[runtime] Use MonoError for mono_type_get_object

diff --git a/mono/metadata/cominterop.c b/mono/metadata/cominterop.c
index 0035e44f1f956d1d77410183755b689ef9dc06de..162e7436406f30b3e0e3e46cb618c3a2e1031d19 100644 (file)
--- a/mono/metadata/cominterop.c
+++ b/mono/metadata/cominterop.c
@@ -35,6 +35,8 @@
 #include "mono/utils/mono-counters.h"
 #include "mono/utils/strenc.h"
 #include "mono/utils/atomic.h"
+#include "mono/utils/mono-error.h"
+#include "mono/utils/mono-error-internals.h"
 #include <string.h>
 #include <errno.h>
 
@@ -520,11 +522,17 @@ cominterop_get_hresult_for_exception (MonoException* exc)
 static MonoReflectionType *
 cominterop_type_from_handle (MonoType *handle)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoDomain *domain = mono_domain_get (); 
        MonoClass *klass = mono_class_from_mono_type (handle);
 
        mono_class_init (klass);
-       return mono_type_get_object (domain, handle);
+
+       ret = mono_type_get_object_checked (domain, handle, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+       return ret;
 }
 
 void

diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c
index 8bfbdb3c1a515594c880f65fb62fb27fb362a550..bc41710796640620b3a6b6c42ee5c21ac79fbd25 100644 (file)
--- a/mono/metadata/icall.c
+++ b/mono/metadata/icall.c
@@ -1125,12 +1125,18 @@ ves_icall_System_ValueType_Equals (MonoObject *this_obj, MonoObject *that, MonoA
 ICALL_EXPORT MonoReflectionType *
 ves_icall_System_Object_GetType (MonoObject *obj)
 {
+       MonoError error;
+       MonoReflectionType *ret;
 #ifndef DISABLE_REMOTING
        if (obj->vtable->klass == mono_defaults.transparent_proxy_class)
-               return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg);
+               ret = mono_type_get_object_checked (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg, &error);
        else
 #endif
-               return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg);
+               ret = mono_type_get_object_checked (mono_object_domain (obj), &obj->vtable->klass->byval_arg, &error);
+
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT void
@@ -1256,6 +1262,8 @@ get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed
 static MonoReflectionType *
 type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoMethod *m, *dest;
 
        MonoType *type = NULL;
@@ -1309,7 +1317,10 @@ type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase)
        if (!type) 
                return NULL;
 
-       return mono_type_get_object (mono_domain_get (), type);
+       ret = mono_type_get_object_checked (mono_domain_get (), type, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+       return ret;
 }
 
 #ifdef UNUSED
@@ -1384,9 +1395,14 @@ ves_icall_type_from_name (MonoString *name,
 ICALL_EXPORT MonoReflectionType*
 ves_icall_type_from_handle (MonoType *handle)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoDomain *domain = mono_domain_get (); 
 
-       return mono_type_get_object (domain, handle);
+       ret = mono_type_get_object_checked (domain, handle, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 /* System.TypeCode */
@@ -1644,6 +1660,7 @@ ICALL_EXPORT void
 ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
 {
        MonoError error;
+       MonoReflectionType *rt;
        MonoDomain *domain = mono_domain_get ();
        MonoMethodSignature* sig;
 
@@ -1651,9 +1668,16 @@ ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
        if (!mono_error_ok (&error))
                mono_error_raise_exception (&error);
 
+       rt = mono_type_get_object_checked (domain, &method->klass->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       MONO_STRUCT_SETREF (info, parent, rt);
+
+       rt = mono_type_get_object_checked (domain, sig->ret, &error);
+       mono_error_raise_exception (&error);
+
+       MONO_STRUCT_SETREF (info, ret, rt);
 
-       MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &method->klass->byval_arg));
-       MONO_STRUCT_SETREF (info, ret, mono_type_get_object (domain, sig->ret));
        info->attrs = method->flags;
        info->implattrs = method->iflags;
        if (sig->call_convention == MONO_CALL_DEFAULT)
@@ -1711,11 +1735,17 @@ ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field)
 ICALL_EXPORT MonoReflectionType*
 ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoClass *parent;
 
        parent = declaring? field->field->parent: field->klass;
 
-       return mono_type_get_object (mono_object_domain (field), &parent->byval_arg);
+       ret = mono_type_get_object_checked (mono_object_domain (field), &parent->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
+
 }
 
 ICALL_EXPORT MonoObject *
@@ -1938,11 +1968,16 @@ ICALL_EXPORT MonoReflectionType*
 ves_icall_MonoField_ResolveType (MonoReflectionField *ref_field)
 {
        MonoError error;
-       MonoClassField *field = ref_field->field;
-       MonoType *type = mono_field_get_type_checked (field, &error);
-       if (!mono_error_ok (&error))
-               mono_error_raise_exception (&error);
-       return mono_type_get_object (mono_object_domain (ref_field), type);
+       MonoReflectionType *ret;
+       MonoType *type;
+
+       type = mono_field_get_type_checked (ref_field->field, &error);
+       mono_error_raise_exception (&error);
+
+       ret = mono_type_get_object_checked (mono_object_domain (ref_field), type, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 /* From MonoProperty.cs */
@@ -1958,13 +1993,23 @@ typedef enum {
 ICALL_EXPORT void
 ves_icall_get_property_info (const MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoDomain *domain = mono_object_domain (property); 
        const MonoProperty *pproperty = property->property;
 
-       if ((req_info & PInfo_ReflectedType) != 0)
-               MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->klass->byval_arg));
-       if ((req_info & PInfo_DeclaringType) != 0)
-               MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &pproperty->parent->byval_arg));
+       if ((req_info & PInfo_ReflectedType) != 0) {
+               rt = mono_type_get_object_checked (domain, &property->klass->byval_arg, &error);
+               mono_error_raise_exception (&error);
+
+               MONO_STRUCT_SETREF (info, parent, rt);
+       }
+       if ((req_info & PInfo_DeclaringType) != 0) {
+               rt = mono_type_get_object_checked (domain, &pproperty->parent->byval_arg, &error);
+               mono_error_raise_exception (&error);
+
+               MONO_STRUCT_SETREF (info, declaring_type, rt);
+       }
 
        if ((req_info & PInfo_Name) != 0)
                MONO_STRUCT_SETREF (info, name, mono_string_new (domain, pproperty->name));
@@ -1989,10 +2034,19 @@ ves_icall_get_property_info (const MonoReflectionProperty *property, MonoPropert
 ICALL_EXPORT void
 ves_icall_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoDomain *domain = mono_object_domain (event); 
 
-       MONO_STRUCT_SETREF (info, reflected_type, mono_type_get_object (domain, &event->klass->byval_arg));
-       MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &event->event->parent->byval_arg));
+       rt = mono_type_get_object_checked (domain, &event->klass->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       MONO_STRUCT_SETREF (info, reflected_type, rt);
+
+       rt = mono_type_get_object_checked (domain, &event->event->parent->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       MONO_STRUCT_SETREF (info, declaring_type, rt);
 
        MONO_STRUCT_SETREF (info, name, mono_string_new (domain, event->event->name));
        info->attrs = event->event->attrs;
@@ -2044,6 +2098,7 @@ typedef struct {
 static void
 fill_iface_array (gpointer key, gpointer value, gpointer user_data)
 {
+       MonoReflectionType *rt;
        FillIfaceArrayData *data = (FillIfaceArrayData *)user_data;
        MonoClass *ic = (MonoClass *)key;
        MonoType *ret = &ic->byval_arg, *inflated = NULL;
@@ -2057,7 +2112,11 @@ fill_iface_array (gpointer key, gpointer value, gpointer user_data)
                        return;
        }
 
-       mono_array_setref (data->iface_array, data->next_idx++, mono_type_get_object (data->domain, ret));
+       rt = mono_type_get_object_checked (data->domain, ret, data->error);
+       if (!mono_error_ok (data->error))
+               return;
+
+       mono_array_setref (data->iface_array, data->next_idx++, rt);
 
        if (inflated)
                mono_metadata_free_type (inflated);
@@ -2175,10 +2234,16 @@ ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *
 ICALL_EXPORT MonoReflectionType*
 ves_icall_MonoType_GetElementType (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoClass *klass;
 
-       if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY)
-               return mono_type_get_object (mono_object_domain (type), &type->type->data.klass->byval_arg);
+       if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY) {
+               ret = mono_type_get_object_checked (mono_object_domain (type), &type->type->data.klass->byval_arg, &error);
+               mono_error_raise_exception (&error);
+
+               return ret;
+       }
 
        klass = mono_class_from_mono_type (type->type);
        mono_class_init_or_throw (klass);
@@ -2186,23 +2251,36 @@ ves_icall_MonoType_GetElementType (MonoReflectionType *type)
        // GetElementType should only return a type for:
        // Array Pointer PassedByRef
        if (type->type->byref)
-               return mono_type_get_object (mono_object_domain (type), &klass->byval_arg);
+               ret = mono_type_get_object_checked (mono_object_domain (type), &klass->byval_arg, &error);
        else if (klass->element_class && MONO_CLASS_IS_ARRAY (klass))
-               return mono_type_get_object (mono_object_domain (type), &klass->element_class->byval_arg);
+               ret = mono_type_get_object_checked (mono_object_domain (type), &klass->element_class->byval_arg, &error);
        else if (klass->element_class && type->type->type == MONO_TYPE_PTR)
-               return mono_type_get_object (mono_object_domain (type), &klass->element_class->byval_arg);
+               ret = mono_type_get_object_checked (mono_object_domain (type), &klass->element_class->byval_arg, &error);
        else
                return NULL;
+
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT MonoReflectionType*
 ves_icall_get_type_parent (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoReflectionType *ret;
+
        if (type->type->byref)
                return NULL;
 
        MonoClass *klass = mono_class_from_mono_type (type->type);
-       return klass->parent ? mono_type_get_object (mono_object_domain (type), &klass->parent->byval_arg): NULL;
+       if (!klass->parent)
+               return NULL;
+
+       ret = mono_type_get_object_checked (mono_object_domain (type), &klass->parent->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT MonoBoolean
@@ -2250,6 +2328,8 @@ ves_icall_MonoType_get_Assembly (MonoReflectionType *type)
 ICALL_EXPORT MonoReflectionType*
 ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoDomain *domain = mono_domain_get ();
        MonoClass *klass;
 
@@ -2265,7 +2345,13 @@ ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
                klass = mono_class_from_mono_type (type->type)->nested_in;
        }
 
-       return klass ? mono_type_get_object (domain, &klass->byval_arg) : NULL;
+       if (!klass)
+               return NULL;
+
+       ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT MonoString*
@@ -2327,6 +2413,8 @@ create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count)
 ICALL_EXPORT MonoArray*
 ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoArray *res;
        MonoClass *klass, *pklass;
        MonoDomain *domain = mono_object_domain (type);
@@ -2339,13 +2427,21 @@ ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean ru
                res = create_type_array (domain, runtimeTypeArray, container->type_argc);
                for (i = 0; i < container->type_argc; ++i) {
                        pklass = mono_class_from_generic_parameter_internal (mono_generic_container_get_param (container, i));
-                       mono_array_setref (res, i, mono_type_get_object (domain, &pklass->byval_arg));
+
+                       rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
+                       mono_error_raise_exception (&error);
+
+                       mono_array_setref (res, i, rt);
                }
        } else if (klass->generic_class) {
                MonoGenericInst *inst = klass->generic_class->context.class_inst;
                res = create_type_array (domain, runtimeTypeArray, inst->type_argc);
-               for (i = 0; i < inst->type_argc; ++i)
-                       mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
+               for (i = 0; i < inst->type_argc; ++i) {
+                       rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
+                       mono_error_raise_exception (&error);
+
+                       mono_array_setref (res, i, rt);
+               }
        } else {
                res = NULL;
        }
@@ -2370,6 +2466,8 @@ ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType *type)
 ICALL_EXPORT MonoReflectionType*
 ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoClass *klass;
 
        if (type->type->byref)
@@ -2388,8 +2486,12 @@ ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
 
                if (generic_class->wastypebuilder && tb)
                        return (MonoReflectionType *)tb;
-               else
-                       return mono_type_get_object (mono_object_domain (type), &generic_class->byval_arg);
+               else {
+                       ret = mono_type_get_object_checked (mono_object_domain (type), &generic_class->byval_arg, &error);
+                       mono_error_raise_exception (&error);
+
+                       return ret;
+               }
        }
        return NULL;
 }
@@ -2397,6 +2499,8 @@ ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType *type)
 ICALL_EXPORT MonoReflectionType*
 ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoClass *klass;
        MonoType *geninst, **types;
        int i, count;
@@ -2425,7 +2529,10 @@ ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
                return NULL;
        }
 
-       return mono_type_get_object (mono_object_domain (type), geninst);
+       ret = mono_type_get_object_checked (mono_object_domain (type), geninst, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT gboolean
@@ -2465,6 +2572,8 @@ ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
 ICALL_EXPORT MonoArray *
 ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoGenericParamInfo *param_info;
        MonoDomain *domain;
        MonoClass **ptr;
@@ -2479,8 +2588,12 @@ ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
                ;
 
        res = mono_array_new (domain, mono_defaults.monotype_class, count);
-       for (i = 0; i < count; i++)
-               mono_array_setref (res, i, mono_type_get_object (domain, &param_info->constraints [i]->byval_arg));
+       for (i = 0; i < count; i++) {
+               rt = mono_type_get_object_checked (domain, &param_info->constraints [i]->byval_arg, &error);
+               mono_error_raise_exception (&error);
+
+               mono_array_setref (res, i, rt);
+       }
 
 
        return res;
@@ -2666,6 +2779,8 @@ ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method
 ICALL_EXPORT MonoArray*
 ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoArray *res;
        MonoDomain *domain;
        int count, i;
@@ -2679,8 +2794,12 @@ ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
                        count = inst->type_argc;
                        res = mono_array_new (domain, mono_defaults.systemtype_class, count);
 
-                       for (i = 0; i < count; i++)
-                               mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i]));
+                       for (i = 0; i < count; i++) {
+                               rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
+                               mono_error_raise_exception (&error);
+
+                               mono_array_setref (res, i, rt);
+                       }
 
                        return res;
                }
@@ -2693,8 +2812,11 @@ ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
                MonoGenericContainer *container = mono_method_get_generic_container (method->method);
                MonoGenericParam *param = mono_generic_container_get_param (container, i);
                MonoClass *pklass = mono_class_from_generic_parameter_internal (param);
-               mono_array_setref (res, i,
-                               mono_type_get_object (domain, &pklass->byval_arg));
+
+               rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
+               mono_error_raise_exception (&error);
+
+               mono_array_setref (res, i, rt);
        }
 
        return res;
@@ -3073,6 +3195,8 @@ ves_icall_System_Enum_get_value (MonoObject *eobj)
 ICALL_EXPORT MonoReflectionType *
 ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoType *etype;
        MonoClass *klass;
 
@@ -3085,7 +3209,10 @@ ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type)
                return NULL;
        }
 
-       return mono_type_get_object (mono_object_domain (type), etype);
+       ret = mono_type_get_object_checked (mono_object_domain (type), etype, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT int
@@ -3904,10 +4031,11 @@ loader_error:
 ICALL_EXPORT MonoArray*
 ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint32 bflags)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoDomain *domain; 
        MonoClass *klass;
        MonoArray *res;
-       MonoObject *member;
        int i, match;
        MonoClass *nested;
        gpointer iter;
@@ -3955,8 +4083,10 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint
                                continue;
                }
 
-               member = (MonoObject*)mono_type_get_object (domain, &nested->byval_arg);
-               mono_ptr_array_append (tmp_array, member);
+               rt = mono_type_get_object_checked (domain, &nested->byval_arg, &error);
+               mono_error_raise_exception (&error);
+
+               mono_ptr_array_append (tmp_array, (MonoObject*) rt);
        }
 
        res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array));
@@ -3975,6 +4105,8 @@ ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint
 ICALL_EXPORT MonoReflectionType*
 ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *assembly, MonoReflectionModule *module, MonoString *name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        gchar *str;
        MonoType *type = NULL;
        MonoTypeNameParse info;
@@ -4080,7 +4212,10 @@ ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *as
        }
 
        /* g_print ("got it\n"); */
-       return mono_type_get_object (mono_object_domain (assembly), type);
+       ret = mono_type_get_object_checked (mono_object_domain (assembly), type, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 static gboolean
@@ -4979,6 +5114,8 @@ mono_module_type_is_visible (MonoTableInfo *tdef, MonoImage *image, int type)
 static MonoArray*
 mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoArray *res;
        MonoClass *klass;
        MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
@@ -4999,12 +5136,15 @@ mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **excepti
        count = 0;
        for (i = 1; i < tdef->rows; ++i) {
                if (!exportedOnly || mono_module_type_is_visible (tdef, image, i + 1)) {
-                       MonoError error;
                        klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, &error);
                        mono_loader_assert_no_error (); /* Plug any leaks */
+                       g_assert (mono_error_ok (&error));
                        
                        if (klass) {
-                               mono_array_setref (res, count, mono_type_get_object (domain, &klass->byval_arg));
+                               rt = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+                               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+                               mono_array_setref (res, count, rt);
                        } else {
                                MonoException *ex = mono_error_convert_to_exception (&error);
                                mono_array_setref (*exceptions, count, ex);
@@ -5154,6 +5294,7 @@ ICALL_EXPORT MonoReflectionType*
 ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
 {
        MonoError error;
+       MonoReflectionType *ret;
        MonoDomain *domain = mono_object_domain (module); 
        MonoClass *klass;
 
@@ -5165,7 +5306,11 @@ ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
 
        klass = mono_class_get_checked (module->image, 1 | MONO_TOKEN_TYPE_DEF, &error);
        mono_error_raise_exception (&error);
-       return mono_type_get_object (domain, &klass->byval_arg);
+
+       ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT void
@@ -5441,6 +5586,8 @@ ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32
 ICALL_EXPORT MonoObject*
 ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
 {
+       MonoError merror;
+       MonoObject *ret;
        int table = mono_metadata_token_table (token);
 
        *error = ResolveTokenError_Other;
@@ -5450,8 +5597,12 @@ ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32
        case MONO_TABLE_TYPEREF:
        case MONO_TABLE_TYPESPEC: {
                MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
-               if (t)
-                       return (MonoObject*)mono_type_get_object (mono_domain_get (), t);
+               if (t) {
+                       ret = (MonoObject*) mono_type_get_object_checked (mono_domain_get (), t, &merror);
+                       mono_error_raise_exception (&merror);
+
+                       return ret;
+               }
                else
                        return NULL;
        }
@@ -5529,6 +5680,8 @@ ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 t
 ICALL_EXPORT MonoReflectionType*
 ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoClass *klass;
        int isbyref = 0, rank;
        char *str = mono_string_to_utf8 (smodifiers);
@@ -5546,9 +5699,13 @@ ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, Mon
                        }
                        isbyref = 1;
                        p++;
+
                        g_free (str);
-                       return mono_type_get_object (mono_object_domain (tb), &klass->this_arg);
-                       break;
+
+                       ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->this_arg, &error);
+                       mono_error_raise_exception (&error);
+
+                       return ret;
                case '*':
                        klass = mono_ptr_class_get (&klass->byval_arg);
                        mono_class_init (klass);
@@ -5580,8 +5737,13 @@ ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, Mon
                        break;
                }
        }
+
        g_free (str);
-       return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
+
+       ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT MonoBoolean
@@ -5613,6 +5775,8 @@ check_for_invalid_type (MonoClass *klass)
 ICALL_EXPORT MonoReflectionType *
 ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoClass *klass, *aklass;
 
        klass = mono_class_from_mono_type (type->type);
@@ -5623,24 +5787,34 @@ ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
        else
                aklass = mono_bounded_array_class_get (klass, rank, TRUE);
 
-       return mono_type_get_object (mono_object_domain (type), &aklass->byval_arg);
+       ret = mono_type_get_object_checked (mono_object_domain (type), &aklass->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT MonoReflectionType *
 ves_icall_Type_make_byref_type (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoClass *klass;
 
        klass = mono_class_from_mono_type (type->type);
        mono_class_init_or_throw (klass);
        check_for_invalid_type (klass);
 
-       return mono_type_get_object (mono_object_domain (type), &klass->this_arg);
+       ret = mono_type_get_object_checked (mono_object_domain (type), &klass->this_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT MonoReflectionType *
 ves_icall_Type_MakePointerType (MonoReflectionType *type)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoClass *klass, *pklass;
 
        klass = mono_class_from_mono_type (type->type);
@@ -5649,7 +5823,10 @@ ves_icall_Type_MakePointerType (MonoReflectionType *type)
 
        pklass = mono_ptr_class_get (type->type);
 
-       return mono_type_get_object (mono_object_domain (type), &pklass->byval_arg);
+       ret = mono_type_get_object_checked (mono_object_domain (type), &pklass->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 
 ICALL_EXPORT MonoObject *
@@ -5832,7 +6009,11 @@ ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this_obj, MonoStri
 ICALL_EXPORT MonoReflectionType *
 ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp)
 {
-       return mono_type_get_object (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg);
+       MonoError error;
+       MonoReflectionType *ret = mono_type_get_object_checked (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
 }
 #endif
 
@@ -7037,6 +7218,8 @@ ves_icall_System_NumberFormatter_GetFormatterTables (guint64 const **mantissas,
 static MonoArray*
 type_array_from_modifiers (MonoImage *image, MonoType *type, int optional)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoArray *res;
        int i, count = 0;
        for (i = 0; i < type->num_mods; ++i) {
@@ -7049,10 +7232,13 @@ type_array_from_modifiers (MonoImage *image, MonoType *type, int optional)
        count = 0;
        for (i = 0; i < type->num_mods; ++i) {
                if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) {
-                       MonoError error;
                        MonoClass *klass = mono_class_get_checked (image, type->modifiers [i].token, &error);
                        mono_error_raise_exception (&error); /* this is safe, no cleanup needed on callers */ 
-                       mono_array_setref (res, count, mono_type_get_object (mono_domain_get (), &klass->byval_arg));
+
+                       rt = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, &error);
+                       mono_error_raise_exception (&error);
+
+                       mono_array_setref (res, count, rt);
                        count++;
                }
        }

diff --git a/mono/metadata/object.c b/mono/metadata/object.c
index ffae02f394ec3eb484c6430ee932748acc1bcaf7..bd31aaa2a8be8a431b5335ba6ebdf626fcfcfadb 100644 (file)
--- a/mono/metadata/object.c
+++ b/mono/metadata/object.c
@@ -38,6 +38,7 @@
 #include "mono/metadata/mono-debug-debugger.h"
 #include <mono/metadata/gc-internals.h>
 #include <mono/metadata/verify-internals.h>
+#include <mono/metadata/reflection-internals.h>
 #include <mono/utils/strenc.h>
 #include <mono/utils/mono-counters.h>
 #include <mono/utils/mono-error-internals.h>
@@ -1928,6 +1929,7 @@ mono_class_create_runtime_vtable (MonoDomain *domain, MonoClass *klass, gboolean
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        MonoVTable *vt;
        MonoClassRuntimeInfo *runtime_info, *old_info;
        MonoClassField *field;
@@ -2174,7 +2176,9 @@ mono_class_create_runtime_vtable (MonoDomain *domain, MonoClass *klass, gboolean
        /* Special case System.MonoType to avoid infinite recursion */
        if (klass != mono_defaults.monotype_class) {
                /*FIXME check for OOM*/
-               vt->type = mono_type_get_object (domain, &klass->byval_arg);
+               vt->type = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
                if (mono_object_get_class ((MonoObject *)vt->type) != mono_defaults.monotype_class)
                        /* This is unregistered in
                           unregister_vtable_reflection_type() in
@@ -2228,7 +2232,9 @@ mono_class_create_runtime_vtable (MonoDomain *domain, MonoClass *klass, gboolean
 
        if (klass == mono_defaults.monotype_class) {
                /*FIXME check for OOM*/
-               vt->type = mono_type_get_object (domain, &klass->byval_arg);
+               vt->type = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
                if (mono_object_get_class ((MonoObject *)vt->type) != mono_defaults.monotype_class)
                        /* This is unregistered in
                           unregister_vtable_reflection_type() in
@@ -3214,6 +3220,7 @@ mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObje
 {      
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        MonoObject *o;
        MonoClass *klass;
        MonoVTable *vtable = NULL;
@@ -3222,7 +3229,6 @@ mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObje
        gboolean is_ref = FALSE;
        gboolean is_literal = FALSE;
        gboolean is_ptr = FALSE;
-       MonoError error;
        MonoType *type = mono_field_get_type_checked (field, &error);
 
        if (!mono_error_ok (&error))
@@ -3314,7 +3320,8 @@ mono_field_get_value_object (MonoDomain *domain, MonoClassField *field, MonoObje
 
                /* MONO_TYPE_PTR is passed by value to runtime_invoke () */
                args [0] = ptr ? *ptr : NULL;
-               args [1] = mono_type_get_object (mono_domain_get (), type);
+               args [1] = mono_type_get_object_checked (mono_domain_get (), type, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
 
                return mono_runtime_invoke (m, NULL, args, NULL);
        }
@@ -3901,6 +3908,7 @@ make_transparent_proxy (MonoObject *obj, gboolean *failure, MonoObject **exc)
 
        static MonoMethod *get_proxy_method;
 
+       MonoError error;
        MonoDomain *domain = mono_domain_get ();
        MonoRealProxy *real_proxy;
        MonoReflectionType *reflection_type;
@@ -3912,7 +3920,8 @@ make_transparent_proxy (MonoObject *obj, gboolean *failure, MonoObject **exc)
        g_assert (mono_class_is_marshalbyref (obj->vtable->klass));
 
        real_proxy = (MonoRealProxy*) mono_object_new (domain, mono_defaults.real_proxy_class);
-       reflection_type = mono_type_get_object (domain, &obj->vtable->klass->byval_arg);
+       reflection_type = mono_type_get_object_checked (domain, &obj->vtable->klass->byval_arg, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        MONO_OBJECT_SETREF (real_proxy, class_to_proxy, reflection_type);
        MONO_OBJECT_SETREF (real_proxy, unwrapped_server, obj);
@@ -4300,6 +4309,7 @@ mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        MonoMethodSignature *sig = mono_method_signature (method);
        gpointer *pa = NULL;
        MonoObject *res;
@@ -4451,7 +4461,9 @@ mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
 
                        g_assert (res->vtable->klass == mono_defaults.int_class);
                        box_args [0] = ((MonoIntPtr*)res)->m_value;
-                       box_args [1] = mono_type_get_object (mono_domain_get (), sig->ret);
+                       box_args [1] = mono_type_get_object_checked (mono_domain_get (), sig->ret, &error);
+                       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
                        res = mono_runtime_invoke (box_method, NULL, box_args, &box_exc);
                        g_assert (!box_exc);
                }
@@ -4577,7 +4589,9 @@ mono_object_new_specific_checked (MonoVTable *vtable, MonoError *error)
                        vtable->domain->create_proxy_for_type_method = im;
                }
        
-               pa [0] = mono_type_get_object (mono_domain_get (), &vtable->klass->byval_arg);
+               pa [0] = mono_type_get_object_checked (mono_domain_get (), &vtable->klass->byval_arg, error);
+               if (!mono_error_ok (error))
+                       return NULL;
 
                o = mono_runtime_invoke (im, NULL, pa, NULL);           
                if (o != NULL) return o;
@@ -5546,6 +5560,7 @@ mono_object_isinst_mbyref (MonoObject *obj, MonoClass *klass)
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        MonoVTable *vt;
 
        if (!obj)
@@ -5586,7 +5601,8 @@ mono_object_isinst_mbyref (MonoObject *obj, MonoClass *klass)
                im = mono_object_get_virtual_method (rp, im);
                g_assert (im);
        
-               pa [0] = mono_type_get_object (domain, &klass->byval_arg);
+               pa [0] = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
                pa [1] = obj;
 
                res = mono_runtime_invoke (im, rp, pa, NULL);

diff --git a/mono/metadata/reflection-internals.h b/mono/metadata/reflection-internals.h
index 54eee9f0c73230f7b600c64c6f46a7238abfad7d..144d1130fc16b97eb5a2f7c03c0e47c7ad024851 100644 (file)
--- a/mono/metadata/reflection-internals.h
+++ b/mono/metadata/reflection-internals.h
@@ -17,4 +17,7 @@ mono_identifier_unescape_type_name_chars (char* identifier);
 MonoImage *
 mono_find_dynamic_image_owner (void *ptr);
 
+MonoReflectionType*
+mono_type_get_object_checked (MonoDomain *domain, MonoType *type, MonoError *error);
+
 #endif /* __MONO_METADATA_REFLECTION_INTERNALS_H__ */

diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c
index 4bba73e36200d71c2a598c2c3b606198b0ee02f4..96316adef5b17d72481be979ba7287e96a77ff57 100644 (file)
--- a/mono/metadata/reflection.c
+++ b/mono/metadata/reflection.c
@@ -1674,12 +1674,14 @@ reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoRe
 {
        MONO_REQ_GC_UNSAFE_MODE;
 
+       MonoError error;
        const char *name = mb->attrs & METHOD_ATTRIBUTE_STATIC ? ".cctor": ".ctor";
 
        memset (rmb, 0, sizeof (ReflectionMethodBuilder));
 
        rmb->ilgen = mb->ilgen;
-       rmb->rtype = mono_type_get_object (mono_domain_get (), &mono_defaults.void_class->byval_arg);
+       rmb->rtype = mono_type_get_object_checked (mono_domain_get (), &mono_defaults.void_class->byval_arg, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
        rmb->parameters = mb->parameters;
        rmb->generic_params = NULL;
        rmb->generic_container = NULL;
@@ -6691,9 +6693,22 @@ MonoReflectionType*
 mono_type_get_object (MonoDomain *domain, MonoType *type)
 {
        MonoError error;
+       MonoReflectionType *ret = mono_type_get_object_checked (domain, type, &error);
+       mono_error_raise_exception (&error);
+
+       return ret;
+}
+
+MonoReflectionType*
+mono_type_get_object_checked (MonoDomain *domain, MonoType *type, MonoError *error)
+{
        MonoType *norm_type;
        MonoReflectionType *res;
-       MonoClass *klass = mono_class_from_mono_type (type);
+       MonoClass *klass;
+
+       mono_error_init (error);
+
+       klass = mono_class_from_mono_type (type);
 
        /*we must avoid using @type as it might have come
         * from a mono_metadata_type_dup and the caller
@@ -6739,7 +6754,9 @@ mono_type_get_object (MonoDomain *domain, MonoType *type)
         */
        norm_type = mono_type_normalize (type);
        if (norm_type != type) {
-               res = mono_type_get_object (domain, norm_type);
+               res = mono_type_get_object_checked (domain, norm_type, error);
+               if (!mono_error_ok (error))
+                       return NULL;
                mono_g_hash_table_insert (domain->type_hash, type, res);
                mono_domain_unlock (domain);
                mono_loader_unlock ();
@@ -6785,8 +6802,10 @@ mono_type_get_object (MonoDomain *domain, MonoType *type)
                }
        }
        /* This is stored in vtables/JITted code so it has to be pinned */
-       res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.monotype_class, &error);
-       mono_error_raise_exception (&error);
+       res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.monotype_class, error);
+       if (!mono_error_ok (error))
+               return NULL;
+
        res->type = type;
        mono_g_hash_table_insert (domain->type_hash, type, res);
 
@@ -6817,6 +6836,8 @@ mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refcl
        static MonoClass *System_Reflection_MonoCMethod = NULL;
        static MonoClass *System_Reflection_MonoGenericMethod = NULL;
        static MonoClass *System_Reflection_MonoGenericCMethod = NULL;
+       MonoError error;
+       MonoReflectionType *rt;
        MonoClass *klass;
        MonoReflectionMethod *ret;
 
@@ -6837,8 +6858,14 @@ mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refcl
                }
                gret = (MonoReflectionGenericMethod*)mono_object_new (domain, klass);
                gret->method.method = method;
+
                MONO_OBJECT_SETREF (gret, method.name, mono_string_new (domain, method->name));
-               MONO_OBJECT_SETREF (gret, method.reftype, mono_type_get_object (domain, &refclass->byval_arg));
+
+               rt = mono_type_get_object_checked (domain, &refclass->byval_arg, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+               MONO_OBJECT_SETREF (gret, method.reftype, rt);
+
                CACHE_OBJECT (MonoReflectionMethod *, method, (MonoReflectionMethod*)gret, refclass);
        }
 
@@ -6858,7 +6885,12 @@ mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refcl
        }
        ret = (MonoReflectionMethod*)mono_object_new (domain, klass);
        ret->method = method;
-       MONO_OBJECT_SETREF (ret, reftype, mono_type_get_object (domain, &refclass->byval_arg));
+
+       rt = mono_type_get_object_checked (domain, &refclass->byval_arg, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */;
+
+       MONO_OBJECT_SETREF (ret, reftype, rt);
+
        CACHE_OBJECT (MonoReflectionMethod *, method, ret, refclass);
 }
 
@@ -6899,6 +6931,8 @@ mono_method_clear_object (MonoDomain *domain, MonoMethod *method)
 MonoReflectionField*
 mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field)
 {
+       MonoError error;
+       MonoReflectionType *rt;
        MonoReflectionField *res;
        static MonoClass *monofield_klass;
 
@@ -6912,10 +6946,18 @@ mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *fie
 
        if (is_field_on_inst (field)) {
                res->attrs = get_field_on_inst_generic_type (field)->attrs;
-               MONO_OBJECT_SETREF (res, type, mono_type_get_object (domain, field->type));
+
+               rt = mono_type_get_object_checked (domain, field->type, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+               MONO_OBJECT_SETREF (res, type, rt);
        } else {
-               if (field->type)
-                       MONO_OBJECT_SETREF (res, type, mono_type_get_object (domain, field->type));
+               if (field->type) {
+                       rt = mono_type_get_object_checked (domain, field->type, &error);
+                       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+                       MONO_OBJECT_SETREF (res, type, rt);
+               }
                res->attrs = mono_field_get_flags (field);
        }
        CACHE_OBJECT (MonoReflectionField *, field, res, klass);
@@ -7040,6 +7082,7 @@ mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoCla
        MonoMarshalSpec **mspecs;
        MonoMethodSignature *sig;
        MonoVTable *pinfo_vtable;
+       MonoReflectionType *rt;
        int i;
 
        if (!System_Reflection_ParameterInfo_array) {
@@ -7088,9 +7131,16 @@ mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoCla
        for (i = 0; i < sig->param_count; ++i) {
                param = (MonoReflectionParameter *) mono_object_new_specific_checked (pinfo_vtable, &error);
                mono_error_raise_exception (&error); /* FIXME don't raise here */
-               MONO_OBJECT_SETREF (param, ClassImpl, mono_type_get_object (domain, sig->params [i]));
+
+               rt = mono_type_get_object_checked (domain, sig->params [i], &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+               MONO_OBJECT_SETREF (param, ClassImpl, rt);
+
                MONO_OBJECT_SETREF (param, MemberImpl, (MonoObject*)member);
+
                MONO_OBJECT_SETREF (param, NameImpl, mono_string_new (domain, names [i]));
+
                param->PositionImpl = i;
                param->AttrsImpl = sig->params [i]->attrs;
 
@@ -7171,9 +7221,11 @@ mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
        static MonoClass *System_Reflection_MethodBody = NULL;
        static MonoClass *System_Reflection_LocalVariableInfo = NULL;
        static MonoClass *System_Reflection_ExceptionHandlingClause = NULL;
+       MonoError error;
        MonoReflectionMethodBody *ret;
        MonoMethodHeader *header;
        MonoImage *image;
+       MonoReflectionType *rt;
        guint32 method_rva, local_var_sig_token;
     char *ptr;
        unsigned char format, flags;
@@ -7236,7 +7288,12 @@ mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
        MONO_OBJECT_SETREF (ret, locals, mono_array_new_cached (domain, System_Reflection_LocalVariableInfo, header->num_locals));
        for (i = 0; i < header->num_locals; ++i) {
                MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new (domain, System_Reflection_LocalVariableInfo);
-               MONO_OBJECT_SETREF (info, local_type, mono_type_get_object (domain, header->locals [i]));
+
+               rt = mono_type_get_object_checked (domain, header->locals [i], &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+               MONO_OBJECT_SETREF (info, local_type, rt);
+
                info->is_pinned = header->locals [i]->pinned;
                info->local_index = i;
                mono_array_setref (ret->locals, i, info);
@@ -7255,8 +7312,12 @@ mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
                info->handler_length = clause->handler_len;
                if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER)
                        info->filter_offset = clause->data.filter_offset;
-               else if (clause->data.catch_class)
-                       MONO_OBJECT_SETREF (info, catch_type, mono_type_get_object (mono_domain_get (), &clause->data.catch_class->byval_arg));
+               else if (clause->data.catch_class) {
+                       rt = mono_type_get_object_checked (mono_domain_get (), &clause->data.catch_class->byval_arg, &error);
+                       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+                       MONO_OBJECT_SETREF (info, catch_type, rt);
+               }
 
                mono_array_setref (ret->clauses, i, info);
        }
@@ -7830,6 +7891,7 @@ _mono_reflection_get_type_from_info (MonoTypeNameParse *info, MonoImage *image,
 static MonoType*
 mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase)
 {
+       MonoError error;
        MonoClass *klass;
        GList *mod;
        int modval;
@@ -7926,7 +7988,8 @@ mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoT
                        }
                }
 
-               the_type = mono_type_get_object (mono_domain_get (), &klass->byval_arg);
+               the_type = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
 
                instance = mono_reflection_bind_generic_parameters (
                        the_type, info->type_arguments->len, type_args);
@@ -8298,6 +8361,7 @@ handle_enum:
                *end = p + slen;
                return mono_string_new_len (mono_domain_get (), p, slen);
        case MONO_TYPE_CLASS: {
+               MonoReflectionType *rt;
                char *n;
                MonoType *t;
                if (*p == (char)0xFF) {
@@ -8317,7 +8381,12 @@ handle_type:
                }
                g_free (n);
                *end = p + slen;
-               return mono_type_get_object (mono_domain_get (), t);
+
+               rt = mono_type_get_object_checked (mono_domain_get (), t, error);
+               if (!mono_error_ok (error))
+                       return NULL;
+
+               return rt;
        }
        case MONO_TYPE_OBJECT: {
                char subt = *p++;
@@ -8469,6 +8538,7 @@ create_cattr_typed_arg (MonoType *t, MonoObject *val)
 {
        static MonoClass *klass;
        static MonoMethod *ctor;
+       MonoError error;
        MonoObject *retval;
        void *params [2], *unboxed;
 
@@ -8477,7 +8547,9 @@ create_cattr_typed_arg (MonoType *t, MonoObject *val)
        if (!ctor)
                ctor = mono_class_get_method_from_name (klass, ".ctor", 2);
        
-       params [0] = mono_type_get_object (mono_domain_get (), t);
+       params [0] = mono_type_get_object_checked (mono_domain_get (), t, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
        params [1] = val;
        retval = mono_object_new (mono_domain_get (), klass);
        unboxed = mono_object_unbox (retval);
@@ -9732,7 +9804,7 @@ mono_reflection_register_with_runtime (MonoReflectionType *type)
 
        klass = mono_class_from_mono_type (res);
 
-       mono_loader_lock (); /*same locking as mono_type_get_object*/
+       mono_loader_lock (); /*same locking as mono_type_get_object_checked */
        mono_domain_lock (domain);
 
        if (!image_is_dynamic (klass->image)) {
@@ -10588,6 +10660,8 @@ mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, Mono
                                                                                   MonoMarshalSpec *spec)
 {
        static MonoClass *System_Reflection_Emit_MarshalAsAttribute;
+       MonoError error;
+       MonoReflectionType *rt;
        MonoReflectionMarshalAsAttribute *minfo;
        MonoType *mtype;
 
@@ -10616,8 +10690,12 @@ mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, Mono
        case MONO_NATIVE_CUSTOM:
                if (spec->data.custom_data.custom_name) {
                        mtype = mono_reflection_type_from_name (spec->data.custom_data.custom_name, klass->image);
-                       if (mtype)
-                               MONO_OBJECT_SETREF (minfo, marshal_type_ref, mono_type_get_object (domain, mtype));
+                       if (mtype) {
+                               rt = mono_type_get_object_checked (domain, mtype, &error);
+                               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+                               MONO_OBJECT_SETREF (minfo, marshal_type_ref, rt);
+                       }
 
                        MONO_OBJECT_SETREF (minfo, marshal_type, mono_string_new (domain, spec->data.custom_data.custom_name));
                }
@@ -11863,7 +11941,11 @@ mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
        if (klass->wastypebuilder) {
                mono_domain_unlock (domain);
                mono_loader_unlock ();
-               return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
+
+               res = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+               return res;
        }
        /*
         * Fields to set in klass:
@@ -11887,7 +11969,11 @@ mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
                        klass->wastypebuilder = TRUE;
                        mono_loader_unlock ();
                        mono_domain_unlock (domain);
-                       return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
+
+                       res = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
+                       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+                       return res;
                }
        }
 #endif
@@ -11954,7 +12040,9 @@ mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
                mono_raise_exception (mono_get_exception_type_load (tb->name, NULL));
        }
 
-       res = mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
+       res = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
        g_assert (res != (MonoReflectionType*)tb);
 
        return res;
@@ -13195,6 +13283,7 @@ mono_declsec_get_assembly_action (MonoAssembly *assembly, guint32 action, MonoDe
 gboolean
 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass)
 {
+       MonoError error;
        MonoObject *res, *exc;
        void *params [1];
        static MonoClass *System_Reflection_Emit_TypeBuilder = NULL;
@@ -13210,13 +13299,14 @@ mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass)
        }
 
        /* 
-        * The result of mono_type_get_object () might be a System.MonoType but we
+        * The result of mono_type_get_object_checked () might be a System.MonoType but we
         * need a TypeBuilder so use mono_class_get_ref_info (klass).
         */
        g_assert (mono_class_get_ref_info (klass));
        g_assert (!strcmp (((MonoObject*)(mono_class_get_ref_info (klass)))->vtable->klass->name, "TypeBuilder"));
 
-       params [0] = mono_type_get_object (mono_domain_get (), &oklass->byval_arg);
+       params [0] = mono_type_get_object_checked (mono_domain_get (), &oklass->byval_arg, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
 
        res = mono_runtime_invoke (method, (MonoObject*)(mono_class_get_ref_info (klass)), params, &exc);
        if (exc)

diff --git a/mono/metadata/remoting.c b/mono/metadata/remoting.c
index cbe8b3add942c42519b415dfbec92474e5ae30f1..8ca8ae62fdb550f506b55949ba4f8feeac76dd77 100644 (file)
--- a/mono/metadata/remoting.c
+++ b/mono/metadata/remoting.c
@@ -16,6 +16,7 @@
 #include "mono/metadata/tabledefs.h"
 #include "mono/metadata/exception.h"
 #include "mono/metadata/debug-helpers.h"
+#include "mono/metadata/reflection-internals.h"
 
 typedef enum {
        MONO_MARSHAL_NONE,                      /* No marshalling needed */
@@ -199,11 +200,17 @@ mono_remoting_marshal_init (void)
 static MonoReflectionType *
 type_from_handle (MonoType *handle)
 {
+       MonoError error;
+       MonoReflectionType *ret;
        MonoDomain *domain = mono_domain_get (); 
        MonoClass *klass = mono_class_from_mono_type (handle);
 
        mono_class_init (klass);
-       return mono_type_get_object (domain, handle);
+
+       ret = mono_type_get_object_checked (domain, handle, &error);
+       mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+       return ret;
 }
 
 #ifndef DISABLE_JIT

diff --git a/mono/mini/debugger-agent.c b/mono/mini/debugger-agent.c
index 7340ac302cf831db9cfba2b82595583c6e3e9e0f..62598bbb40500cf408cb29ea003fc5307c02d726 100644 (file)
--- a/mono/mini/debugger-agent.c
+++ b/mono/mini/debugger-agent.c
@@ -62,6 +62,7 @@
 #include <mono/metadata/assembly.h>
 #include <mono/metadata/runtime.h>
 #include <mono/metadata/verify-internals.h>
+#include <mono/metadata/reflection-internals.h>
 #include <mono/utils/mono-coop-mutex.h>
 #include <mono/utils/mono-coop-semaphore.h>
 #include <mono/utils/mono-error-internals.h>
@@ -7858,6 +7859,7 @@ collect_interfaces (MonoClass *klass, GHashTable *ifaces, MonoError *error)
 static ErrorCode
 type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint8 *p, guint8 *end, Buffer *buf)
 {
+       MonoError error;
        MonoClass *nested;
        MonoType *type;
        gpointer iter;
@@ -8162,7 +8164,8 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint
                break;
        }
        case CMD_TYPE_GET_OBJECT: {
-               MonoObject *o = (MonoObject*)mono_type_get_object (domain, &klass->byval_arg);
+               MonoObject *o = (MonoObject*)mono_type_get_object_checked (domain, &klass->byval_arg, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
                buffer_add_objid (buf, o);
                break;
        }
@@ -8221,7 +8224,6 @@ type_commands_internal (int command, MonoClass *klass, MonoDomain *domain, guint
        case CMD_TYPE_GET_INTERFACES: {
                MonoClass *parent;
                GHashTable *iface_hash = g_hash_table_new (NULL, NULL);
-               MonoError error;
                MonoClass *tclass, *iface;
                GHashTableIter iter;
 

diff --git a/mono/mini/method-to-ir.c b/mono/mini/method-to-ir.c
index 4c0a925becfeda42c3460cbe2b8bb122ad7dc503..a202b20cf3832d00a9ca72581243b7cd2eca48f7 100644 (file)
--- a/mono/mini/method-to-ir.c
+++ b/mono/mini/method-to-ir.c
@@ -60,6 +60,7 @@
 #include <mono/utils/mono-compiler.h>
 #include <mono/utils/mono-memory-model.h>
 #include <mono/metadata/mono-basic-block.h>
+#include <mono/metadata/reflection-internals.h>
 
 #include "trace.h"
 
@@ -12255,7 +12256,11 @@ mono_method_to_ir (MonoCompile *cfg, MonoMethod *method, MonoBasicBlock *start_b
                                                        EMIT_NEW_TYPE_FROM_HANDLE_CONST (cfg, ins, image, n, generic_context);
                                                }
                                        } else {
-                                               EMIT_NEW_PCONST (cfg, ins, mono_type_get_object (cfg->domain, (MonoType *)handle));
+                                               MonoError error;
+                                               MonoReflectionType *rt = mono_type_get_object_checked (cfg->domain, (MonoType *)handle, &error);
+                                               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+                                               EMIT_NEW_PCONST (cfg, ins, rt);
                                        }
                                        ins->type = STACK_OBJ;
                                        ins->klass = cmethod->klass;

diff --git a/mono/mini/mini-generic-sharing.c b/mono/mini/mini-generic-sharing.c
index a4963295fcbb2f1bce5c014faf3aeb1841d29cf9..94312a18f43d315cecdfb76d58ce66d7325a12d2 100644 (file)
--- a/mono/mini/mini-generic-sharing.c
+++ b/mono/mini/mini-generic-sharing.c
@@ -12,6 +12,7 @@
 
 #include <mono/metadata/class.h>
 #include <mono/metadata/method-builder.h>
+#include <mono/metadata/reflection-internals.h>
 #include <mono/utils/mono-counters.h>
 
 #include "mini.h"
@@ -1468,6 +1469,7 @@ static gpointer
 instantiate_info (MonoDomain *domain, MonoRuntimeGenericContextInfoTemplate *oti,
                                  MonoGenericContext *context, MonoClass *klass)
 {
+       MonoError error;
        gpointer data;
        gboolean temporary;
 
@@ -1516,8 +1518,12 @@ instantiate_info (MonoDomain *domain, MonoRuntimeGenericContextInfoTemplate *oti
        }
        case MONO_RGCTX_INFO_TYPE:
                return data;
-       case MONO_RGCTX_INFO_REFLECTION_TYPE:
-               return mono_type_get_object (domain, (MonoType *)data);
+       case MONO_RGCTX_INFO_REFLECTION_TYPE: {
+               MonoReflectionType *ret = mono_type_get_object_checked (domain, (MonoType *)data, &error);
+               mono_error_raise_exception (&error); /* FIXME don't raise here */
+
+               return ret;
+       }
        case MONO_RGCTX_INFO_METHOD:
                return data;
        case MONO_RGCTX_INFO_GENERIC_METHOD_CODE: {

diff --git a/mono/mini/mini-runtime.c b/mono/mini/mini-runtime.c
index a16063cb2d27920d24bac76e1492efbc4cfd5b4b..514dbbeefaf9ac1d556ad80f21ebd1adcaf4dd10 100644 (file)
--- a/mono/mini/mini-runtime.c
+++ b/mono/mini/mini-runtime.c
@@ -47,6 +47,7 @@
 #include <mono/metadata/mempool-internals.h>
 #include <mono/metadata/attach.h>
 #include <mono/metadata/runtime.h>
+#include <mono/metadata/reflection-internals.h>
 #include <mono/utils/mono-math.h>
 #include <mono/utils/mono-compiler.h>
 #include <mono/utils/mono-counters.h>
@@ -1566,8 +1567,9 @@ mono_resolve_patch_target (MonoMethod *method, MonoDomain *domain, guint8 *code,
                mono_class_init (handle_class);
                mono_class_init (mono_class_from_mono_type ((MonoType *)handle));
 
-               target =
-                       mono_type_get_object (domain, (MonoType *)handle);
+               target = mono_type_get_object_checked (domain, (MonoType *)handle, &error);
+               mono_error_raise_exception (&error);
+
                break;
        }
        case MONO_PATCH_INFO_LDTOKEN: {