Skip visibility checks from corlib internal assemblies.

[mono.git] / mono / metadata / class.c

diff --git a/mono/metadata/class.c b/mono/metadata/class.c
index e00aace953a8ac94ba659c707fb2f64db57c41de..95ab07ff6b9664d20741a1b5a12c8535dda0ce79 100644 (file)
--- a/mono/metadata/class.c
+++ b/mono/metadata/class.c
@@ -5439,14 +5439,16 @@ mono_generic_class_get_class (MonoGenericClass *gclass)
 {
        MonoClass *klass, *gklass;
 
+       if (gclass->cached_class)
+               return gclass->cached_class;
+
        mono_loader_lock ();
        if (gclass->cached_class) {
                mono_loader_unlock ();
                return gclass->cached_class;
        }
 
-       gclass->cached_class = mono_image_set_alloc0 (gclass->owner, sizeof (MonoClass));
-       klass = gclass->cached_class;
+       klass = mono_image_set_alloc0 (gclass->owner, sizeof (MonoClass));
 
        gklass = gclass->container_class;
 
@@ -5520,6 +5522,9 @@ mono_generic_class_get_class (MonoGenericClass *gclass)
                }
        }
 
+       mono_memory_barrier ();
+       gclass->cached_class = klass;
+
        mono_profiler_class_loaded (klass, MONO_PROFILE_OK);
 
        inflated_classes ++;
@@ -5621,40 +5626,65 @@ make_generic_param_class (MonoGenericParam *param, MonoImage *image, gboolean is
 }
 
 #define FAST_CACHE_SIZE 16
-static MonoClass *var_cache_fast [FAST_CACHE_SIZE];
-static MonoClass *mvar_cache_fast [FAST_CACHE_SIZE];
-static GHashTable *var_cache_slow;
-static GHashTable *mvar_cache_slow;
 
 static MonoClass *
 get_anon_gparam_class (MonoGenericParam *param, gboolean is_mvar)
 {
        int n = mono_generic_param_num (param);
+       MonoImage *image = param->image;
        GHashTable *ht;
 
-       if (n < FAST_CACHE_SIZE)
-               return (is_mvar ? mvar_cache_fast : var_cache_fast) [n];
-       ht = is_mvar ? mvar_cache_slow : var_cache_slow;
-       return ht ? g_hash_table_lookup (ht, GINT_TO_POINTER (n)) : NULL;
+       g_assert (image);
+
+       if (n < FAST_CACHE_SIZE) {
+               if (is_mvar)
+                       return image->mvar_cache_fast ? image->mvar_cache_fast [n] : NULL;
+               else
+                       return image->var_cache_fast ? image->var_cache_fast [n] : NULL;
+       } else {
+               ht = is_mvar ? image->mvar_cache_slow : image->var_cache_slow;
+               return ht ? g_hash_table_lookup (ht, GINT_TO_POINTER (n)) : NULL;
+       }
 }
 
+/*
+ * LOCKING: Acquires the loader lock.
+ */
 static void
 set_anon_gparam_class (MonoGenericParam *param, gboolean is_mvar, MonoClass *klass)
 {
        int n = mono_generic_param_num (param);
+       MonoImage *image = param->image;
        GHashTable *ht;
 
+       g_assert (image);
+
        if (n < FAST_CACHE_SIZE) {
-               (is_mvar ? mvar_cache_fast : var_cache_fast) [n] = klass;
+               if (is_mvar) {
+                       /* No locking needed */
+                       if (!image->mvar_cache_fast)
+                               image->mvar_cache_fast = mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE);
+                       image->mvar_cache_fast [n] = klass;
+               } else {
+                       if (!image->var_cache_fast)
+                               image->var_cache_fast = mono_image_alloc0 (image, sizeof (MonoClass*) * FAST_CACHE_SIZE);
+                       image->var_cache_fast [n] = klass;
+               }
                return;
        }
-       ht = is_mvar ? mvar_cache_slow : var_cache_slow;
+       ht = is_mvar ? image->mvar_cache_slow : image->var_cache_slow;
        if (!ht) {
-               ht = g_hash_table_new (NULL, NULL);
-               if (is_mvar)
-                       mvar_cache_slow = ht;
-               else
-                       var_cache_slow = ht;
+               mono_loader_lock ();
+               ht = is_mvar ? image->mvar_cache_slow : image->var_cache_slow;
+               if (!ht) {
+                       ht = g_hash_table_new (NULL, NULL);
+                       mono_memory_barrier ();
+                       if (is_mvar)
+                               image->mvar_cache_slow = ht;
+                       else
+                               image->var_cache_slow = ht;
+               }
+               mono_loader_unlock ();
        }
 
        g_hash_table_insert (ht, GINT_TO_POINTER (n), klass);
@@ -7044,7 +7074,8 @@ mono_class_from_name (MonoImage *image, const char* name_space, const char *name
                name = buf;
        }
 
-       if (get_class_from_name) {
+       /* FIXME: get_class_from_name () can't handle types in the EXPORTEDTYPE table */
+       if (get_class_from_name && image->tables [MONO_TABLE_EXPORTEDTYPE].rows == 0) {
                gboolean res = get_class_from_name (image, name_space, name, &class);
                if (res) {
                        if (!class)
@@ -7198,7 +7229,7 @@ mono_class_is_variant_compatible (MonoClass *klass, MonoClass *oklass)
        MonoGenericContainer *container = klass_gtd->generic_container;
 
        /*Viable candidates are instances of the same generic interface*/
-       if (mono_class_get_generic_type_definition (oklass) != klass_gtd)
+       if (mono_class_get_generic_type_definition (oklass) != klass_gtd || oklass == klass_gtd)
                return FALSE;
 
        klass_argv = &klass->generic_class->context.class_inst->type_argv [0];
@@ -7338,7 +7369,7 @@ mono_class_is_variant_compatible_slow (MonoClass *klass, MonoClass *oklass)
        MonoGenericContainer *container = klass_gtd->generic_container;
 
        /*Viable candidates are instances of the same generic interface*/
-       if (mono_class_get_generic_type_definition (oklass) != klass_gtd)
+       if (mono_class_get_generic_type_definition (oklass) != klass_gtd || oklass == klass_gtd)
                return FALSE;
 
        klass_argv = &klass->generic_class->context.class_inst->type_argv [0];
@@ -7506,7 +7537,7 @@ mono_class_get_finalizer (MonoClass *klass)
 
        if (!klass->inited)
                mono_class_init (klass);
-       if (!klass->has_finalize)
+       if (!mono_class_has_finalizer (klass))
                return NULL;
 
        if (mono_class_get_cached_class_info (klass, &cached_info))
@@ -8991,6 +9022,9 @@ can_access_type (MonoClass *access_klass, MonoClass *member_klass)
 {
        int access_level;
 
+       if (access_klass->image->assembly && access_klass->image->assembly->corlib_internal)
+               return TRUE;
+
        if (access_klass->element_class && !access_klass->enumtype)
                access_klass = access_klass->element_class;
 
@@ -9050,6 +9084,9 @@ static gboolean
 can_access_member (MonoClass *access_klass, MonoClass *member_klass, MonoClass* context_klass, int access_level)
 {
        MonoClass *member_generic_def;
+       if (access_klass->image->assembly && access_klass->image->assembly->corlib_internal)
+               return TRUE;
+
        if (((access_klass->generic_class && access_klass->generic_class->container_class) ||
                                        access_klass->generic_container) && 
                        (member_generic_def = get_generic_definition_class (member_klass))) {