X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Floader.c;h=17794ed099aafb5e18a24615f50d4b22bcc4c203;hb=e66357c45bb0e159aa3d02276347757e75a15dd7;hp=ce103f4f8b7eb427cc1cfbe402c20d71555a1bac;hpb=352be9c703587fdedab6ff0275c99c48a56cd2d1;p=mono.git diff --git a/mono/metadata/loader.c b/mono/metadata/loader.c index ce103f4f8b7..17794ed099a 100644 --- a/mono/metadata/loader.c +++ b/mono/metadata/loader.c @@ -33,9 +33,11 @@ #include #include #include +#include +#include #include #include -#include +#include MonoDefaults mono_defaults; @@ -75,7 +77,7 @@ mono_loader_cleanup (void) * with the appropriate arguments, then return NULL to report the failure. The error * should be propagated until it reaches code which can throw managed exceptions. At that * point, an exception should be thrown based on the information returned by - * mono_loader_get_error (). Then the error should be cleared by calling + * mono_loader_get_last_error (). Then the error should be cleared by calling * mono_loader_clear_error (). */ @@ -190,6 +192,27 @@ mono_loader_set_error_field_load (MonoClass *klass, const char *member_name) set_loader_error (error); } +/* + * mono_loader_set_error_bad_image: + * + * Set the loader error for this thread. + */ +void +mono_loader_set_error_bad_image (char *msg) +{ + MonoLoaderError *error; + + if (mono_loader_get_last_error ()) + return; + + error = g_new0 (MonoLoaderError, 1); + error->exception_type = MONO_EXCEPTION_BAD_IMAGE; + error->msg = msg; + + set_loader_error (error); +} + + /* * mono_loader_get_last_error: * @@ -215,6 +238,7 @@ mono_loader_clear_error (void) if (ex) { g_free (ex->class_name); g_free (ex->assembly_name); + g_free (ex->msg); g_free (ex); TlsSetValue (loader_error_thread_id, NULL); @@ -244,10 +268,10 @@ mono_loader_error_prepare_exception (MonoLoaderError *error) class_name = mono_string_new (mono_domain_get (), cname); - ex = mono_get_exception_type_load (class_name, aname); + ex = mono_get_exception_type_load (class_name, aname); g_free (cname); g_free (aname); - break; + break; } case MONO_EXCEPTION_MISSING_METHOD: { char *cname = g_strdup (error->class_name); @@ -270,11 +294,11 @@ mono_loader_error_prepare_exception (MonoLoaderError *error) class_name = g_strdup_printf ("%s%s%s", cnspace, cnspace ? "." : "", cname); ex = mono_get_exception_missing_field (class_name, cmembername); - g_free (class_name); + g_free (class_name); g_free (cname); g_free (cmembername); g_free (cnspace); - break; + break; } case MONO_EXCEPTION_FILE_NOT_FOUND: { @@ -293,7 +317,15 @@ mono_loader_error_prepare_exception (MonoLoaderError *error) g_free (filename); break; } - + + case MONO_EXCEPTION_BAD_IMAGE: { + char *msg = g_strdup (error->msg); + mono_loader_clear_error (); + ex = mono_get_exception_bad_image_format (msg); + g_free (msg); + break; + } + default: g_assert_not_reached (); } @@ -301,25 +333,38 @@ mono_loader_error_prepare_exception (MonoLoaderError *error) return ex; } +/* + * If @field belongs to an inflated generic class, return the corresponding field of the + * generic type definition class. + */ +static MonoClassField* +mono_metadata_get_corresponding_field_from_generic_type_definition (MonoClassField *field) +{ + MonoClass *gtd; + int offset; + + if (!field->parent->generic_class) + return field; + + gtd = field->parent->generic_class->container_class; + offset = field - field->parent->fields; + return gtd->fields + offset; +} + static MonoClassField* field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass, MonoGenericContext *context) { MonoClass *klass; - MonoClassField *field; + MonoClassField *field, *sig_field = NULL; MonoTableInfo *tables = image->tables; + MonoType *sig_type; guint32 cols[6]; guint32 nindex, class; const char *fname; const char *ptr; guint32 idx = mono_metadata_token_index (token); - if (image->dynamic) { - MonoClassField *result = mono_lookup_dynamic_token (image, token, context); - *retklass = result->parent; - return result; - } - mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE); nindex = cols [MONO_MEMBERREF_CLASS] >> MONO_MEMBERREF_PARENT_BITS; class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK; @@ -330,52 +375,49 @@ field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass, mono_metadata_decode_blob_size (ptr, &ptr); /* we may want to check the signature here... */ + if (*ptr++ != 0x6) { + mono_loader_set_error_bad_image (g_strdup_printf ("Bad field signature class token %08x field name %s token %08x", class, fname, token)); + return NULL; + } + sig_type = mono_metadata_parse_type (image, MONO_PARSE_TYPE, 0, ptr, &ptr); + switch (class) { case MONO_MEMBERREF_PARENT_TYPEDEF: klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | nindex); if (!klass) { - char *name = mono_class_name_from_token (image, MONO_TOKEN_TYPE_REF | nindex); - g_warning ("Missing field %s in class %s (typeref index %d)", fname, name, nindex); + char *name = mono_class_name_from_token (image, MONO_TOKEN_TYPE_DEF | nindex); + g_warning ("Missing field %s in class %s (typedef index %d)", fname, name, nindex); + mono_loader_set_error_type_load (name, image->assembly_name); g_free (name); return NULL; } mono_class_init (klass); if (retklass) *retklass = klass; - field = mono_class_get_field_from_name (klass, fname); + sig_field = field = mono_class_get_field_from_name (klass, fname); break; case MONO_MEMBERREF_PARENT_TYPEREF: klass = mono_class_from_typeref (image, MONO_TOKEN_TYPE_REF | nindex); if (!klass) { char *name = mono_class_name_from_token (image, MONO_TOKEN_TYPE_REF | nindex); - g_warning ("Missing field %s in class %s (typeref index %d)", fname, name, nindex); + g_warning ("missing field %s in class %s (typeref index %d)", fname, name, nindex); + mono_loader_set_error_type_load (name, image->assembly_name); g_free (name); return NULL; } mono_class_init (klass); if (retklass) *retklass = klass; - field = mono_class_get_field_from_name (klass, fname); + sig_field = field = mono_class_get_field_from_name (klass, fname); break; case MONO_MEMBERREF_PARENT_TYPESPEC: { - /*guint32 bcols [MONO_TYPESPEC_SIZE]; - guint32 len; - MonoType *type; - - mono_metadata_decode_row (&tables [MONO_TABLE_TYPESPEC], nindex - 1, - bcols, MONO_TYPESPEC_SIZE); - ptr = mono_metadata_blob_heap (image, bcols [MONO_TYPESPEC_SIGNATURE]); - len = mono_metadata_decode_value (ptr, &ptr); - type = mono_metadata_parse_type (image, MONO_PARSE_TYPE, 0, ptr, &ptr); - - klass = mono_class_from_mono_type (type); - mono_class_init (klass); - g_print ("type in sig: %s\n", klass->name);*/ klass = mono_class_get_full (image, MONO_TOKEN_TYPE_SPEC | nindex, context); + //FIXME can't klass be null? mono_class_init (klass); if (retklass) *retklass = klass; field = mono_class_get_field_from_name (klass, fname); + sig_field = mono_metadata_get_corresponding_field_from_generic_type_definition (field); break; } default: @@ -385,6 +427,10 @@ field_from_memberref (MonoImage *image, guint32 token, MonoClass **retklass, if (!field) mono_loader_set_error_field_load (klass, fname); + else if (sig_field && !mono_metadata_type_equal_full (sig_type, sig_field->type, TRUE)) { + mono_loader_set_error_field_load (klass, fname); + return NULL; + } return field; } @@ -398,7 +444,16 @@ mono_field_from_token (MonoImage *image, guint32 token, MonoClass **retklass, MonoClassField *field; if (image->dynamic) { - MonoClassField *result = mono_lookup_dynamic_token (image, token, context); + MonoClassField *result; + MonoClass *handle_class; + + *retklass = NULL; + result = mono_lookup_dynamic_token_class (image, token, TRUE, &handle_class, context); + // This checks the memberref type as well + if (result && handle_class != mono_defaults.fieldhandle_class) { + mono_loader_set_error_bad_image (g_strdup ("Bad field token.")); + return NULL; + } *retklass = result->parent; return result; } @@ -427,7 +482,7 @@ mono_field_from_token (MonoImage *image, guint32 token, MonoClass **retklass, } mono_loader_lock (); - if (field && !field->parent->generic_class) + if (field && !field->parent->generic_class && !field->parent->generic_container) g_hash_table_insert (image->field_cache, GUINT_TO_POINTER (token), field); mono_loader_unlock (); return field; @@ -482,11 +537,8 @@ find_method_in_class (MonoClass *in_class, const char *name, const char *qname, } } - if (i < in_class->method.count) { - mono_class_setup_methods (from_class); - g_assert (from_class->method.count == in_class->method.count); - return from_class->methods [i]; - } + if (i < in_class->method.count) + return mono_class_get_method_by_index (from_class, i); return NULL; } @@ -566,7 +618,9 @@ inflate_generic_signature (MonoImage *image, MonoMethodSignature *sig, MonoGener if (!context) return sig; - res = mono_metadata_signature_alloc (image, sig->param_count); + res = g_malloc0 (sizeof (MonoMethodSignature) + ((gint32)sig->param_count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*)); + res->param_count = sig->param_count; + res->sentinelpos = -1; res->ret = mono_class_inflate_generic_type (sig->ret, context); is_open = mono_class_is_open_constructed_type (res->ret); for (i = 0; i < sig->param_count; ++i) { @@ -609,6 +663,7 @@ inflate_generic_header (MonoMethodHeader *header, MonoGenericContext *context) continue; t = mono_class_inflate_generic_type (&clause->data.catch_class->byval_arg, context); clause->data.catch_class = mono_class_from_mono_type (t); + mono_metadata_free_type (t); } } return res; @@ -632,7 +687,6 @@ mono_method_get_signature_full (MonoMethod *method, MonoImage *image, guint32 to if (table == MONO_TABLE_METHODSPEC) { g_assert (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) && - !(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && mono_method_signature (method)); g_assert (method->is_inflated); @@ -660,7 +714,6 @@ mono_method_get_signature_full (MonoMethod *method, MonoImage *image, guint32 to prev_sig = g_hash_table_lookup (image->memberref_signatures, GUINT_TO_POINTER (token)); if (prev_sig) { /* Somebody got in before us */ - /* FIXME: Free sig */ sig = prev_sig; } else @@ -668,7 +721,16 @@ mono_method_get_signature_full (MonoMethod *method, MonoImage *image, guint32 to mono_loader_unlock (); } - sig = inflate_generic_signature (image, sig, context); + if (context) { + MonoMethodSignature *cached; + + /* This signature is not owned by a MonoMethod, so need to cache */ + sig = inflate_generic_signature (image, sig, context); + cached = mono_metadata_get_inflated_signature (sig, context); + if (cached != sig) + mono_metadata_free_inflated_signature (sig); + sig = cached; + } return sig; } @@ -727,7 +789,7 @@ method_from_memberref (MonoImage *image, guint32 idx, MonoGenericContext *typesp if (!klass) { char *name = mono_class_name_from_token (image, MONO_TOKEN_TYPE_REF | nindex); g_warning ("Missing method %s in assembly %s, type %s", mname, image->name, name); - mono_loader_set_error_method_load (name, mname); + mono_loader_set_error_type_load (name, image->assembly_name); g_free (name); return NULL; } @@ -740,7 +802,7 @@ method_from_memberref (MonoImage *image, guint32 idx, MonoGenericContext *typesp if (!klass) { char *name = mono_class_name_from_token (image, MONO_TOKEN_TYPE_SPEC | nindex); g_warning ("Missing method %s in assembly %s, type %s", mname, image->name, name); - mono_loader_set_error_method_load (name, mname); + mono_loader_set_error_type_load (name, image->assembly_name); g_free (name); return NULL; } @@ -750,7 +812,7 @@ method_from_memberref (MonoImage *image, guint32 idx, MonoGenericContext *typesp if (!klass) { char *name = mono_class_name_from_token (image, MONO_TOKEN_TYPE_DEF | nindex); g_warning ("Missing method %s in assembly %s, type %s", mname, image->name, name); - mono_loader_set_error_method_load (name, mname); + mono_loader_set_error_type_load (name, image->assembly_name); g_free (name); return NULL; } @@ -833,7 +895,7 @@ method_from_memberref (MonoImage *image, guint32 idx, MonoGenericContext *typesp static MonoMethod * method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 idx) { - MonoMethod *method, *inflated; + MonoMethod *method; MonoClass *klass; MonoTableInfo *tables = image->tables; MonoGenericContext new_context; @@ -853,32 +915,10 @@ method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 i param_count = mono_metadata_decode_value (ptr, &ptr); g_assert (param_count); - /* - * Be careful with the two contexts here: - * - * ---------------------------------------- - * class Foo { - * static void Hello (S s, T t) { } - * - * static void Test (U u) { - * Foo.Hello (u, "World"); - * } - * } - * ---------------------------------------- - * - * Let's assume we're currently JITing Foo.Test - * (ie. `S' is instantiated as `int' and `U' is instantiated as `long'). - * - * The call to Hello() is encoded with a MethodSpec with a TypeSpec as parent - * (MONO_MEMBERREF_PARENT_TYPESPEC). - * - * The TypeSpec is encoded as `Foo', so we need to parse it in the current - * context (S=int, U=long) to get the correct `Foo'. - * - * After that, we parse the memberref signature in the new context - * (S=int, T=uninstantiated) and get the open generic method `Foo.Hello'. - * - */ + inst = mono_metadata_parse_generic_inst (image, NULL, param_count, ptr, &ptr); + if (context && inst->is_open) + inst = mono_metadata_inflate_generic_inst (inst, context); + if ((token & MONO_METHODDEFORREF_MASK) == MONO_METHODDEFORREF_METHODDEF) method = mono_get_method_full (image, MONO_TOKEN_METHOD_DEF | nindex, NULL, context); else @@ -886,47 +926,15 @@ method_from_methodspec (MonoImage *image, MonoGenericContext *context, guint32 i klass = method->klass; - /* FIXME: Is this invalid metadata? Should we throw an exception instead? */ - g_assert (!klass->generic_container); - if (klass->generic_class) { g_assert (method->is_inflated); method = ((MonoMethodInflated *) method)->declaring; } new_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL; - - /* - * When parsing the methodspec signature, we're in the old context again: - * - * ---------------------------------------- - * class Foo { - * static void Hello (T t) { } - * - * static void Test (U u) { - * Foo.Hello (u); - * } - * } - * ---------------------------------------- - * - * Let's assume we're currently JITing "Foo.Test". - * - * In this case, we already parsed the memberref as "Foo.Hello" and the methodspec - * signature is "". This means that we must instantiate the method type parameter - * `T' from the new method with the method type parameter `U' from the current context; - * ie. instantiate the method as `Foo.Hello. - */ - - inst = mono_metadata_parse_generic_inst (image, NULL, param_count, ptr, &ptr); - - if (context && inst->is_open) - inst = mono_metadata_inflate_generic_inst (inst, context); - new_context.method_inst = inst; - inflated = mono_class_inflate_generic_method_full (method, klass, &new_context); - - return inflated; + return mono_class_inflate_generic_method_full (method, klass, &new_context); } struct _MonoDllMap { @@ -1325,8 +1333,17 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass, int size, i; guint32 cols [MONO_TYPEDEF_SIZE]; - if (image->dynamic) - return mono_lookup_dynamic_token (image, token, context); + if (image->dynamic) { + MonoClass *handle_class; + + result = mono_lookup_dynamic_token_class (image, token, TRUE, &handle_class, context); + // This checks the memberref type as well + if (result && handle_class != mono_defaults.methodhandle_class) { + mono_loader_set_error_bad_image (g_strdup ("Bad method token.")); + return NULL; + } + return result; + } if (table != MONO_TABLE_METHOD) { if (table == MONO_TABLE_METHODSPEC) { @@ -1341,6 +1358,11 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass, if (used_context) *used_context = FALSE; + if (idx > image->tables [MONO_TABLE_METHOD].rows) { + mono_loader_set_error_bad_image (g_strdup ("Bad method token.")); + return NULL; + } + mono_metadata_decode_row (&image->tables [MONO_TABLE_METHOD], idx - 1, cols, 6); if ((cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) || @@ -1368,6 +1390,7 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass, container = klass->generic_container; generic_container = mono_metadata_load_generic_params (image, token, container); if (generic_container) { + result->is_generic = TRUE; generic_container->owner.method = result; mono_metadata_load_generic_param_constraints (image, token, generic_container); @@ -1386,24 +1409,24 @@ mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass, if (cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) { if (result->klass == mono_defaults.string_class && !strcmp (result->name, ".ctor")) result->string_ctor = 1; - } else if ((cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) && (!(cols [1] & METHOD_IMPL_ATTRIBUTE_NATIVE))) { + } else if (cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) { MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)result; - MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP]; +#ifdef PLATFORM_WIN32 + /* IJW is P/Invoke with a predefined function pointer. */ + if (image->is_module_handle && (cols [1] & METHOD_IMPL_ATTRIBUTE_NATIVE)) { + piinfo->addr = mono_image_rva_map (image, cols [0]); + g_assert (piinfo->addr); + } +#endif piinfo->implmap_idx = mono_metadata_implmap_from_method (image, idx - 1); - piinfo->piflags = mono_metadata_decode_row_col (im, piinfo->implmap_idx - 1, MONO_IMPLMAP_FLAGS); - } - - /* FIXME: lazyness for generics too, but how? */ - if (!(result->flags & METHOD_ATTRIBUTE_ABSTRACT) && - !(cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) && - !(result->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) && container) { - gpointer loc = mono_image_rva_map (image, cols [0]); - g_assert (loc); - ((MonoMethodNormal *) result)->header = mono_metadata_parse_mh_full (image, container, loc); + /* Native methods can have no map. */ + if (piinfo->implmap_idx) + piinfo->piflags = mono_metadata_decode_row_col (&tables [MONO_TABLE_IMPLMAP], piinfo->implmap_idx - 1, MONO_IMPLMAP_FLAGS); } - result->generic_container = generic_container; + if (generic_container) + mono_method_set_generic_container (result, generic_container); return result; } @@ -1414,6 +1437,14 @@ mono_get_method (MonoImage *image, guint32 token, MonoClass *klass) return mono_get_method_full (image, token, klass, NULL); } +static gpointer +get_method_token (gpointer value) +{ + MonoMethod *m = (MonoMethod*)value; + + return GUINT_TO_POINTER (m->token); +} + MonoMethod * mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass, MonoGenericContext *context) @@ -1425,7 +1456,16 @@ mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass, mono_loader_lock (); - if ((result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token)))) { + if (mono_metadata_token_table (token) == MONO_TABLE_METHOD) { + if (!image->method_cache) + image->method_cache = mono_value_hash_table_new (NULL, NULL, get_method_token); + result = mono_value_hash_table_lookup (image->method_cache, GINT_TO_POINTER (token)); + } else { + if (!image->methodref_cache) + image->methodref_cache = g_hash_table_new (NULL, NULL); + result = g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token)); + } + if (result) { mono_loader_unlock (); return result; } @@ -1444,8 +1484,13 @@ mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass, * used the `context' to get the method. See bug #80969. */ - if (!used_context && !(result && result->is_inflated)) - g_hash_table_insert (image->method_cache, GINT_TO_POINTER (token), result); + if (!used_context && !(result && result->is_inflated) && result) { + if (mono_metadata_token_table (token) == MONO_TABLE_METHOD) { + mono_value_hash_table_insert (image->method_cache, GINT_TO_POINTER (token), result); + } else { + g_hash_table_insert (image->methodref_cache, GINT_TO_POINTER (token), result); + } + } mono_loader_unlock (); @@ -1468,7 +1513,7 @@ mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constra MonoMethod *method, *result; MonoClass *ic = NULL; MonoGenericContext *class_context = NULL, *method_context = NULL; - MonoMethodSignature *sig; + MonoMethodSignature *sig, *original_sig; mono_loader_lock (); @@ -1480,12 +1525,26 @@ mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constra mono_class_init (constrained_class); method = *cil_method; - sig = mono_method_signature (method); + original_sig = sig = mono_method_signature (method); if (method->is_inflated && sig->generic_param_count) { MonoMethodInflated *imethod = (MonoMethodInflated *) method; sig = mono_method_signature (imethod->declaring); method_context = mono_method_get_context (method); + + original_sig = sig; + /* + * We must inflate the signature with the class instantiation to work on + * cases where a class inherit from a generic type and the override replaces + * and type argument which a concrete type. See #325283. + */ + if (method_context->class_inst) { + MonoGenericContext ctx; + ctx.method_inst = NULL; + ctx.class_inst = method_context->class_inst; + + sig = inflate_generic_signature (method->klass->image, sig, &ctx); + } } if ((constrained_class != method->klass) && (method->klass->interface_id != 0)) @@ -1495,6 +1554,9 @@ mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constra class_context = mono_class_get_context (constrained_class); result = find_method (constrained_class, ic, method->name, sig, constrained_class); + if (sig != original_sig) + mono_metadata_free_inflated_signature (sig); + if (!result) { g_warning ("Missing method %s.%s.%s in assembly %s token %x", method->klass->name_space, method->klass->name, method->name, image->name, token); @@ -1514,6 +1576,10 @@ mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constra void mono_free_method (MonoMethod *method) { + if (mono_profiler_get_events () & MONO_PROFILE_METHOD_EVENTS) + mono_profiler_method_free (method); + + /* FIXME: This hack will go away when the profiler will support freeing methods */ if (mono_profiler_get_events () != MONO_PROFILE_NONE) return; @@ -1530,6 +1596,10 @@ mono_free_method (MonoMethod *method) MonoMethodWrapper *mw = (MonoMethodWrapper*)method; int i; + mono_loader_lock (); + mono_property_hash_remove_object (method->klass->image->property_hash, method); + mono_loader_unlock (); + g_free ((char*)method->name); if (mw->method.header) { g_free ((char*)mw->method.header->code); @@ -1548,17 +1618,21 @@ void mono_method_get_param_names (MonoMethod *method, const char **names) { int i, lastp; - MonoClass *klass = method->klass; + MonoClass *klass; MonoTableInfo *methodt; MonoTableInfo *paramt; guint32 idx; + if (method->is_inflated) + method = ((MonoMethodInflated *) method)->declaring; + if (!mono_method_signature (method)->param_count) return; for (i = 0; i < mono_method_signature (method)->param_count; ++i) names [i] = ""; - if (klass->generic_class || klass->rank) /* copy the names later */ + klass = method->klass; + if (klass->rank) return; mono_class_init (klass); @@ -1810,8 +1884,11 @@ mono_method_signature (MonoMethod *m) const char *sig; gboolean can_cache_signature; MonoGenericContainer *container; + MonoMethodSignature *signature = NULL; int *pattrs; + /* We need memory barriers below because of the double-checked locking pattern */ + if (m->signature) return m->signature; @@ -1824,10 +1901,11 @@ mono_method_signature (MonoMethod *m) if (m->is_inflated) { MonoMethodInflated *imethod = (MonoMethodInflated *) m; - MonoMethodSignature *signature; /* the lock is recursive */ signature = mono_method_signature (imethod->declaring); - m->signature = inflate_generic_signature (imethod->declaring->klass->image, signature, mono_method_get_context (m)); + signature = inflate_generic_signature (imethod->declaring->klass->image, signature, mono_method_get_context (m)); + mono_memory_barrier (); + m->signature = signature; mono_loader_unlock (); return m->signature; } @@ -1839,7 +1917,7 @@ mono_method_signature (MonoMethod *m) sig = mono_metadata_blob_heap (img, mono_metadata_decode_row_col (&img->tables [MONO_TABLE_METHOD], idx - 1, MONO_METHOD_SIGNATURE)); g_assert (!m->klass->generic_class); - container = m->generic_container; + container = mono_method_get_generic_container (m); if (!container) container = m->klass->generic_container; @@ -1855,39 +1933,39 @@ mono_method_signature (MonoMethod *m) } if (can_cache_signature) - m->signature = g_hash_table_lookup (img->method_signatures, sig); + signature = g_hash_table_lookup (img->method_signatures, sig); - if (!m->signature) { + if (!signature) { const char *sig_body; size = mono_metadata_decode_blob_size (sig, &sig_body); - m->signature = mono_metadata_parse_method_signature_full (img, container, idx, sig_body, NULL); - if (!m->signature) { + signature = mono_metadata_parse_method_signature_full (img, container, idx, sig_body, NULL); + if (!signature) { mono_loader_unlock (); return NULL; } if (can_cache_signature) - g_hash_table_insert (img->method_signatures, (gpointer)sig, m->signature); + g_hash_table_insert (img->method_signatures, (gpointer)sig, signature); } /* Verify metadata consistency */ - if (m->signature->generic_param_count) { + if (signature->generic_param_count) { if (!container || !container->is_method) g_error ("Signature claims method has generic parameters, but generic_params table says it doesn't"); - if (container->type_argc != m->signature->generic_param_count) + if (container->type_argc != signature->generic_param_count) g_error ("Inconsistent generic parameter count. Signature says %d, generic_params table says %d", - m->signature->generic_param_count, container->type_argc); + signature->generic_param_count, container->type_argc); } else if (container && container->is_method && container->type_argc) g_error ("generic_params table claims method has generic parameters, but signature says it doesn't"); if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) - m->signature->pinvoke = 1; - else if ((m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) && (!(m->iflags & METHOD_IMPL_ATTRIBUTE_NATIVE))) { + signature->pinvoke = 1; + else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) { MonoCallConvention conv = 0; MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)m; - m->signature->pinvoke = 1; + signature->pinvoke = 1; switch (piinfo->piflags & PINVOKE_ATTRIBUTE_CALL_CONV_MASK) { case 0: /* no call conv, so using default */ @@ -1912,9 +1990,12 @@ mono_method_signature (MonoMethod *m) g_warning ("unsupported calling convention : 0x%04x", piinfo->piflags); g_assert_not_reached (); } - m->signature->call_convention = conv; + signature->call_convention = conv; } + mono_memory_barrier (); + m->signature = signature; + mono_loader_unlock (); return m->signature; } @@ -1981,7 +2062,7 @@ mono_method_get_header (MonoMethod *method) g_assert (loc); - mn->header = mono_metadata_parse_mh_full (img, method->generic_container, loc); + mn->header = mono_metadata_parse_mh_full (img, mono_method_get_generic_container (method), loc); mono_loader_unlock (); return mn->header;