From ea176c5bb8d2f93dafeec4aff683860c886c97ba Mon Sep 17 00:00:00 2001 From: =?utf8?q?Aleksey=20Kliger=20=28=CE=BBgeek=29?= Date: Tue, 10 Jan 2017 10:22:14 -0500 Subject: [PATCH] [reflection] Coop handles icalls in System.Reflection and System.RuntimeTypeHandle (#4217) * [sre] Add typed coop handle declarations * [reflection] Implement mono_reflection_get_token_handle Rewrite mono_reflection_get_token_checked to use it. * [reflection] Use handles for ves_icall_reflection_get_token - Get rid of mono_reflection_get_token_checked - Rename mono_reflection_get_token_handle to mono_reflection_get_token_checked * [reflection] Use handles for ves_icall_GetCurrentMethod * [reflection] Use handles for ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType_native * [reflection] Use handles for ves_icall_System_Reflection_Module_ResolveSignature * [reflection] Use handles for ves_icall_System_Type_internal_from_name * [reflection] Use handles for ves_icall_System_Type_internal_from_handle * [runtime] Use coop handles for System.Object.GetType () * [reflection] Use handles for ves_icall_MonoField_GetParentType * [reflection] Use handles for ves_icall_MonoField_ResolveType * [reflection] Use handles for most icalls in System.RuntimeTypeHandle - GetArrayRank - GetAttributes - GetBaseType - GetElementType - HasInstantiation - IsArray - IsByRef - IsComObject - IsGenericTypeDefinition - IsGenericVariable - IsPointer - IsPrimitive - type_is_assignable_from * [reflection] Use handles for ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl and ves_icall_RuntimeTypeHandle_GetGenericParameterInfo --- mono/metadata/icall-def.h | 54 ++-- mono/metadata/icall.c | 415 +++++++++++++-------------- mono/metadata/object-internals.h | 15 + mono/metadata/reflection-internals.h | 3 +- mono/metadata/reflection.c | 63 ++-- 5 files changed, 284 insertions(+), 266 deletions(-) diff --git a/mono/metadata/icall-def.h b/mono/metadata/icall-def.h index 10eda0d8a71..81820330ccb 100644 --- a/mono/metadata/icall-def.h +++ b/mono/metadata/icall-def.h @@ -493,7 +493,7 @@ ICALL_TYPE(NUMBER_FORMATTER, "System.NumberFormatter", NUMBER_FORMATTER_1) ICALL(NUMBER_FORMATTER_1, "GetFormatterTables", ves_icall_System_NumberFormatter_GetFormatterTables) ICALL_TYPE(OBJ, "System.Object", OBJ_1) -ICALL(OBJ_1, "GetType", ves_icall_System_Object_GetType) +HANDLES(ICALL(OBJ_1, "GetType", ves_icall_System_Object_GetType)) ICALL(OBJ_2, "InternalGetHashCode", mono_object_hash) ICALL(OBJ_3, "MemberwiseClone", ves_icall_System_Object_MemberwiseClone) @@ -575,12 +575,12 @@ HANDLES(ICALL(FILEDI_2, "get_marshal_info", ves_icall_System_Reflection_FieldInf HANDLES(ICALL(FILEDI_3, "internal_from_handle_type", ves_icall_System_Reflection_FieldInfo_internal_from_handle_type)) ICALL_TYPE(MEMBERI, "System.Reflection.MemberInfo", MEMBERI_1) -ICALL(MEMBERI_1, "get_MetadataToken", ves_icall_reflection_get_token) +HANDLES(ICALL(MEMBERI_1, "get_MetadataToken", ves_icall_reflection_get_token)) ICALL_TYPE(MBASE, "System.Reflection.MethodBase", MBASE_1) -ICALL(MBASE_1, "GetCurrentMethod", ves_icall_GetCurrentMethod) +HANDLES(ICALL(MBASE_1, "GetCurrentMethod", ves_icall_GetCurrentMethod)) HANDLES(ICALL(MBASE_2, "GetMethodBodyInternal", ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal)) -ICALL(MBASE_4, "GetMethodFromHandleInternalType_native", ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType_native) +HANDLES(ICALL(MBASE_4, "GetMethodFromHandleInternalType_native", ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType_native)) ICALL_TYPE(MODULE, "System.Reflection.Module", MODULE_1) HANDLES(ICALL(MODULE_1, "Close", ves_icall_System_Reflection_Module_Close)) @@ -593,10 +593,10 @@ HANDLES(ICALL(MODULE_6, "InternalGetTypes", ves_icall_System_Reflection_Module_I HANDLES(ICALL(MODULE_7, "ResolveFieldToken", ves_icall_System_Reflection_Module_ResolveFieldToken)) HANDLES(ICALL(MODULE_8, "ResolveMemberToken", ves_icall_System_Reflection_Module_ResolveMemberToken)) HANDLES(ICALL(MODULE_9, "ResolveMethodToken", ves_icall_System_Reflection_Module_ResolveMethodToken)) -ICALL(MODULE_10, "ResolveSignature", ves_icall_System_Reflection_Module_ResolveSignature) +HANDLES(ICALL(MODULE_10, "ResolveSignature", ves_icall_System_Reflection_Module_ResolveSignature)) ICALL(MODULE_11, "ResolveStringToken", ves_icall_System_Reflection_Module_ResolveStringToken) HANDLES(ICALL(MODULE_12, "ResolveTypeToken", ves_icall_System_Reflection_Module_ResolveTypeToken)) -ICALL(MODULE_13, "get_MetadataToken", ves_icall_reflection_get_token) +HANDLES(ICALL(MODULE_13, "get_MetadataToken", ves_icall_reflection_get_token)) ICALL_TYPE(MCMETH, "System.Reflection.MonoCMethod", MCMETH_1) ICALL(MCMETH_1, "GetGenericMethodDefinition_impl", ves_icall_MonoMethod_GetGenericMethodDefinition) @@ -608,10 +608,10 @@ ICALL(MEVIN_1, "get_event_info", ves_icall_MonoEventInfo_get_event_info) ICALL_TYPE(MFIELD, "System.Reflection.MonoField", MFIELD_1) ICALL(MFIELD_1, "GetFieldOffset", ves_icall_MonoField_GetFieldOffset) -ICALL(MFIELD_2, "GetParentType", ves_icall_MonoField_GetParentType) +HANDLES(ICALL(MFIELD_2, "GetParentType", ves_icall_MonoField_GetParentType)) ICALL(MFIELD_5, "GetRawConstantValue", ves_icall_MonoField_GetRawConstantValue) ICALL(MFIELD_3, "GetValueInternal", ves_icall_MonoField_GetValueInternal) -ICALL(MFIELD_6, "ResolveType", ves_icall_MonoField_ResolveType) +HANDLES(ICALL(MFIELD_6, "ResolveType", ves_icall_MonoField_ResolveType)) ICALL(MFIELD_4, "SetValueInternal", ves_icall_MonoField_SetValueInternal) ICALL(MFIELD_7, "get_core_clr_security_level", ves_icall_MonoField_get_core_clr_security_level) @@ -639,7 +639,7 @@ ICALL(MPROPI_3, "get_default_value", property_info_get_default_value) ICALL(MPROPI_2, "get_property_info", ves_icall_MonoPropertyInfo_get_property_info) ICALL_TYPE(PARAMI, "System.Reflection.ParameterInfo", PARAMI_1) -ICALL(PARAMI_1, "GetMetadataToken", ves_icall_reflection_get_token) +HANDLES(ICALL(PARAMI_1, "GetMetadataToken", ves_icall_reflection_get_token)) HANDLES(ICALL(PARAMI_2, "GetTypeModifiers", ves_icall_ParameterInfo_GetTypeModifiers)) ICALL_TYPE(PROPI, "System.Reflection.PropertyInfo", PROPI_1) @@ -798,25 +798,25 @@ ICALL(RT_26, "make_array_type", ves_icall_RuntimeType_make_array_type) ICALL(RT_27, "make_byref_type", ves_icall_RuntimeType_make_byref_type) ICALL_TYPE(RTH, "System.RuntimeTypeHandle", RTH_1) -ICALL(RTH_1, "GetArrayRank", ves_icall_RuntimeTypeHandle_GetArrayRank) +HANDLES(ICALL(RTH_1, "GetArrayRank", ves_icall_RuntimeTypeHandle_GetArrayRank)) HANDLES(ICALL(RTH_2, "GetAssembly", ves_icall_RuntimeTypeHandle_GetAssembly)) -ICALL(RTH_3, "GetAttributes", ves_icall_RuntimeTypeHandle_GetAttributes) -ICALL(RTH_4, "GetBaseType", ves_icall_RuntimeTypeHandle_GetBaseType) -ICALL(RTH_5, "GetElementType", ves_icall_RuntimeTypeHandle_GetElementType) -ICALL(RTH_19, "GetGenericParameterInfo", ves_icall_RuntimeTypeHandle_GetGenericParameterInfo) -ICALL(RTH_6, "GetGenericTypeDefinition_impl", ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl) -ICALL(RTH_7, "GetMetadataToken", ves_icall_reflection_get_token) +HANDLES(ICALL(RTH_3, "GetAttributes", ves_icall_RuntimeTypeHandle_GetAttributes)) +HANDLES(ICALL(RTH_4, "GetBaseType", ves_icall_RuntimeTypeHandle_GetBaseType)) +HANDLES(ICALL(RTH_5, "GetElementType", ves_icall_RuntimeTypeHandle_GetElementType)) +HANDLES(ICALL(RTH_19, "GetGenericParameterInfo", ves_icall_RuntimeTypeHandle_GetGenericParameterInfo)) +HANDLES(ICALL(RTH_6, "GetGenericTypeDefinition_impl", ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl)) +HANDLES(ICALL(RTH_7, "GetMetadataToken", ves_icall_reflection_get_token)) HANDLES(ICALL(RTH_8, "GetModule", ves_icall_RuntimeTypeHandle_GetModule)) -ICALL(RTH_9, "HasInstantiation", ves_icall_RuntimeTypeHandle_HasInstantiation) -ICALL(RTH_10, "IsArray", ves_icall_RuntimeTypeHandle_IsArray) -ICALL(RTH_11, "IsByRef", ves_icall_RuntimeTypeHandle_IsByRef) -ICALL(RTH_12, "IsComObject", ves_icall_RuntimeTypeHandle_IsComObject) -ICALL(RTH_13, "IsGenericTypeDefinition", ves_icall_RuntimeTypeHandle_IsGenericTypeDefinition) -ICALL(RTH_14, "IsGenericVariable", ves_icall_RuntimeTypeHandle_IsGenericVariable) +HANDLES(ICALL(RTH_9, "HasInstantiation", ves_icall_RuntimeTypeHandle_HasInstantiation)) +HANDLES(ICALL(RTH_10, "IsArray", ves_icall_RuntimeTypeHandle_IsArray)) +HANDLES(ICALL(RTH_11, "IsByRef", ves_icall_RuntimeTypeHandle_IsByRef)) +HANDLES(ICALL(RTH_12, "IsComObject", ves_icall_RuntimeTypeHandle_IsComObject)) +HANDLES(ICALL(RTH_13, "IsGenericTypeDefinition", ves_icall_RuntimeTypeHandle_IsGenericTypeDefinition)) +HANDLES(ICALL(RTH_14, "IsGenericVariable", ves_icall_RuntimeTypeHandle_IsGenericVariable)) ICALL(RTH_15, "IsInstanceOfType", ves_icall_RuntimeTypeHandle_IsInstanceOfType) -ICALL(RTH_16, "IsPointer", ves_icall_RuntimeTypeHandle_IsPointer) -ICALL(RTH_17, "IsPrimitive", ves_icall_RuntimeTypeHandle_IsPrimitive) -ICALL(RTH_18, "type_is_assignable_from", ves_icall_RuntimeTypeHandle_type_is_assignable_from) +HANDLES(ICALL(RTH_16, "IsPointer", ves_icall_RuntimeTypeHandle_IsPointer)) +HANDLES(ICALL(RTH_17, "IsPrimitive", ves_icall_RuntimeTypeHandle_IsPrimitive)) +HANDLES(ICALL(RTH_18, "type_is_assignable_from", ves_icall_RuntimeTypeHandle_type_is_assignable_from)) ICALL_TYPE(RNG, "System.Security.Cryptography.RNGCryptoServiceProvider", RNG_1) ICALL(RNG_1, "RngClose", ves_icall_System_Security_Cryptography_RNGCryptoServiceProvider_RngClose) @@ -1037,8 +1037,8 @@ ICALL(WAITH_3, "WaitAny_internal", ves_icall_System_Threading_WaitHandle_WaitAny ICALL(WAITH_4, "WaitOne_internal", ves_icall_System_Threading_WaitHandle_WaitOne_internal) ICALL_TYPE(TYPE, "System.Type", TYPE_1) -ICALL(TYPE_1, "internal_from_handle", ves_icall_System_Type_internal_from_handle) -ICALL(TYPE_2, "internal_from_name", ves_icall_System_Type_internal_from_name) +HANDLES(ICALL(TYPE_1, "internal_from_handle", ves_icall_System_Type_internal_from_handle)) +HANDLES(ICALL(TYPE_2, "internal_from_name", ves_icall_System_Type_internal_from_name)) ICALL_TYPE(TYPEDR, "System.TypedReference", TYPEDR_1) ICALL(TYPEDR_1, "InternalToObject", mono_TypedReference_ToObject) diff --git a/mono/metadata/icall.c b/mono/metadata/icall.c index 60f33b92ea0..3c81b3bc807 100644 --- a/mono/metadata/icall.c +++ b/mono/metadata/icall.c @@ -1212,20 +1212,21 @@ ves_icall_System_ValueType_Equals (MonoObject *this_obj, MonoObject *that, MonoA } } -ICALL_EXPORT MonoReflectionType * -ves_icall_System_Object_GetType (MonoObject *obj) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_System_Object_GetType (MonoObjectHandle obj, MonoError *error) { - MonoError error; - MonoReflectionType *ret; + mono_error_init (error); + MonoDomain *domain = MONO_HANDLE_DOMAIN (obj); + MonoClass *klass = mono_handle_class (obj); #ifndef DISABLE_REMOTING - if (obj->vtable->klass == mono_defaults.transparent_proxy_class) - ret = mono_type_get_object_checked (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg, &error); - else + if (klass == mono_defaults.transparent_proxy_class) { + MonoTransparentProxyHandle proxy_obj = MONO_HANDLE_CAST (MonoTransparentProxy, obj); + MonoRemoteClass *remote_class = MONO_HANDLE_GETVAL (proxy_obj, remote_class); + MonoType *proxy_type = &remote_class->proxy_class->byval_arg; + return mono_type_get_object_handle (domain, proxy_type, error); + } else #endif - ret = mono_type_get_object_checked (mono_object_domain (obj), &obj->vtable->klass->byval_arg, &error); - - mono_error_set_pending_exception (&error); - return ret; + return mono_type_get_object_handle (domain, &klass->byval_arg, error); } static gboolean @@ -1301,7 +1302,7 @@ get_caller_no_system_or_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboole return FALSE; } -static MonoReflectionType * +static MonoReflectionTypeHandle type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoAssembly **caller_assembly, MonoError *error) { MonoMethod *m, *dest; @@ -1361,7 +1362,8 @@ type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoAsse if (assembly) { /* When loading from the current assembly, AppDomain.TypeResolve will not be called yet */ type = mono_reflection_get_type_checked (rootimage, assembly->image, info, ignoreCase, &type_resolve, error); - return_val_if_nok (error, NULL); + if (!is_ok (error)) + goto fail; } // XXXX - aleksey - @@ -1375,33 +1377,38 @@ type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoAsse if (!info->assembly.name && !type) { /* try mscorlib */ type = mono_reflection_get_type_checked (rootimage, NULL, info, ignoreCase, &type_resolve, error); - return_val_if_nok (error, NULL); + if (!is_ok (error)) + goto fail; } if (assembly && !type && type_resolve) { type_resolve = FALSE; /* This will invoke TypeResolve if not done in the first 'if' */ type = mono_reflection_get_type_checked (rootimage, assembly->image, info, ignoreCase, &type_resolve, error); - return_val_if_nok (error, NULL); + if (!is_ok (error)) + goto fail; } if (!type) - return NULL; + goto fail; - return mono_type_get_object_checked (mono_domain_get (), type, error); + return mono_type_get_object_handle (mono_domain_get (), type, error); +fail: + return MONO_HANDLE_NEW (MonoReflectionType, NULL); } -ICALL_EXPORT MonoReflectionType* -ves_icall_System_Type_internal_from_name (MonoString *name, - MonoBoolean throwOnError, - MonoBoolean ignoreCase) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_System_Type_internal_from_name (MonoStringHandle name, + MonoBoolean throwOnError, + MonoBoolean ignoreCase, + MonoError *error) { - MonoError error; + mono_error_init (error); MonoTypeNameParse info; - MonoReflectionType *type = NULL; gboolean parsedOk; MonoAssembly *caller_assembly; + MonoReflectionTypeHandle type = MONO_HANDLE_NEW (MonoReflectionType, NULL); - char *str = mono_string_to_utf8_checked (name, &error); - if (!is_ok (&error)) + char *str = mono_string_handle_to_utf8 (name, error); + if (!is_ok (error)) goto leave; parsedOk = mono_reflection_parse_type (str, &info); @@ -1410,18 +1417,18 @@ ves_icall_System_Type_internal_from_name (MonoString *name, if (!parsedOk) { mono_reflection_free_type_info (&info); if (throwOnError) - mono_error_set_argument (&error, "typeName", "failed parse: %s", str); + mono_error_set_argument (error, "typeName", "failed parse: %s", str); goto leave; } - type = type_from_parsed_name (&info, ignoreCase, &caller_assembly, &error); + MONO_HANDLE_ASSIGN (type, type_from_parsed_name (&info, ignoreCase, &caller_assembly, error)); - if (!is_ok (&error)) { + if (!is_ok (error)) { mono_reflection_free_type_info (&info); goto leave; } - if (type == NULL) { + if (MONO_HANDLE_IS_NULL (type)) { if (throwOnError) { char *tname = info.name_space ? g_strdup_printf ("%s.%s", info.name_space, info.name) : g_strdup (info.name); char *aname; @@ -1431,7 +1438,7 @@ ves_icall_System_Type_internal_from_name (MonoString *name, aname = mono_stringify_assembly_name (mono_assembly_get_name (caller_assembly)); else aname = g_strdup (""); - mono_error_set_type_load_name (&error, tname, aname, ""); + mono_error_set_type_load_name (error, tname, aname, ""); } mono_reflection_free_type_info (&info); goto leave; @@ -1439,29 +1446,23 @@ ves_icall_System_Type_internal_from_name (MonoString *name, leave: g_free (str); - if (!is_ok (&error)) { - if (throwOnError) - mono_error_set_pending_exception (&error); - else - mono_error_cleanup (&error); - return NULL; + if (!is_ok (error)) { + if (!throwOnError) + mono_error_cleanup (error); + return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE); } return type; } -ICALL_EXPORT MonoReflectionType* -ves_icall_System_Type_internal_from_handle (MonoType *handle) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_System_Type_internal_from_handle (MonoType *handle, MonoError *error) { - MonoError error; - MonoReflectionType *ret; + mono_error_init (error); MonoDomain *domain = mono_domain_get (); - ret = mono_type_get_object_checked (domain, handle, &error); - mono_error_set_pending_exception (&error); - - return ret; + return mono_type_get_object_handle (domain, handle, error); } ICALL_EXPORT MonoType* @@ -1606,22 +1607,23 @@ mono_type_get_underlying_type_ignore_byref (MonoType *type) } ICALL_EXPORT guint32 -ves_icall_RuntimeTypeHandle_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c) +ves_icall_RuntimeTypeHandle_type_is_assignable_from (MonoReflectionTypeHandle ref_type, MonoReflectionTypeHandle ref_c, MonoError *error) { - MonoClass *klass; - MonoClass *klassc; + mono_error_init (error); - g_assert (type != NULL); + g_assert (!MONO_HANDLE_IS_NULL (ref_type)); - klass = mono_class_from_mono_type (type->type); - klassc = mono_class_from_mono_type (c->type); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + MonoClass *klass = mono_class_from_mono_type (type); + MonoType *ctype = MONO_HANDLE_GETVAL (ref_c, type); + MonoClass *klassc = mono_class_from_mono_type (ctype); - if (type->type->byref ^ c->type->byref) + if (type->byref ^ ctype->byref) return FALSE; - if (type->type->byref) { - MonoType *t = mono_type_get_underlying_type_ignore_byref (type->type); - MonoType *ot = mono_type_get_underlying_type_ignore_byref (c->type); + if (type->byref) { + MonoType *t = mono_type_get_underlying_type_ignore_byref (type); + MonoType *ot = mono_type_get_underlying_type_ignore_byref (ctype); klass = mono_class_from_mono_type (t); klassc = mono_class_from_mono_type (ot); @@ -1660,9 +1662,11 @@ ves_icall_RuntimeTypeHandle_IsInstanceOfType (MonoReflectionType *type, MonoObje } ICALL_EXPORT guint32 -ves_icall_RuntimeTypeHandle_GetAttributes (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_GetAttributes (MonoReflectionTypeHandle ref_type, MonoError *error) { - MonoClass *klass = mono_class_from_mono_type (type->type); + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + MonoClass *klass = mono_class_from_mono_type (type); return mono_class_get_flags (klass); } @@ -1878,20 +1882,21 @@ ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field) return field->field->offset - sizeof (MonoObject); } -ICALL_EXPORT MonoReflectionType* -ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_MonoField_GetParentType (MonoReflectionFieldHandle field, MonoBoolean declaring, MonoError *error) { - MonoError error; - MonoReflectionType *ret; + mono_error_init (error); + MonoDomain *domain = MONO_HANDLE_DOMAIN (field); MonoClass *parent; - parent = declaring? field->field->parent: field->klass; - - ret = mono_type_get_object_checked (mono_object_domain (field), &parent->byval_arg, &error); - mono_error_set_pending_exception (&error); - - return ret; + if (declaring) { + MonoClassField *f = MONO_HANDLE_GETVAL (field, field); + parent = f->parent; + } else { + parent = MONO_HANDLE_GETVAL (field, klass); + } + return mono_type_get_object_handle (domain, &parent->byval_arg, error); } ICALL_EXPORT MonoObject * @@ -2143,26 +2148,17 @@ ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *rfield) return o; } -ICALL_EXPORT MonoReflectionType* -ves_icall_MonoField_ResolveType (MonoReflectionField *ref_field) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_MonoField_ResolveType (MonoReflectionFieldHandle ref_field, MonoError *error) { - MonoError error; - MonoReflectionType *ret; - MonoType *type; - - type = mono_field_get_type_checked (ref_field->field, &error); - if (!mono_error_ok (&error)) { - mono_error_set_pending_exception (&error); - return NULL; - } - - ret = mono_type_get_object_checked (mono_object_domain (ref_field), type, &error); - if (!mono_error_ok (&error)) { - mono_error_set_pending_exception (&error); - return NULL; + mono_error_init (error); + MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_field); + MonoClassField *field = MONO_HANDLE_GETVAL (ref_field, field); + MonoType *type = mono_field_get_type_checked (field, error); + if (!is_ok (error)) { + return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE); } - - return ret; + return mono_type_get_object_handle (domain, type, error); } /* From MonoProperty.cs */ @@ -2498,97 +2494,95 @@ ves_icall_RuntimeType_GetPacking (MonoReflectionType *type, guint32 *packing, gu } } -ICALL_EXPORT MonoReflectionType* -ves_icall_RuntimeTypeHandle_GetElementType (MonoReflectionType *type) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_RuntimeTypeHandle_GetElementType (MonoReflectionTypeHandle ref_type, MonoError *error) { - MonoError error; - MonoReflectionType *ret; - MonoClass *klass; + mono_error_init (error); - 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_set_pending_exception (&error); - return ret; - } + MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); - klass = mono_class_from_mono_type (type->type); - mono_class_init_checked (klass, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; + if (!type->byref && type->type == MONO_TYPE_SZARRAY) { + return mono_type_get_object_handle (domain, &type->data.klass->byval_arg, error); + } + MonoClass *klass = mono_class_from_mono_type (type); + mono_class_init_checked (klass, error); + if (!is_ok (error)) + return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE); // GetElementType should only return a type for: // Array Pointer PassedByRef - if (type->type->byref) - ret = mono_type_get_object_checked (mono_object_domain (type), &klass->byval_arg, &error); + if (type->byref) + return mono_type_get_object_handle (domain, &klass->byval_arg, error); else if (klass->element_class && MONO_CLASS_IS_ARRAY (klass)) - 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) - ret = mono_type_get_object_checked (mono_object_domain (type), &klass->element_class->byval_arg, &error); + return mono_type_get_object_handle (domain, &klass->element_class->byval_arg, error); + else if (klass->element_class && type->type == MONO_TYPE_PTR) + return mono_type_get_object_handle (domain, &klass->element_class->byval_arg, error); else - return NULL; - - mono_error_set_pending_exception (&error); - - return ret; + return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE); } -ICALL_EXPORT MonoReflectionType* -ves_icall_RuntimeTypeHandle_GetBaseType (MonoReflectionType *type) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_RuntimeTypeHandle_GetBaseType (MonoReflectionTypeHandle ref_type, MonoError *error) { - MonoError error; - MonoReflectionType *ret; + mono_error_init (error); - if (type->type->byref) - return NULL; + MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); - MonoClass *klass = mono_class_from_mono_type (type->type); - if (!klass->parent) - return NULL; + if (type->byref) + return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE); - ret = mono_type_get_object_checked (mono_object_domain (type), &klass->parent->byval_arg, &error); - mono_error_set_pending_exception (&error); + MonoClass *klass = mono_class_from_mono_type (type); + if (!klass->parent) + return MONO_HANDLE_CAST (MonoReflectionType, NULL_HANDLE); - return ret; + return mono_type_get_object_handle (domain, &klass->parent->byval_arg, error); } ICALL_EXPORT MonoBoolean -ves_icall_RuntimeTypeHandle_IsPointer (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_IsPointer (MonoReflectionTypeHandle ref_type, MonoError *error) { - return type->type->type == MONO_TYPE_PTR; + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + return type->type == MONO_TYPE_PTR; } ICALL_EXPORT MonoBoolean -ves_icall_RuntimeTypeHandle_IsPrimitive (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_IsPrimitive (MonoReflectionTypeHandle ref_type, MonoError *error) { - return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U))); + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + return (!type->byref && (((type->type >= MONO_TYPE_BOOLEAN) && (type->type <= MONO_TYPE_R8)) || (type->type == MONO_TYPE_I) || (type->type == MONO_TYPE_U))); } ICALL_EXPORT MonoBoolean -ves_icall_RuntimeTypeHandle_IsByRef (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_IsByRef (MonoReflectionTypeHandle ref_type, MonoError *error) { - return type->type->byref; + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + return type->byref; } ICALL_EXPORT MonoBoolean -ves_icall_RuntimeTypeHandle_IsComObject (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_IsComObject (MonoReflectionTypeHandle ref_type, MonoError *error) { - MonoError error; - MonoClass *klass = mono_class_from_mono_type (type->type); - mono_class_init_checked (klass, &error); - if (mono_error_set_pending_exception (&error)) + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + MonoClass *klass = mono_class_from_mono_type (type); + mono_class_init_checked (klass, error); + if (!is_ok (error)) return FALSE; return mono_class_is_com_object (klass); } ICALL_EXPORT guint32 -ves_icall_reflection_get_token (MonoObject* obj) +ves_icall_reflection_get_token (MonoObjectHandle obj, MonoError *error) { - MonoError error; - guint32 result = mono_reflection_get_token_checked (obj, &error); - mono_error_set_pending_exception (&error); - return result; + mono_error_init (error); + return mono_reflection_get_token_checked (obj, error); } ICALL_EXPORT MonoReflectionModuleHandle @@ -2675,16 +2669,17 @@ ves_icall_RuntimeType_get_Namespace (MonoReflectionTypeHandle type, MonoError *e } ICALL_EXPORT gint32 -ves_icall_RuntimeTypeHandle_GetArrayRank (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_GetArrayRank (MonoReflectionTypeHandle ref_type, MonoError *error) { - MonoClass *klass; + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); - if (type->type->type != MONO_TYPE_ARRAY && type->type->type != MONO_TYPE_SZARRAY) { - mono_set_pending_exception (mono_get_exception_argument ("type", "Type must be an array type")); + if (type->type != MONO_TYPE_ARRAY && type->type != MONO_TYPE_SZARRAY) { + mono_error_set_argument (error, "type", "Type must be an array type"); return 0; } - klass = mono_class_from_mono_type (type->type); + MonoClass *klass = mono_class_from_mono_type (type); return klass->rank; } @@ -2740,51 +2735,55 @@ ves_icall_RuntimeType_GetGenericArguments (MonoReflectionType *type, MonoBoolean } ICALL_EXPORT gboolean -ves_icall_RuntimeTypeHandle_IsGenericTypeDefinition (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_IsGenericTypeDefinition (MonoReflectionTypeHandle ref_type, MonoError *error) { - MonoClass *klass; + mono_error_init (error); - if (!IS_MONOTYPE (type)) + if (!IS_MONOTYPE (MONO_HANDLE_RAW(ref_type))) return FALSE; - if (type->type->byref) + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + if (type->byref) return FALSE; - klass = mono_class_from_mono_type (type->type); + MonoClass *klass = mono_class_from_mono_type (type); return mono_class_is_gtd (klass); } -ICALL_EXPORT MonoReflectionType* -ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl (MonoReflectionType *type) +ICALL_EXPORT MonoReflectionTypeHandle +ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl (MonoReflectionTypeHandle ref_type, MonoError *error) { - MonoError error; - MonoReflectionType *ret; - MonoClass *klass; + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); - if (type->type->byref) - return NULL; + MonoReflectionTypeHandle ret = MONO_HANDLE_NEW (MonoReflectionType, NULL); - klass = mono_class_from_mono_type (type->type); + if (type->byref) + goto leave; + + MonoClass *klass = mono_class_from_mono_type (type); if (mono_class_is_gtd (klass)) { - return type; /* check this one */ + /* check this one */ + MONO_HANDLE_ASSIGN (ret, ref_type); + goto leave; } if (mono_class_is_ginst (klass)) { MonoClass *generic_class = mono_class_get_generic_class (klass)->container_class; - gpointer tb; - - tb = mono_class_get_ref_info (generic_class); - if (generic_class->wastypebuilder && tb) - return (MonoReflectionType *)tb; - else { - ret = mono_type_get_object_checked (mono_object_domain (type), &generic_class->byval_arg, &error); - mono_error_set_pending_exception (&error); - - return ret; + guint32 ref_info_handle = mono_class_get_ref_info_handle (klass); + + if (generic_class->wastypebuilder && ref_info_handle) { + MonoObjectHandle tb = mono_gchandle_get_target_handle (ref_info_handle); + g_assert (!MONO_HANDLE_IS_NULL (tb)); + MONO_HANDLE_ASSIGN (ret, tb); + } else { + MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_type); + MONO_HANDLE_ASSIGN (ret, mono_type_get_object_handle (domain, &generic_class->byval_arg, error)); } } - return NULL; +leave: + return ret; } ICALL_EXPORT MonoReflectionType* @@ -2831,17 +2830,19 @@ ves_icall_RuntimeType_MakeGenericType (MonoReflectionType *type, MonoArray *type } ICALL_EXPORT gboolean -ves_icall_RuntimeTypeHandle_HasInstantiation (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_HasInstantiation (MonoReflectionTypeHandle ref_type, MonoError *error) { + mono_error_init (error); MonoClass *klass; - if (!IS_MONOTYPE (type)) + if (!IS_MONOTYPE (MONO_HANDLE_RAW (ref_type))) return FALSE; - if (type->type->byref) + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + if (type->byref) return FALSE; - klass = mono_class_from_mono_type (type->type); + klass = mono_class_from_mono_type (type); return mono_class_is_ginst (klass) || mono_class_is_gtd (klass); } @@ -2857,15 +2858,18 @@ ves_icall_RuntimeType_GetGenericParameterPosition (MonoReflectionType *type) } ICALL_EXPORT MonoGenericParamInfo * -ves_icall_RuntimeTypeHandle_GetGenericParameterInfo (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_GetGenericParameterInfo (MonoReflectionTypeHandle ref_type, MonoError *error) { - return mono_generic_param_info (type->type->data.generic_param); + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); + return mono_generic_param_info (type->data.generic_param); } ICALL_EXPORT MonoBoolean -ves_icall_RuntimeTypeHandle_IsGenericVariable (MonoReflectionType *type) +ves_icall_RuntimeTypeHandle_IsGenericVariable (MonoReflectionTypeHandle ref_type, MonoError *error) { - return is_generic_parameter (type->type); + MonoType *type = MONO_HANDLE_GETVAL(ref_type, type); + return is_generic_parameter (type); } ICALL_EXPORT MonoReflectionMethod* @@ -5053,25 +5057,22 @@ fail: return MONO_HANDLE_CAST (MonoArray, NULL_HANDLE); } -ICALL_EXPORT MonoReflectionMethod* -ves_icall_GetCurrentMethod (void) +ICALL_EXPORT MonoReflectionMethodHandle +ves_icall_GetCurrentMethod (MonoError *error) { - MonoReflectionMethod *res = NULL; - MonoError error; + mono_error_init (error); MonoMethod *m = mono_method_get_last_managed (); if (!m) { - mono_set_pending_exception (mono_get_exception_not_supported ("Stack walks are not supported on this platform.")); - return NULL; + mono_error_set_not_supported (error, "Stack walks are not supported on this platform."); + return MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE); } while (m->is_inflated) m = ((MonoMethodInflated*)m)->declaring; - res = mono_method_get_object_checked (mono_domain_get (), m, NULL, &error); - mono_error_set_pending_exception (&error); - return res; + return mono_method_get_object_handle (mono_domain_get (), m, NULL, error); } @@ -5113,29 +5114,26 @@ mono_method_get_equivalent_method (MonoMethod *method, MonoClass *klass) return klass->methods [offset]; } -ICALL_EXPORT MonoReflectionMethod* -ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType_native (MonoMethod *method, MonoType *type, MonoBoolean generic_check) +ICALL_EXPORT MonoReflectionMethodHandle +ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType_native (MonoMethod *method, MonoType *type, MonoBoolean generic_check, MonoError *error) { - MonoReflectionMethod *res = NULL; - MonoError error; + mono_error_init (error); MonoClass *klass; if (type && generic_check) { klass = mono_class_from_mono_type (type); if (mono_class_get_generic_type_definition (method->klass) != mono_class_get_generic_type_definition (klass)) - return NULL; + return MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE); if (method->klass != klass) { method = mono_method_get_equivalent_method (method, klass); if (!method) - return NULL; + return MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE); } } else if (type) klass = mono_class_from_mono_type (type); else klass = method->klass; - res = mono_method_get_object_checked (mono_domain_get (), method, klass, &error); - mono_error_set_pending_exception (&error); - return res; + return mono_method_get_object_handle (mono_domain_get (), method, klass, error); } ICALL_EXPORT MonoReflectionMethodBodyHandle @@ -6023,49 +6021,50 @@ ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 return NULL_HANDLE; } -ICALL_EXPORT MonoArray* -ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error) +ICALL_EXPORT MonoArrayHandle +ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error, MonoError *error) { - MonoError error; + mono_error_init (error); int table = mono_metadata_token_table (token); int idx = mono_metadata_token_index (token); MonoTableInfo *tables = image->tables; guint32 sig, len; const char *ptr; - MonoArray *res; *resolve_error = ResolveTokenError_OutOfRange; /* FIXME: Support other tables ? */ if (table != MONO_TABLE_STANDALONESIG) - return NULL; + return MONO_HANDLE_CAST (MonoArray, NULL); if (image_is_dynamic (image)) - return NULL; + return MONO_HANDLE_CAST (MonoArray, NULL); if ((idx == 0) || (idx > tables [MONO_TABLE_STANDALONESIG].rows)) - return NULL; + return MONO_HANDLE_CAST (MonoArray, NULL); sig = mono_metadata_decode_row_col (&tables [MONO_TABLE_STANDALONESIG], idx - 1, 0); ptr = mono_metadata_blob_heap (image, sig); len = mono_metadata_decode_blob_size (ptr, &ptr); - res = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, len, &error); - if (mono_error_set_pending_exception (&error)) - return NULL; - memcpy (mono_array_addr (res, guint8, 0), ptr, len); + MonoArrayHandle res = mono_array_new_handle (mono_domain_get (), mono_defaults.byte_class, len, error); + if (!is_ok (error)) + return MONO_HANDLE_CAST (MonoArray, NULL); + uint32_t h; + gpointer array_base = MONO_ARRAY_HANDLE_PIN (res, guint8, 0, &h); + memcpy (array_base, ptr, len); + mono_gchandle_free (h); return res; } ICALL_EXPORT MonoBoolean -ves_icall_RuntimeTypeHandle_IsArray (MonoReflectionType *t) +ves_icall_RuntimeTypeHandle_IsArray (MonoReflectionTypeHandle ref_type, MonoError *error) { - MonoType *type; - MonoBoolean res; + mono_error_init (error); + MonoType *type = MONO_HANDLE_GETVAL (ref_type, type); - type = t->type; - res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY); + MonoBoolean res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY); return res; } diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index 935e676ff62..4031b3245a3 100644 --- a/mono/metadata/object-internals.h +++ b/mono/metadata/object-internals.h @@ -306,6 +306,9 @@ typedef struct { MonoBoolean custom_type_info; } MonoTransparentProxy; +/* Safely access System.Runtime.Remoting.Proxies.TransparentProxy from native code */ +TYPED_HANDLE_DECL (MonoTransparentProxy); + typedef struct { MonoObject obj; MonoReflectionMethod *method; @@ -999,6 +1002,9 @@ typedef struct { MonoArray *permissions; } MonoReflectionCtorBuilder; +/* Safely access System.Reflection.Emit.ConstructorBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionCtorBuilder); + typedef struct { MonoObject object; MonoMethod *mhandle; @@ -1030,6 +1036,9 @@ typedef struct { MonoArray *permissions; } MonoReflectionMethodBuilder; +/* Safely access System.Reflection.Emit.MethodBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionMethodBuilder); + typedef struct { MonoObject object; MonoMethod *mhandle; @@ -1112,6 +1121,9 @@ typedef struct { MonoArray *modopt; } MonoReflectionFieldBuilder; +/* Safely access System.Reflection.Emit.FieldBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionFieldBuilder); + typedef struct { MonoObject object; guint32 attrs; @@ -1190,6 +1202,9 @@ typedef struct { MonoReflectionType *created; } MonoReflectionTypeBuilder; +/* Safely access System.Reflection.Emit.TypeBuilder from native code */ +TYPED_HANDLE_DECL (MonoReflectionTypeBuilder); + typedef struct { MonoReflectionType type; MonoReflectionType *element_type; diff --git a/mono/metadata/reflection-internals.h b/mono/metadata/reflection-internals.h index 27fbba80a15..1b8e894a1a6 100644 --- a/mono/metadata/reflection-internals.h +++ b/mono/metadata/reflection-internals.h @@ -25,8 +25,7 @@ MonoType* mono_reflection_type_from_name_checked (char *name, MonoImage *image, MonoError *error); guint32 -mono_reflection_get_token_checked (MonoObject *obj, MonoError *error); - +mono_reflection_get_token_checked (MonoObjectHandle obj, MonoError *error); MonoObject* mono_custom_attrs_get_attr_checked (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass, MonoError *error); diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c index b627a9f6820..121859325dc 100644 --- a/mono/metadata/reflection.c +++ b/mono/metadata/reflection.c @@ -2238,12 +2238,14 @@ mono_reflection_type_from_name_checked (char *name, MonoImage *image, MonoError * representing a metadata element. */ guint32 -mono_reflection_get_token (MonoObject *obj) +mono_reflection_get_token (MonoObject *obj_raw) { + HANDLE_FUNCTION_ENTER (); + MONO_HANDLE_DCL (MonoObject, obj); MonoError error; guint32 result = mono_reflection_get_token_checked (obj, &error); mono_error_assert_ok (&error); - return result; + HANDLE_FUNCTION_RETURN_VAL (result); } /** @@ -2255,32 +2257,31 @@ mono_reflection_get_token (MonoObject *obj) * representing a metadata element. On failure sets @error. */ guint32 -mono_reflection_get_token_checked (MonoObject *obj, MonoError *error) +mono_reflection_get_token_checked (MonoObjectHandle obj, MonoError *error) { - MonoClass *klass; guint32 token = 0; mono_error_init (error); - klass = obj->vtable->klass; + MonoClass *klass = mono_handle_class (obj); if (strcmp (klass->name, "MethodBuilder") == 0) { - MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj; + MonoReflectionMethodBuilderHandle mb = MONO_HANDLE_CAST (MonoReflectionMethodBuilder, obj); - token = mb->table_idx | MONO_TOKEN_METHOD_DEF; + token = MONO_HANDLE_GETVAL (mb, table_idx) | MONO_TOKEN_METHOD_DEF; } else if (strcmp (klass->name, "ConstructorBuilder") == 0) { - MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj; + MonoReflectionCtorBuilderHandle mb = MONO_HANDLE_CAST (MonoReflectionCtorBuilder, obj); - token = mb->table_idx | MONO_TOKEN_METHOD_DEF; + token = MONO_HANDLE_GETVAL (mb, table_idx) | MONO_TOKEN_METHOD_DEF; } else if (strcmp (klass->name, "FieldBuilder") == 0) { - MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj; + MonoReflectionFieldBuilderHandle fb = MONO_HANDLE_CAST (MonoReflectionFieldBuilder, obj); - token = fb->table_idx | MONO_TOKEN_FIELD_DEF; + token = MONO_HANDLE_GETVAL (fb, table_idx) | MONO_TOKEN_FIELD_DEF; } else if (strcmp (klass->name, "TypeBuilder") == 0) { - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj; - token = tb->table_idx | MONO_TOKEN_TYPE_DEF; + MonoReflectionTypeBuilderHandle tb = MONO_HANDLE_CAST (MonoReflectionTypeBuilder, obj); + token = MONO_HANDLE_GETVAL (tb, table_idx) | MONO_TOKEN_TYPE_DEF; } else if (strcmp (klass->name, "RuntimeType") == 0) { - MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error); + MonoType *type = mono_reflection_type_get_handle (MONO_HANDLE_RAW (MONO_HANDLE_CAST (MonoReflectionType, obj)), error); /* FIXME use handles */ return_val_if_nok (error, 0); MonoClass *mc = mono_class_from_mono_type (type); if (!mono_class_init (mc)) { @@ -2291,35 +2292,39 @@ mono_reflection_get_token_checked (MonoObject *obj, MonoError *error) token = mc->type_token; } else if (strcmp (klass->name, "MonoCMethod") == 0 || strcmp (klass->name, "MonoMethod") == 0) { - MonoReflectionMethod *m = (MonoReflectionMethod *)obj; - if (m->method->is_inflated) { - MonoMethodInflated *inflated = (MonoMethodInflated *) m->method; + MonoReflectionMethodHandle m = MONO_HANDLE_CAST (MonoReflectionMethod, obj); + MonoMethod *method = MONO_HANDLE_GETVAL (m, method); + if (method->is_inflated) { + MonoMethodInflated *inflated = (MonoMethodInflated *) method; return inflated->declaring->token; } else { - token = m->method->token; + token = method->token; } } else if (strcmp (klass->name, "MonoField") == 0) { - MonoReflectionField *f = (MonoReflectionField*)obj; + MonoReflectionFieldHandle f = MONO_HANDLE_CAST (MonoReflectionField, obj); - token = mono_class_get_field_token (f->field); + token = mono_class_get_field_token (MONO_HANDLE_GETVAL (f, field)); } else if (strcmp (klass->name, "MonoProperty") == 0) { - MonoReflectionProperty *p = (MonoReflectionProperty*)obj; + MonoReflectionPropertyHandle p = MONO_HANDLE_CAST (MonoReflectionProperty, obj); - token = mono_class_get_property_token (p->property); + token = mono_class_get_property_token (MONO_HANDLE_GETVAL (p, property)); } else if (strcmp (klass->name, "MonoEvent") == 0) { - MonoReflectionMonoEvent *p = (MonoReflectionMonoEvent*)obj; + MonoReflectionMonoEventHandle p = MONO_HANDLE_CAST (MonoReflectionMonoEvent, obj); - token = mono_class_get_event_token (p->event); + token = mono_class_get_event_token (MONO_HANDLE_GETVAL (p, event)); } else if (strcmp (klass->name, "ParameterInfo") == 0 || strcmp (klass->name, "MonoParameterInfo") == 0) { - MonoReflectionParameter *p = (MonoReflectionParameter*)obj; - MonoClass *member_class = mono_object_class (p->MemberImpl); + MonoReflectionParameterHandle p = MONO_HANDLE_CAST (MonoReflectionParameter, obj); + MonoObjectHandle member_impl = MONO_HANDLE_NEW (MonoObject, NULL); + MONO_HANDLE_GET (member_impl, p, MemberImpl); + MonoClass *member_class = mono_handle_class (member_impl); g_assert (mono_class_is_reflection_method_or_constructor (member_class)); + MonoMethod *method = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionMethod, member_impl), method); - token = mono_method_get_param_token (((MonoReflectionMethod*)p->MemberImpl)->method, p->PositionImpl); + token = mono_method_get_param_token (method, MONO_HANDLE_GETVAL (p, PositionImpl)); } else if (strcmp (klass->name, "Module") == 0 || strcmp (klass->name, "MonoModule") == 0) { - MonoReflectionModule *m = (MonoReflectionModule*)obj; + MonoReflectionModuleHandle m = MONO_HANDLE_CAST (MonoReflectionModule, obj); - token = m->token; + token = MONO_HANDLE_GETVAL (m, token); } else if (strcmp (klass->name, "Assembly") == 0 || strcmp (klass->name, "MonoAssembly") == 0) { token = mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1); } else { -- 2.25.1