X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Floader.c;h=17794ed099aafb5e18a24615f50d4b22bcc4c203;hb=e66357c45bb0e159aa3d02276347757e75a15dd7;hp=8462aa97e64d0f71ded2c0b43e38cd68f86ae7b6;hpb=81837bcab89b22a8d85146bd1ce91527760e4ce9;p=mono.git diff --git a/mono/metadata/loader.c b/mono/metadata/loader.c index 8462aa97e64..17794ed099a 100644 --- a/mono/metadata/loader.c +++ b/mono/metadata/loader.c @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include @@ -34,9 +33,11 @@ #include #include #include +#include +#include #include #include -#include +#include MonoDefaults mono_defaults; @@ -76,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 (). */ @@ -100,7 +101,7 @@ mono_loader_set_error_assembly_load (const char *assembly_name, gboolean ref_onl return; error = g_new0 (MonoLoaderError, 1); - error->kind = MONO_LOADER_ERROR_ASSEMBLY; + error->exception_type = MONO_EXCEPTION_FILE_NOT_FOUND; error->assembly_name = g_strdup (assembly_name); error->ref_only = ref_only; @@ -131,7 +132,7 @@ mono_loader_set_error_type_load (const char *class_name, const char *assembly_na return; error = g_new0 (MonoLoaderError, 1); - error->kind = MONO_LOADER_ERROR_TYPE; + error->exception_type = MONO_EXCEPTION_TYPE_LOAD; error->class_name = g_strdup (class_name); error->assembly_name = g_strdup (assembly_name); @@ -161,7 +162,7 @@ mono_loader_set_error_method_load (const char *class_name, const char *member_na return; error = g_new0 (MonoLoaderError, 1); - error->kind = MONO_LOADER_ERROR_METHOD; + error->exception_type = MONO_EXCEPTION_MISSING_METHOD; error->class_name = g_strdup (class_name); error->member_name = member_name; @@ -184,13 +185,34 @@ mono_loader_set_error_field_load (MonoClass *klass, const char *member_name) return; error = g_new0 (MonoLoaderError, 1); - error->kind = MONO_LOADER_ERROR_FIELD; + error->exception_type = MONO_EXCEPTION_MISSING_FIELD; error->klass = klass; error->member_name = 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: * @@ -216,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); @@ -235,8 +258,8 @@ mono_loader_error_prepare_exception (MonoLoaderError *error) { MonoException *ex = NULL; - switch (error->kind) { - case MONO_LOADER_ERROR_TYPE: { + switch (error->exception_type) { + case MONO_EXCEPTION_TYPE_LOAD: { char *cname = g_strdup (error->class_name); char *aname = g_strdup (error->assembly_name); MonoString *class_name; @@ -245,12 +268,12 @@ 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_LOADER_ERROR_METHOD: { + case MONO_EXCEPTION_MISSING_METHOD: { char *cname = g_strdup (error->class_name); char *aname = g_strdup (error->member_name); @@ -261,7 +284,7 @@ mono_loader_error_prepare_exception (MonoLoaderError *error) break; } - case MONO_LOADER_ERROR_FIELD: { + case MONO_EXCEPTION_MISSING_FIELD: { char *cnspace = g_strdup (*error->klass->name_space ? error->klass->name_space : ""); char *cname = g_strdup (error->klass->name); char *cmembername = g_strdup (error->member_name); @@ -271,14 +294,14 @@ 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_LOADER_ERROR_ASSEMBLY: { + case MONO_EXCEPTION_FILE_NOT_FOUND: { char *msg; char *filename; @@ -294,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 (); } @@ -302,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); - *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; @@ -331,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: @@ -386,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; } @@ -399,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); + 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; } @@ -428,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; @@ -470,7 +524,8 @@ find_method_in_class (MonoClass *in_class, const char *name, const char *qname, MonoMethod *m = in_class->methods [i]; if (!((fqname && !strcmp (m->name, fqname)) || - (qname && !strcmp (m->name, qname)) || !strcmp (m->name, name))) + (qname && !strcmp (m->name, qname)) || + (name && !strcmp (m->name, name)))) continue; if (sig->call_convention == MONO_CALL_VARARG) { @@ -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; } @@ -522,10 +574,21 @@ find_method (MonoClass *in_class, MonoClass *ic, const char* name, MonoMethodSig g_assert (from_class->interface_count == in_class->interface_count); for (i = 0; i < in_class->interface_count; i++) { - MonoClass *ic = in_class->interfaces [i]; + MonoClass *in_ic = in_class->interfaces [i]; MonoClass *from_ic = from_class->interfaces [i]; + char *ic_qname, *ic_fqname, *ic_class_name; + + ic_class_name = mono_type_get_name_full (&in_ic->byval_arg, MONO_TYPE_NAME_FORMAT_IL); + ic_qname = g_strconcat (ic_class_name, ".", name, NULL); + if (in_ic->name_space && in_ic->name_space [0]) + ic_fqname = g_strconcat (in_ic->name_space, ".", ic_class_name, ".", name, NULL); + else + ic_fqname = NULL; - result = find_method_in_class (ic, name, qname, fqname, sig, from_ic); + result = find_method_in_class (in_ic, ic ? name : NULL, ic_qname, ic_fqname, sig, from_ic); + g_free (ic_class_name); + g_free (ic_fqname); + g_free (ic_qname); if (result) goto out; } @@ -555,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) { @@ -598,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; @@ -621,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); @@ -649,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 @@ -657,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; } @@ -716,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; } @@ -729,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; } @@ -739,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; } @@ -822,12 +895,11 @@ 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 = NULL; - MonoGenericMethod *gmethod; - MonoGenericContainer *container = NULL; + MonoGenericContext new_context; + MonoGenericInst *inst; const char *ptr; guint32 cols [MONO_METHODSPEC_SIZE]; guint32 token, nindex, param_count; @@ -843,105 +915,26 @@ 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 method = method_from_memberref (image, nindex, context, NULL); - method = mono_get_inflated_method (method); - 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; } - container = method->generic_container; - g_assert (container); - - gmethod = g_new0 (MonoGenericMethod, 1); - if (klass->generic_class) - gmethod->class_inst = klass->generic_class->inst; - gmethod->container = container; - - new_context = g_new0 (MonoGenericContext, 1); - new_context->gmethod = gmethod; - new_context->class_inst = gmethod->class_inst; - - /* - * 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. - */ - - gmethod->inst = mono_metadata_parse_generic_inst (image, NULL, param_count, ptr, &ptr); + new_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL; + new_context.method_inst = inst; - if (context && gmethod->inst->is_open) - gmethod->inst = mono_metadata_inflate_generic_inst (gmethod->inst, context); - - if (!container->method_hash) - container->method_hash = g_hash_table_new ( - (GHashFunc)mono_metadata_generic_method_hash, (GEqualFunc)mono_metadata_generic_method_equal); - - inflated = g_hash_table_lookup (container->method_hash, gmethod); - if (inflated) { - g_free (gmethod); - g_free (new_context); - return inflated; - } - - mono_stats.generics_metadata_size += sizeof (MonoGenericMethod) + - sizeof (MonoGenericContext) + param_count * sizeof (MonoType); - - inflated = mono_class_inflate_generic_method_full (method, klass, new_context); - g_hash_table_insert (container->method_hash, gmethod, inflated); - - return inflated; + return mono_class_inflate_generic_method_full (method, klass, &new_context); } struct _MonoDllMap { @@ -1324,6 +1317,9 @@ mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char return piinfo->addr; } +/* + * LOCKING: assumes the loader lock to be taken. + */ static MonoMethod * mono_get_method_from_token (MonoImage *image, guint32 token, MonoClass *klass, MonoGenericContext *context, gboolean *used_context) @@ -1337,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); + 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) { @@ -1353,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) || @@ -1380,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); @@ -1398,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; } @@ -1426,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) @@ -1437,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; } @@ -1456,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 (); @@ -1480,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 (); @@ -1491,13 +1524,27 @@ mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constra } mono_class_init (constrained_class); - method = mono_get_inflated_method (*cil_method); - sig = mono_method_signature (method); + method = *cil_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)) @@ -1507,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); @@ -1526,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; @@ -1540,11 +1594,20 @@ mono_free_method (MonoMethod *method) if (method->dynamic) { 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) + if (mw->method.header) { g_free ((char*)mw->method.header->code); - g_free (mw->method.header); + for (i = 0; i < mw->method.header->num_locals; ++i) + g_free (mw->method.header->locals [i]); + g_free (mw->method.header->clauses); + g_free (mw->method.header); + } g_free (mw->method_data); g_free (method->signature); g_free (method); @@ -1555,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); @@ -1611,9 +1678,6 @@ mono_method_get_param_token (MonoMethod *method, int index) MonoTableInfo *methodt; guint32 idx; - if (klass->generic_class) - g_assert_not_reached (); - mono_class_init (klass); if (klass->image->dynamic) { @@ -1625,7 +1689,11 @@ mono_method_get_param_token (MonoMethod *method, int index) if (idx > 0) { guint param_index = mono_metadata_decode_row_col (methodt, idx - 1, MONO_METHOD_PARAMLIST); - return mono_metadata_make_token (MONO_TABLE_PARAM, param_index + index); + if (index == -1) + /* Return value */ + return mono_metadata_make_token (MONO_TABLE_PARAM, 0); + else + return mono_metadata_make_token (MONO_TABLE_PARAM, param_index + index); } return 0; @@ -1816,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; @@ -1830,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; } @@ -1845,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; @@ -1861,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 */ @@ -1918,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; } @@ -1987,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;