X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fclass.c;h=701f10dbc638225cb1cdd15145f31896d8c25ee0;hb=b196696d61725b6fa5d0a5a31df5659e98b8b729;hp=b564b9c5621b1fb4ce56eaaa58e9ad39a28b453c;hpb=de0624d8b3f640aff8d2467a52a7285a8b9b4a85;p=mono.git diff --git a/mono/metadata/class.c b/mono/metadata/class.c index b564b9c5621..701f10dbc63 100644 --- a/mono/metadata/class.c +++ b/mono/metadata/class.c @@ -172,25 +172,23 @@ mono_class_from_typeref (MonoImage *image, guint32 type_token) static void * -mono_mempool_dup (MonoMemPool *mp, void *data, guint size) +mono_image_memdup (MonoImage *image, void *data, guint size) { - void *res = mono_mempool_alloc (mp, size); + void *res = mono_image_alloc (image, size); memcpy (res, data, size); return res; } /* Copy everything mono_metadata_free_array free. */ MonoArrayType * -mono_dup_array_type (MonoMemPool *mp, MonoArrayType *a) +mono_dup_array_type (MonoImage *image, MonoArrayType *a) { - if (mp) { - mono_loader_lock (); - a = mono_mempool_dup (mp, a, sizeof (MonoArrayType)); + if (image) { + a = mono_image_memdup (image, a, sizeof (MonoArrayType)); if (a->sizes) - a->sizes = mono_mempool_dup (mp, a->sizes, a->numsizes * sizeof (int)); + a->sizes = mono_image_memdup (image, a->sizes, a->numsizes * sizeof (int)); if (a->lobounds) - a->lobounds = mono_mempool_dup (mp, a->lobounds, a->numlobounds * sizeof (int)); - mono_loader_unlock (); + a->lobounds = mono_image_memdup (image, a->lobounds, a->numlobounds * sizeof (int)); } else { a = g_memdup (a, sizeof (MonoArrayType)); if (a->sizes) @@ -203,15 +201,15 @@ mono_dup_array_type (MonoMemPool *mp, MonoArrayType *a) /* Copy everything mono_metadata_free_method_signature free. */ MonoMethodSignature* -mono_metadata_signature_deep_dup (MonoMemPool *mp, MonoMethodSignature *sig) +mono_metadata_signature_deep_dup (MonoImage *image, MonoMethodSignature *sig) { int i; - sig = mono_metadata_signature_dup_full (mp, sig); + sig = mono_metadata_signature_dup_full (image, sig); - sig->ret = mono_metadata_type_dup (mp, sig->ret); + sig->ret = mono_metadata_type_dup (image, sig->ret); for (i = 0; i < sig->param_count; ++i) - sig->params [i] = mono_metadata_type_dup (mp, sig->params [i]); + sig->params [i] = mono_metadata_type_dup (image, sig->params [i]); return sig; } @@ -370,7 +368,7 @@ mono_type_get_name_recurse (MonoType *type, GString *str, gboolean is_recursed, for (i = 0; i < klass->generic_container->type_argc; i++) { if (i) g_string_append_c (str, ','); - g_string_append (str, klass->generic_container->type_params [i].name); + g_string_append (str, mono_generic_container_get_param (klass->generic_container, i)->name); } if (format == MONO_TYPE_NAME_FORMAT_IL) g_string_append_c (str, '>'); @@ -489,12 +487,12 @@ mono_class_is_open_constructed_type (MonoType *t) } static MonoType* -inflate_generic_type (MonoMemPool *mempool, MonoType *type, MonoGenericContext *context) +inflate_generic_type (MonoImage *image, MonoType *type, MonoGenericContext *context) { switch (type->type) { case MONO_TYPE_MVAR: { MonoType *nt; - int num = type->data.generic_param->num; + int num = mono_type_get_generic_param_num (type); MonoGenericInst *inst = context->method_inst; if (!inst || !inst->type_argv) return NULL; @@ -506,20 +504,20 @@ inflate_generic_type (MonoMemPool *mempool, MonoType *type, MonoGenericContext * * while the VAR/MVAR duplicates a type from the context. So, we need to ensure that the * ->byref and ->attrs from @type are propagated to the returned type. */ - nt = mono_metadata_type_dup (mempool, inst->type_argv [num]); + nt = mono_metadata_type_dup (image, inst->type_argv [num]); nt->byref = type->byref; nt->attrs = type->attrs; return nt; } case MONO_TYPE_VAR: { MonoType *nt; - int num = type->data.generic_param->num; + int num = mono_type_get_generic_param_num (type); MonoGenericInst *inst = context->class_inst; if (!inst) return NULL; if (num >= inst->type_argc) g_error ("VAR %d (%s) cannot be expanded in this context with %d instantiations", num, type->data.generic_param->name, inst->type_argc); - nt = mono_metadata_type_dup (mempool, inst->type_argv [num]); + nt = mono_metadata_type_dup (image, inst->type_argv [num]); nt->byref = type->byref; nt->attrs = type->attrs; return nt; @@ -529,7 +527,7 @@ inflate_generic_type (MonoMemPool *mempool, MonoType *type, MonoGenericContext * MonoType *nt, *inflated = inflate_generic_type (NULL, &eclass->byval_arg, context); if (!inflated) return NULL; - nt = mono_metadata_type_dup (mempool, type); + nt = mono_metadata_type_dup (image, type); nt->data.klass = mono_class_from_mono_type (inflated); mono_metadata_free_type (inflated); return nt; @@ -539,7 +537,7 @@ inflate_generic_type (MonoMemPool *mempool, MonoType *type, MonoGenericContext * MonoType *nt, *inflated = inflate_generic_type (NULL, &eclass->byval_arg, context); if (!inflated) return NULL; - nt = mono_metadata_type_dup (mempool, type); + nt = mono_metadata_type_dup (image, type); nt->data.array = g_memdup (nt->data.array, sizeof (MonoArrayType)); nt->data.array->eklass = mono_class_from_mono_type (inflated); mono_metadata_free_type (inflated); @@ -559,7 +557,7 @@ inflate_generic_type (MonoMemPool *mempool, MonoType *type, MonoGenericContext * if (gclass == type->data.generic_class) return NULL; - nt = mono_metadata_type_dup (mempool, type); + nt = mono_metadata_type_dup (image, type); nt->data.generic_class = gclass; return nt; } @@ -581,7 +579,7 @@ inflate_generic_type (MonoMemPool *mempool, MonoType *type, MonoGenericContext * gclass = mono_metadata_lookup_generic_class (klass, inst, klass->image->dynamic); - nt = mono_metadata_type_dup (mempool, type); + nt = mono_metadata_type_dup (image, type); nt->type = MONO_TYPE_GENERICINST; nt->data.generic_class = gclass; return nt; @@ -643,12 +641,12 @@ mono_class_get_generic_class (MonoClass *klass) * modified by the caller, and it should be freed using mono_metadata_free_type (). */ MonoType* -mono_class_inflate_generic_type_with_mempool (MonoMemPool *mempool, MonoType *type, MonoGenericContext *context) +mono_class_inflate_generic_type_with_mempool (MonoImage *image, MonoType *type, MonoGenericContext *context) { MonoType *inflated = NULL; if (context) - inflated = inflate_generic_type (mempool, type, context); + inflated = inflate_generic_type (image, type, context); if (!inflated) { MonoType *shared = mono_metadata_get_shared_type (type); @@ -656,7 +654,7 @@ mono_class_inflate_generic_type_with_mempool (MonoMemPool *mempool, MonoType *ty if (shared) { return shared; } else { - return mono_metadata_type_dup (mempool, type); + return mono_metadata_type_dup (image, type); } } @@ -682,18 +680,18 @@ mono_class_inflate_generic_type (MonoType *type, MonoGenericContext *context) } /* - * mono_class_inflate_generic_type_with_mempool_no_copy: + * mono_class_inflate_generic_type_no_copy: * * Same as inflate_generic_type_with_mempool, but return TYPE if no inflation * was done. */ static MonoType* -mono_class_inflate_generic_type_with_mempool_no_copy (MonoMemPool *mempool, MonoType *type, MonoGenericContext *context) +mono_class_inflate_generic_type_no_copy (MonoImage *image, MonoType *type, MonoGenericContext *context) { MonoType *inflated = NULL; if (context) - inflated = inflate_generic_type (mempool, type, context); + inflated = inflate_generic_type (image, type, context); if (!inflated) return type; @@ -905,14 +903,43 @@ mono_get_inflated_method (MonoMethod *method) return method; } +/* + * mono_method_get_context_general: + * @method: a method + * @uninflated: handle uninflated methods? + * + * Returns the generic context of a method or NULL if it doesn't have + * one. For an inflated method that's the context stored in the + * method. Otherwise it's in the method's generic container or in the + * generic container of the method's class. + */ MonoGenericContext* -mono_method_get_context (MonoMethod *method) +mono_method_get_context_general (MonoMethod *method, gboolean uninflated) { - MonoMethodInflated *imethod; - if (!method->is_inflated) + if (method->is_inflated) { + MonoMethodInflated *imethod = (MonoMethodInflated *) method; + return &imethod->context; + } + if (!uninflated) return NULL; - imethod = (MonoMethodInflated *) method; - return &imethod->context; + if (method->is_generic) + return &(mono_method_get_generic_container (method)->context); + if (method->klass->generic_container) + return &method->klass->generic_container->context; + return NULL; +} + +/* + * mono_method_get_context: + * @method: a method + * + * Returns the generic context for method if it's inflated, otherwise + * NULL. + */ +MonoGenericContext* +mono_method_get_context (MonoMethod *method) +{ + return mono_method_get_context_general (method, FALSE); } /* @@ -930,9 +957,7 @@ mono_method_get_generic_container (MonoMethod *method) if (!method->is_generic) return NULL; - mono_loader_lock (); - container = mono_property_hash_lookup (method->klass->image->property_hash, method, MONO_METHOD_PROP_GENERIC_CONTAINER); - mono_loader_unlock (); + container = mono_image_property_lookup (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER); g_assert (container); return container; @@ -949,9 +974,7 @@ mono_method_set_generic_container (MonoMethod *method, MonoGenericContainer* con { g_assert (method->is_generic); - mono_loader_lock (); - mono_property_hash_insert (method->klass->image->property_hash, method, MONO_METHOD_PROP_GENERIC_CONTAINER, container); - mono_loader_unlock (); + mono_image_property_insert (method->klass->image, method, MONO_METHOD_PROP_GENERIC_CONTAINER, container); } /** @@ -1128,7 +1151,7 @@ mono_class_setup_fields (MonoClass *class) field->name = mono_field_get_name (gfield); /*This memory must come from the image mempool as we don't have a chance to free it.*/ - field->type = mono_class_inflate_generic_type_with_mempool_no_copy (class->image->mempool, gfield->type, mono_class_get_context (class)); + field->type = mono_class_inflate_generic_type_no_copy (class->image, gfield->type, mono_class_get_context (class)); g_assert (field->type->attrs == gfield->type->attrs); if (mono_field_is_deleted (field)) continue; @@ -1580,6 +1603,8 @@ mono_class_setup_methods (MonoClass *class) class->method.count = 3 + (class->rank > 1? 2: 1); + mono_class_setup_interfaces (class); + if (class->interface_count) { count_generic = generic_array_methods (class); first_generic = class->method.count; @@ -1730,17 +1755,7 @@ mono_class_get_inflated_method (MonoClass *class, MonoMethod *method) MonoMethod* mono_class_get_vtable_entry (MonoClass *class, int offset) { - if (class->generic_class) { - MonoClass *gklass = class->generic_class->container_class; - mono_class_setup_vtable (gklass); - if (gklass->vtable [offset]->wrapper_type == MONO_WRAPPER_STATIC_RGCTX_INVOKE) { - MonoMethod *method = mono_marshal_method_from_wrapper (gklass->vtable [offset]); - method = mono_class_inflate_generic_method_full (method, class, mono_class_get_context (class)); - return mono_marshal_get_static_rgctx_invoke (method); - } else { - return mono_class_inflate_generic_method_full (gklass->vtable [offset], class, mono_class_get_context (class)); - } - } + MonoMethod *m; if (class->rank == 1) { /* @@ -1752,8 +1767,24 @@ mono_class_get_vtable_entry (MonoClass *class, int offset) return class->parent->vtable [offset]; } - mono_class_setup_vtable (class); - return class->vtable [offset]; + if (class->generic_class) { + MonoClass *gklass = class->generic_class->container_class; + mono_class_setup_vtable (gklass); + m = gklass->vtable [offset]; + + m = mono_class_inflate_generic_method_full (m, class, mono_class_get_context (class)); + } else { + mono_class_setup_vtable (class); + m = class->vtable [offset]; + } + + /* + * We have to add static rgctx wrappers somewhere, we do it here, + * altough it should probably be done by the JIT. + */ + if (mono_method_needs_static_rgctx_invoke (m, FALSE)) + m = mono_marshal_get_static_rgctx_invoke (m); + return m; } static void @@ -2067,6 +2098,8 @@ collect_implemented_interfaces_aux (MonoClass *klass, GPtrArray **res) { int i; MonoClass *ic; + + mono_class_setup_interfaces (klass); for (i = 0; i < klass->interface_count; i++) { ic = klass->interfaces [i]; @@ -2694,17 +2727,6 @@ mono_class_setup_vtable (MonoClass *class) return; } -static void -check_core_clr_override_method (MonoClass *class, MonoMethod *override, MonoMethod *base) -{ - MonoSecurityCoreCLRLevel override_level = mono_security_core_clr_method_level (override, FALSE); - MonoSecurityCoreCLRLevel base_level = mono_security_core_clr_method_level (base, FALSE); - - if (override_level != base_level && base_level == MONO_SECURITY_CORE_CLR_CRITICAL) - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); -} - - #define DEBUG_INTERFACE_VTABLE_CODE 0 #define TRACE_INTERFACE_VTABLE_CODE 0 #define VERIFY_INTERFACE_VTABLE_CODE 0 @@ -2803,7 +2825,7 @@ check_interface_method_override (MonoClass *class, MonoMethod *im, MonoMethod *c } if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) - check_core_clr_override_method (class, cm, im); + mono_security_core_clr_check_override (class, cm, im); TRACE_INTERFACE_VTABLE (printf ("[NAME CHECK OK]")); return TRUE; } else { @@ -2872,7 +2894,7 @@ check_interface_method_override (MonoClass *class, MonoMethod *im, MonoMethod *c } if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) - check_core_clr_override_method (class, cm, im); + mono_security_core_clr_check_override (class, cm, im); TRACE_INTERFACE_VTABLE (printf ("[INJECTED INTERFACE CHECK OK]")); return TRUE; @@ -2975,7 +2997,7 @@ mono_class_verify_vtable (MonoClass *class) continue; } - if (slot >= 0 && class->vtable [slot] != cm && (class->vtable [slot] && class->vtable [slot]->wrapper_type != MONO_WRAPPER_STATIC_RGCTX_INVOKE)) { + if (slot >= 0 && class->vtable [slot] != cm && (class->vtable [slot])) { char *other_name = class->vtable [slot] ? mono_method_full_name (class->vtable [slot], TRUE) : g_strdup ("[null value]"); printf ("\tMethod %s has slot %d but vtable has %s on it\n", full_name, slot, other_name); g_free (other_name); @@ -3062,31 +3084,28 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o /* Optimized version for generic instances */ if (class->generic_class) { MonoClass *gklass = class->generic_class->container_class; - gboolean usable = TRUE; + MonoMethod **tmp; mono_class_setup_vtable (gklass); + + tmp = mono_image_alloc0 (class->image, sizeof (gpointer) * gklass->vtable_size); + class->vtable_size = gklass->vtable_size; for (i = 0; i < gklass->vtable_size; ++i) - if (gklass->vtable [i] && gklass->vtable [i]->wrapper_type == MONO_WRAPPER_STATIC_RGCTX_INVOKE) - usable = FALSE; - - if (usable) { - MonoMethod **tmp = mono_image_alloc0 (class->image, sizeof (gpointer) * gklass->vtable_size); - class->vtable_size = gklass->vtable_size; - for (i = 0; i < gklass->vtable_size; ++i) - if (gklass->vtable [i]) - tmp [i] = mono_class_inflate_generic_method_full (gklass->vtable [i], class, mono_class_get_context (class)); - mono_memory_barrier (); - class->vtable = tmp; - - /* Have to set method->slot for abstract virtual methods */ - if (class->methods && gklass->methods) { - for (i = 0; i < class->method.count; ++i) - if (class->methods [i]->slot == -1) - class->methods [i]->slot = gklass->methods [i]->slot; + if (gklass->vtable [i]) { + tmp [i] = mono_class_inflate_generic_method_full (gklass->vtable [i], class, mono_class_get_context (class)); + tmp [i]->slot = gklass->vtable [i]->slot; } + mono_memory_barrier (); + class->vtable = tmp; - return; + /* Have to set method->slot for abstract virtual methods */ + if (class->methods && gklass->methods) { + for (i = 0; i < class->method.count; ++i) + if (class->methods [i]->slot == -1) + class->methods [i]->slot = gklass->methods [i]->slot; } + + return; } if (class->parent && class->parent->vtable_size) { @@ -3135,7 +3154,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o g_hash_table_insert (override_map, overrides [i * 2], overrides [i * 2 + 1]); if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) - check_core_clr_override_method (class, vtable [dslot], decl); + mono_security_core_clr_check_override (class, vtable [dslot], decl); } } TRACE_INTERFACE_VTABLE (print_overrides (override_map, "AFTER OVERRIDING INTERFACE METHODS")); @@ -3291,7 +3310,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o } if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) - check_core_clr_override_method (class, cm, m1); + mono_security_core_clr_check_override (class, cm, m1); slot = mono_method_get_vtable_slot (m1); g_assert (cm->slot < max_vtsize); @@ -3327,7 +3346,7 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o g_hash_table_insert (override_map, decl, overrides [i * 2 + 1]); if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) - check_core_clr_override_method (class, vtable [decl->slot], decl); + mono_security_core_clr_check_override (class, vtable [decl->slot], decl); } } @@ -3359,15 +3378,6 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o class->vtable_size = cur_slot; } - /* FIXME: only do this if the class is actually sharable */ - if (class->valuetype && (class->generic_class || class->generic_container) && - mono_class_generic_sharing_enabled (class)) { - for (i = 0; i < max_vtsize; ++i) { - if (vtable [i] && vtable [i]->wrapper_type == MONO_WRAPPER_NONE) - vtable [i] = mono_marshal_get_static_rgctx_invoke (vtable [i]); - } - } - /* Try to share the vtable with our parent. */ if (class->parent && (class->parent->vtable_size == class->vtable_size) && (memcmp (class->parent->vtable, vtable, sizeof (gpointer) * class->vtable_size) == 0)) { mono_memory_barrier (); @@ -3493,16 +3503,6 @@ initialize_object_slots (MonoClass *class) } } -static GList* -g_list_prepend_mempool (GList* l, MonoMemPool* mp, gpointer datum) -{ - GList* n = mono_mempool_alloc (mp, sizeof (GList)); - n->next = l; - n->prev = NULL; - n->data = datum; - return n; -} - typedef struct { MonoMethod *array_method; char *name; @@ -3645,22 +3645,6 @@ set_failure_from_loader_error (MonoClass *class, MonoLoaderError *error) mono_class_set_failure (class, error->exception_type, exception_data); } -static void -check_core_clr_inheritance (MonoClass *class) -{ - MonoSecurityCoreCLRLevel class_level, parent_level; - MonoClass *parent = class->parent; - - if (!parent) - return; - - class_level = mono_security_core_clr_class_level (class); - parent_level = mono_security_core_clr_class_level (parent); - - if (class_level < parent_level) - mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL); -} - /** * mono_class_init: * @class: the class to initialize @@ -3711,7 +3695,7 @@ mono_class_init (MonoClass *class) } if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) - check_core_clr_inheritance (class); + mono_security_core_clr_check_inheritance (class); mono_stats.initialized_class_count++; @@ -3729,8 +3713,6 @@ mono_class_init (MonoClass *class) if (MONO_CLASS_IS_INTERFACE (class)) class->interface_id = mono_get_unique_iid (class); - - g_assert (class->interface_count == gklass->interface_count); } if (class->parent && !class->parent->inited) @@ -4306,6 +4288,7 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token) class->interfaces = interfaces; class->interface_count = icount; + class->interfaces_inited = 1; } if ((class->flags & TYPE_ATTRIBUTE_STRING_FORMAT_MASK) == TYPE_ATTRIBUTE_UNICODE_CLASS) @@ -4408,7 +4391,6 @@ MonoClass* mono_generic_class_get_class (MonoGenericClass *gclass) { MonoClass *klass, *gklass; - int i; mono_loader_lock (); if (gclass->cached_class) { @@ -4455,12 +4437,6 @@ mono_generic_class_get_class (MonoGenericClass *gclass) if (mono_class_is_nullable (klass)) klass->cast_class = klass->element_class = mono_class_get_nullable_param (klass); - klass->interface_count = gklass->interface_count; - klass->interfaces = g_new0 (MonoClass *, klass->interface_count); - for (i = 0; i < klass->interface_count; i++) { - klass->interfaces [i] = mono_class_inflate_generic_class (gklass->interfaces [i], mono_generic_class_get_context (gclass)); - } - /* * We're not interested in the nested classes of a generic instance. * We use the generic type definition to look for nested classes. @@ -4511,6 +4487,7 @@ mono_generic_class_get_class (MonoGenericClass *gclass) MonoClass * mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gboolean is_mvar) { + MonoGenericContainer *container; MonoClass *klass, **ptr; int count, pos, i; @@ -4521,12 +4498,13 @@ mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gb return param->pklass; } - if (!image && param->owner) { + container = mono_generic_param_owner (param); + if (!image && container) { if (is_mvar) { - MonoMethod *method = param->owner->owner.method; + MonoMethod *method = container->owner.method; image = (method && method->klass) ? method->klass->image : NULL; } else { - MonoClass *klass = param->owner->owner.klass; + MonoClass *klass = container->owner.klass; // FIXME: 'klass' should not be null // But, monodis creates GenericContainers without associating a owner to it image = klass ? klass->image : NULL; @@ -4543,8 +4521,9 @@ mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gb if (param->name) klass->name = param->name; else { + int n = mono_generic_param_num (param); klass->name = mono_image_alloc0 (image, 16); - sprintf ((char*)klass->name, is_mvar ? "!!%d" : "!%d", param->num); + sprintf ((char*)klass->name, is_mvar ? "!!%d" : "!%d", n); } klass->name_space = ""; mono_profiler_class_event (klass, MONO_PROFILE_START_LOAD); @@ -4581,21 +4560,21 @@ mono_class_from_generic_parameter (MonoGenericParam *param, MonoImage *image, gb klass->this_arg.data.generic_param = klass->byval_arg.data.generic_param = param; klass->this_arg.byref = TRUE; - if (param->owner) { + if (container) { guint32 owner; guint32 cols [MONO_GENERICPARAM_SIZE]; MonoTableInfo *tdef = &image->tables [MONO_TABLE_GENERICPARAM]; i = 0; - if (is_mvar && param->owner->owner.method) - i = mono_metadata_get_generic_param_row (image, param->owner->owner.method->token, &owner); - else if (!is_mvar && param->owner->owner.klass) - i = mono_metadata_get_generic_param_row (image, param->owner->owner.klass->type_token, &owner); + if (is_mvar && container->owner.method) + i = mono_metadata_get_generic_param_row (image, container->owner.method->token, &owner); + else if (!is_mvar && container->owner.klass) + i = mono_metadata_get_generic_param_row (image, container->owner.klass->type_token, &owner); if (i) { mono_metadata_decode_row (tdef, i - 1, cols, MONO_GENERICPARAM_SIZE); do { - if (cols [MONO_GENERICPARAM_NUMBER] == param->num) { + if (cols [MONO_GENERICPARAM_NUMBER] == mono_generic_param_num (param)) { klass->sizes.generic_param_token = i | MONO_TOKEN_GENERIC_PARAM; break; } @@ -4858,17 +4837,34 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) image = eclass->image; - mono_loader_lock (); + if (rank == 1 && !bounded) { + /* + * This case is very frequent not just during compilation because of calls + * from mono_class_from_mono_type (), mono_array_new (), + * Array:CreateInstance (), etc, so use a separate cache + a separate lock. + */ + EnterCriticalSection (&image->szarray_cache_lock); + if (!image->szarray_cache) + image->szarray_cache = g_hash_table_new (mono_aligned_addr_hash, NULL); + class = g_hash_table_lookup (image->szarray_cache, eclass); + LeaveCriticalSection (&image->szarray_cache_lock); + if (class) + return class; + + mono_loader_lock (); + } else { + mono_loader_lock (); - if (!image->array_cache) - image->array_cache = g_hash_table_new (mono_aligned_addr_hash, NULL); + if (!image->array_cache) + image->array_cache = g_hash_table_new (mono_aligned_addr_hash, NULL); - if ((rootlist = list = g_hash_table_lookup (image->array_cache, eclass))) { - for (; list; list = list->next) { - class = list->data; - if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) { - mono_loader_unlock (); - return class; + if ((rootlist = list = g_hash_table_lookup (image->array_cache, eclass))) { + for (; list; list = list->next) { + class = list->data; + if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) { + mono_loader_unlock (); + return class; + } } } } @@ -4923,18 +4919,6 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) mono_class_setup_supertypes (class); - if (mono_defaults.generic_ilist_class && !bounded && rank == 1) { - MonoType *args [1]; - - /* generic IList, ICollection, IEnumerable */ - class->interface_count = 1; - class->interfaces = mono_image_alloc0 (image, sizeof (MonoClass*) * class->interface_count); - - args [0] = &eclass->byval_arg; - class->interfaces [0] = mono_class_bind_generic_parameters ( - mono_defaults.generic_ilist_class, 1, args, FALSE); - } - if (eclass->generic_class) mono_class_init (eclass); if (!eclass->size_inited) @@ -4969,8 +4953,21 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded) class->generic_container = eclass->generic_container; - list = g_slist_append (rootlist, class); - g_hash_table_insert (image->array_cache, eclass, list); + if (rank == 1 && !bounded) { + MonoClass *prev_class; + + EnterCriticalSection (&image->szarray_cache_lock); + prev_class = g_hash_table_lookup (image->szarray_cache, eclass); + if (prev_class) + /* Someone got in before us */ + class = prev_class; + else + g_hash_table_insert (image->szarray_cache, eclass, class); + LeaveCriticalSection (&image->szarray_cache_lock); + } else { + list = g_slist_append (rootlist, class); + g_hash_table_insert (image->array_cache, eclass, list); + } mono_loader_unlock (); @@ -5890,7 +5887,7 @@ mono_class_has_variant_generic_params (MonoClass *klass) container = klass->generic_class->container_class->generic_container; for (i = 0; i < container->type_argc; ++i) - if (container->type_params [i].flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)) + if (mono_generic_container_get_param (container, i)->flags & (MONO_GEN_PARAM_VARIANT|MONO_GEN_PARAM_COVARIANT)) return TRUE; return FALSE; @@ -5968,9 +5965,9 @@ mono_class_is_assignable_from (MonoClass *klass, MonoClass *oklass) * _CONTRAVARIANT, but they are in a public header so we can't fix it. */ if (param1_class != param2_class) { - if ((container->type_params [i].flags & MONO_GEN_PARAM_VARIANT) && mono_class_is_assignable_from (param1_class, param2_class)) + if ((mono_generic_container_get_param (container, i)->flags & MONO_GEN_PARAM_VARIANT) && mono_class_is_assignable_from (param1_class, param2_class)) ; - else if (((container->type_params [i].flags & MONO_GEN_PARAM_COVARIANT) && mono_class_is_assignable_from (param2_class, param1_class))) + else if (((mono_generic_container_get_param (container, i)->flags & MONO_GEN_PARAM_COVARIANT) && mono_class_is_assignable_from (param2_class, param1_class))) ; else { match = FALSE; @@ -6749,9 +6746,11 @@ mono_class_get_interfaces (MonoClass* klass, gpointer *iter) MonoClass** iface; if (!iter) return NULL; - if (!klass->inited) - mono_class_init (klass); if (!*iter) { + if (!klass->inited) + mono_class_init (klass); + if (!klass->interfaces_inited) + mono_class_setup_interfaces (klass); /* start from the first */ if (klass->interface_count) { *iter = &klass->interfaces [0]; @@ -6805,7 +6804,7 @@ mono_class_get_nested_types (MonoClass* klass, gpointer *iter) mono_metadata_decode_row (&klass->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE); nclass = mono_class_create_from_typedef (klass->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED]); mono_class_alloc_ext (klass); - klass->ext->nested_classes = g_list_prepend_mempool (klass->ext->nested_classes, klass->image->mempool, nclass); + klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, nclass); i = mono_metadata_nesting_typedef (klass->image, klass->type_token, i + 1); } @@ -7192,7 +7191,7 @@ mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data) mono_loader_lock (); klass->exception_type = ex_type; if (ex_data) - mono_property_hash_insert (klass->image->property_hash, klass, MONO_CLASS_PROP_EXCEPTION_DATA, ex_data); + mono_image_property_insert (klass->image, klass, MONO_CLASS_PROP_EXCEPTION_DATA, ex_data); mono_loader_unlock (); return TRUE; @@ -7208,12 +7207,7 @@ mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data) gpointer mono_class_get_exception_data (MonoClass *klass) { - gpointer res; - - mono_loader_lock (); - res = mono_property_hash_lookup (klass->image->property_hash, klass, MONO_CLASS_PROP_EXCEPTION_DATA); - mono_loader_unlock (); - return res; + return mono_image_property_lookup (klass->image, klass, MONO_CLASS_PROP_EXCEPTION_DATA); } /** @@ -7847,4 +7841,50 @@ mono_class_alloc_ext (MonoClass *klass) class_ext_size += sizeof (MonoClassExt); } } - + +/* + * mono_class_setup_interfaces: + * + * Initialize class->interfaces/interfaces_count. + * LOCKING: Acquires the loader lock. + */ +void +mono_class_setup_interfaces (MonoClass *klass) +{ + int i; + + if (klass->interfaces_inited) + return; + + mono_loader_lock (); + + if (klass->interfaces_inited) { + mono_loader_unlock (); + return; + } + + if (klass->rank == 1 && klass->byval_arg.type != MONO_TYPE_ARRAY && mono_defaults.generic_ilist_class) { + MonoType *args [1]; + + /* generic IList, ICollection, IEnumerable */ + klass->interface_count = 1; + klass->interfaces = mono_image_alloc0 (klass->image, sizeof (MonoClass*) * klass->interface_count); + + args [0] = &klass->element_class->byval_arg; + klass->interfaces [0] = mono_class_bind_generic_parameters ( + mono_defaults.generic_ilist_class, 1, args, FALSE); + } else if (klass->generic_class) { + MonoClass *gklass = klass->generic_class->container_class; + + klass->interface_count = gklass->interface_count; + klass->interfaces = g_new0 (MonoClass *, klass->interface_count); + for (i = 0; i < klass->interface_count; i++) + klass->interfaces [i] = mono_class_inflate_generic_class (gklass->interfaces [i], mono_generic_class_get_context (klass->generic_class)); + } + + mono_memory_barrier (); + + klass->interfaces_inited = TRUE; + + mono_loader_unlock (); +}