X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fclass.c;h=0013d793f058bb2744ce8d5ee0968df665be2b6e;hb=ab21e1fa482caf04f71d2ff6fa250f24b9f0eec3;hp=1545ca95ac808e80ea664f2842ff1f3757fbe360;hpb=2ced08a1f887627c5f53c4160117ed299bd54563;p=mono.git

diff --git a/mono/metadata/class.c b/mono/metadata/class.c
index 1545ca95ac8..0013d793f05 100644
--- a/mono/metadata/class.c
+++ b/mono/metadata/class.c
@@ -35,6 +35,9 @@ MonoStats mono_stats;
 
 gboolean mono_print_vtable = FALSE;
 
+/* Function supplied by the runtime to find classes by name using information from the AOT file */
+static MonoGetClassFromName get_class_from_name = NULL;
+
 static MonoClass * mono_class_create_from_typedef (MonoImage *image, guint32 type_token);
 static void mono_class_create_generic (MonoInflatedGenericClass *gclass);
 static gboolean mono_class_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res);
@@ -75,7 +78,19 @@ mono_class_from_typeref (MonoImage *image, guint32 type_token)
 		/* a typedef in disguise */
 		return mono_class_from_name (image, nspace, name);
 	case MONO_RESOLTION_SCOPE_MODULEREF:
-		return mono_class_from_name (image->modules [idx - 1], nspace, name);
+		if (image->modules [idx-1])
+			return mono_class_from_name (image->modules [idx - 1], nspace, name);
+		else {
+			char *msg = g_strdup_printf ("%s%s%s", nspace, nspace [0] ? "." : "", name);
+			char *human_name;
+			
+			human_name = mono_stringify_assembly_name (&image->assembly->aname);
+			mono_loader_set_error_type_load (msg, human_name);
+			g_free (msg);
+			g_free (human_name);
+		
+			return NULL;
+		}
 	case MONO_RESOLTION_SCOPE_TYPEREF: {
 		MonoClass *enclosing = mono_class_from_typeref (image, MONO_TOKEN_TYPE_REF | idx);
 		GList *tmp;
@@ -114,8 +129,19 @@ mono_class_from_typeref (MonoImage *image, guint32 type_token)
 	/* If this assert fails, it probably means that you haven't installed an assembly load/search hook */
 	g_assert (references == image->references);
 	g_assert (references [idx - 1]);
-	if (references [idx - 1] == (gpointer)-1)
+
+	/* If the assembly did not load, register this as a type load exception */
+	if (references [idx - 1] == REFERENCE_MISSING){
+		MonoAssemblyName aname;
+		char *human_name;
+		
+		mono_assembly_get_assemblyref (image, idx - 1, &aname);
+		human_name = mono_stringify_assembly_name (&aname);
+		mono_loader_set_error_assembly_load (human_name, image->assembly->ref_only);
+		g_free (human_name);
+		
 		return NULL;
+	}
 
 	return mono_class_from_name (references [idx - 1]->image, nspace, name);
 }
@@ -194,6 +220,8 @@ mono_type_get_name_recurse (MonoType *type, GString *str, gboolean is_recursed,
 		mono_type_get_name_recurse (
 			&type->data.array->eklass->byval_arg, str, FALSE, nested_format);
 		g_string_append_c (str, '[');
+		if (rank == 1)
+			g_string_append_c (str, '*');
 		for (i = 1; i < rank; i++)
 			g_string_append_c (str, ',');
 		g_string_append_c (str, ']');
@@ -791,9 +819,12 @@ mono_class_setup_fields (MonoClass *class)
 	}
 
 	class->instance_size = 0;
-	class->class_size = 0;
+	if (!class->rank)
+		class->sizes.class_size = 0;
 
 	if (class->parent) {
+		/* For generic instances, class->parent might not have been initialized */
+		mono_class_init (class->parent);
 		if (!class->parent->size_inited)
 			mono_class_setup_fields (class->parent);
 		class->instance_size += class->parent->instance_size;
@@ -879,7 +910,7 @@ mono_class_setup_fields (MonoClass *class)
 			field->type = mono_metadata_parse_type_full (m, container, MONO_PARSE_FIELD, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
 			if (!field->type) {
 				mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
-				continue;
+				break;
 			}
 			if (mono_field_is_deleted (field))
 				continue;
@@ -933,6 +964,8 @@ mono_class_setup_fields (MonoClass *class)
 		class->instance_size = MAX (real_size, class->instance_size);
 	}
 
+	if (class->exception_type)
+		return;
 	mono_class_layout_fields (class);
 }
 
@@ -971,7 +1004,11 @@ mono_class_has_references (MonoClass *klass)
 }
 
 /* useful until we keep track of gc-references in corlib etc. */
+#ifdef HAVE_SGEN_GC
+#define IS_GC_REFERENCE(t) FALSE
+#else
 #define IS_GC_REFERENCE(t) ((t)->type == MONO_TYPE_U || (t)->type == MONO_TYPE_I || (t)->type == MONO_TYPE_PTR)
+#endif
 
 /*
  * mono_class_layout_fields:
@@ -1170,6 +1207,16 @@ mono_class_layout_fields (MonoClass *class)
 		break;
 	}
 
+	if (layout != TYPE_ATTRIBUTE_EXPLICIT_LAYOUT) {
+		/*
+		 * For small structs, set min_align to at least the struct size, since the
+		 * JIT memset/memcpy code assumes this and generates unaligned accesses
+		 * otherwise. See #78990 for a testcase.
+		 */
+		if (class->instance_size <= sizeof (MonoObject) + sizeof (gpointer))
+			class->min_align = MAX (class->min_align, class->instance_size - sizeof (MonoObject));
+	}
+
 	class->size_inited = 1;
 
 	/*
@@ -1186,10 +1233,10 @@ mono_class_layout_fields (MonoClass *class)
 			continue;
 
 		size = mono_type_size (field->type, &align);
-		field->offset = class->class_size;
+		field->offset = class->sizes.class_size;
 		field->offset += align - 1;
 		field->offset &= ~(align - 1);
-		class->class_size = field->offset + size;
+		class->sizes.class_size = field->offset + size;
 	}
 }
 
@@ -1695,6 +1742,19 @@ setup_interface_offsets (MonoClass *class, int cur_slot)
 	return cur_slot;
 }
 
+/*
+ * Setup interface offsets for interfaces. Used by Ref.Emit.
+ */
+void
+mono_class_setup_interface_offsets (MonoClass *class)
+{
+	mono_loader_lock ();
+
+	setup_interface_offsets (class, 0);
+
+	mono_loader_unlock ();
+}
+
 void
 mono_class_setup_vtable (MonoClass *class)
 {
@@ -1702,6 +1762,7 @@ mono_class_setup_vtable (MonoClass *class)
 	MonoGenericContext *context;
 	guint32 type_token;
 	int onum = 0;
+	gboolean ok = TRUE;
 
 	if (class->vtable)
 		return;
@@ -1718,6 +1779,8 @@ mono_class_setup_vtable (MonoClass *class)
 		return;
 	}
 
+	mono_stats.generic_vtable_count ++;
+
 	if (class->generic_class) {
 		context = class->generic_class->context;
 		type_token = class->generic_class->container_class->type_token;
@@ -1728,13 +1791,19 @@ mono_class_setup_vtable (MonoClass *class)
 
 	if (class->image->dynamic)
 		mono_reflection_get_dynamic_overrides (class, &overrides, &onum);
-	else
-		mono_class_get_overrides_full (class->image, type_token, &overrides, &onum, context);
+	else {
+		/* The following call fails if there are missing methods in the type */
+		ok = mono_class_get_overrides_full (class->image, type_token, &overrides, &onum, context);
+	}
 
-	mono_class_setup_vtable_general (class, overrides, onum);
+	if (ok)
+		mono_class_setup_vtable_general (class, overrides, onum);
+		
 	g_free (overrides);
 
 	mono_loader_unlock ();
+
+	return;
 }
 
 /*
@@ -1957,11 +2026,14 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o
 					 */
 					if (!(vtable [io + l])) {
 						MonoClass *parent = class->parent;
-
-						if ((ic->interface_id <= parent->max_interface_id) && 
-							(parent->interface_offsets [ic->interface_id] != -1) &&
-							parent->vtable)
-							vtable [io + l] = parent->vtable [parent->interface_offsets [ic->interface_id] + l];
+						
+						for (; parent; parent = parent->parent) {
+							if ((ic->interface_id <= parent->max_interface_id) && 
+									(parent->interface_offsets [ic->interface_id] != -1) &&
+									parent->vtable) {
+								vtable [io + l] = parent->vtable [parent->interface_offsets [ic->interface_id] + l];
+							}
+						}
 					}
 
 					if (!(vtable [io + l])) {
@@ -2024,10 +2096,21 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o
 				int j;
 				for (j = 0; j < k->method.count; ++j) {
 					MonoMethod *m1 = k->methods [j];
+					MonoMethodSignature *cmsig, *m1sig;
+
 					if (!(m1->flags & METHOD_ATTRIBUTE_VIRTUAL))
 						continue;
+
+					cmsig = mono_method_signature (cm);
+					m1sig = mono_method_signature (m1);
+
+					if (!cmsig || !m1sig) {
+						mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, NULL);
+						return;
+					}
+
 					if (!strcmp(cm->name, m1->name) && 
-					    mono_metadata_signature_equal (mono_method_signature (cm), mono_method_signature (m1))) {
+					    mono_metadata_signature_equal (cmsig, m1sig)) {
 
 						/* CAS - SecurityAction.InheritanceDemand */
 						if (security_enabled && (m1->flags & METHOD_ATTRIBUTE_HAS_SECURITY)) {
@@ -2093,8 +2176,13 @@ mono_class_setup_vtable_general (MonoClass *class, MonoMethod **overrides, int o
 	} else
 		class->vtable_size = cur_slot;
 
-	class->vtable = g_malloc0 (sizeof (gpointer) * class->vtable_size);
-	memcpy (class->vtable, vtable,  sizeof (gpointer) * class->vtable_size);
+	/* 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)) {
+		class->vtable = class->parent->vtable;
+	} else {
+		class->vtable = mono_mempool_alloc0 (class->image->mempool, sizeof (gpointer) * class->vtable_size);
+		memcpy (class->vtable, vtable,  sizeof (gpointer) * class->vtable_size);
+	}
 
 	if (mono_print_vtable) {
 		int icount = 0;
@@ -2170,6 +2258,56 @@ 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;
+}
+
+static void
+setup_generic_array_ifaces (MonoClass *class, MonoClass *iface, int pos)
+{
+	MonoGenericContext *context;
+	int i;
+
+	context = g_new0 (MonoGenericContext, 1);
+	context->container = iface->generic_class->context->container;
+	context->gmethod = g_new0 (MonoGenericMethod, 1);
+	context->gmethod->generic_class = iface->generic_class;
+	context->gmethod->inst = iface->generic_class->inst;
+
+	for (i = 0; i < class->parent->method.count; i++) {
+		MonoMethod *m = class->parent->methods [i];
+		MonoMethod *inflated;
+		const char *mname, *iname;
+		gchar *name;
+
+		if (!strncmp (m->name, "InternalArray__ICollection_", 27)) {
+			iname = "System.Collections.Generic.ICollection`1.";
+			mname = m->name + 27;
+		} else if (!strncmp (m->name, "InternalArray__IEnumerable_", 27)) {
+			iname = "System.Collections.Generic.IEnumerable`1.";
+			mname = m->name + 27;
+		} else if (!strncmp (m->name, "InternalArray__", 15)) {
+			iname = "System.Collections.Generic.IList`1.";
+			mname = m->name + 15;
+		} else {
+			continue;
+		}
+
+		name = mono_mempool_alloc (class->image->mempool, strlen (iname) + strlen (mname) + 1);
+		strcpy (name, iname);
+		strcpy (name + strlen (iname), mname);
+
+		inflated = mono_class_inflate_generic_method (m, context);
+		class->methods [pos++] = mono_marshal_get_generic_array_helper (class, iface, name, inflated);
+	}
+}
+
 /**
  * mono_class_init:
  * @class: the class to initialize
@@ -2177,19 +2315,23 @@ initialize_object_slots (MonoClass *class)
  * compute the instance_size, class_size and other infos that cannot be 
  * computed at mono_class_get() time. Also compute a generic vtable and 
  * the method slot numbers. We use this infos later to create a domain
- * specific vtable.  
+ * specific vtable.
+ *
+ * Returns TRUE on success or FALSE if there was a problem in loading
+ * the type (incorrect assemblies, missing assemblies, methods, etc). 
  */
-void
+gboolean
 mono_class_init (MonoClass *class)
 {
 	int i;
 	MonoCachedClassInfo cached_info;
 	gboolean has_cached_info;
-
+	int class_init_ok = TRUE;
+	
 	g_assert (class);
 
 	if (class->inited)
-		return;
+		return TRUE;
 
 	/*g_print ("Init class %s\n", class->name);*/
 
@@ -2199,7 +2341,7 @@ mono_class_init (MonoClass *class)
 	if (class->inited) {
 		mono_loader_unlock ();
 		/* Somebody might have gotten in before us */
-		return;
+		return TRUE;
 	}
 
 	if (class->init_pending) {
@@ -2282,7 +2424,7 @@ mono_class_init (MonoClass *class)
 			guint32 cols [MONO_NESTED_CLASS_SIZE];
 			mono_metadata_decode_row (&class->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
 			nclass = mono_class_create_from_typedef (class->image, MONO_TOKEN_TYPE_DEF | cols [MONO_NESTED_CLASS_NESTED]);
-			class->nested_classes = g_list_prepend (class->nested_classes, nclass);
+			class->nested_classes = g_list_prepend_mempool (class->nested_classes, class->image->mempool, nclass);
 
 			i = mono_metadata_nesting_typedef (class->image, class->type_token, i + 1);
 		}
@@ -2293,36 +2435,56 @@ mono_class_init (MonoClass *class)
 	 */
 	if (has_cached_info) {
 		class->instance_size = cached_info.instance_size;
-		class->class_size = cached_info.class_size;
+		class->sizes.class_size = cached_info.class_size;
 		class->packing_size = cached_info.packing_size;
 		class->min_align = cached_info.min_align;
 		class->blittable = cached_info.blittable;
 		class->has_references = cached_info.has_references;
 		class->has_static_refs = cached_info.has_static_refs;
+		class->no_special_static_fields = cached_info.no_special_static_fields;
 	}
 	else
-		if (!class->size_inited)
+		if (!class->size_inited){
 			mono_class_setup_fields (class);
+			if (class->exception_type || mono_loader_get_last_error ()){
+				class_init_ok = FALSE;
+				goto leave;
+			}
+		}
+				
 
 	/* initialize method pointers */
 	if (class->rank) {
 		MonoMethod *ctor;
 		MonoMethodSignature *sig;
-		class->method.count = class->rank > 1? 2: 1;
+		int count_generic = 0, first_generic = 0;
+
+		class->method.count = (class->rank > 1? 2: 1);
+
+		if (class->interface_count) {
+			for (i = 0; i < class->parent->method.count; i++) {
+				MonoMethod *m = class->parent->methods [i];
+				if (!strncmp (m->name, "InternalArray__", 15))
+					count_generic++;
+			}
+			first_generic = class->method.count;
+			class->method.count += class->interface_count * count_generic;
+		}
+
 		sig = mono_metadata_signature_alloc (class->image, class->rank);
 		sig->ret = &mono_defaults.void_class->byval_arg;
 		sig->pinvoke = TRUE;
 		for (i = 0; i < class->rank; ++i)
 			sig->params [i] = &mono_defaults.int32_class->byval_arg;
 
-		ctor = (MonoMethod *) g_new0 (MonoMethodPInvoke, 1);
+		ctor = (MonoMethod *) mono_mempool_alloc0 (class->image->mempool, sizeof (MonoMethodPInvoke));
 		ctor->klass = class;
 		ctor->flags = METHOD_ATTRIBUTE_PUBLIC | METHOD_ATTRIBUTE_RT_SPECIAL_NAME | METHOD_ATTRIBUTE_SPECIAL_NAME;
 		ctor->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL;
 		ctor->signature = sig;
 		ctor->name = ".ctor";
 		ctor->slot = -1;
-		class->methods = g_new (MonoMethod*, class->method.count);
+		class->methods = mono_mempool_alloc0 (class->image->mempool, sizeof (MonoMethod*) * class->method.count);
 		class->methods [0] = ctor;
 		if (class->rank > 1) {
 			sig = mono_metadata_signature_alloc (class->image, class->rank * 2);
@@ -2331,7 +2493,7 @@ mono_class_init (MonoClass *class)
 			for (i = 0; i < class->rank * 2; ++i)
 				sig->params [i] = &mono_defaults.int32_class->byval_arg;
 
-			ctor = (MonoMethod *) g_new0 (MonoMethodPInvoke, 1);
+			ctor = (MonoMethod *) mono_mempool_alloc0 (class->image->mempool, sizeof (MonoMethodPInvoke));
 			ctor->klass = class;
 			ctor->flags = METHOD_ATTRIBUTE_PUBLIC | METHOD_ATTRIBUTE_RT_SPECIAL_NAME | METHOD_ATTRIBUTE_SPECIAL_NAME;
 			ctor->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL;
@@ -2340,6 +2502,9 @@ mono_class_init (MonoClass *class)
 			ctor->slot = -1;
 			class->methods [1] = ctor;
 		}
+
+		for (i = 0; i < class->interface_count; i++)
+			setup_generic_array_ifaces (class, class->interfaces [i], first_generic + i * count_generic);
 	}
 
 	mono_class_setup_supertypes (class);
@@ -2368,7 +2533,12 @@ mono_class_init (MonoClass *class)
 	}
 	else {
 		mono_class_setup_vtable (class);
-	
+
+		if (class->exception_type || mono_loader_get_last_error ()){
+			class_init_ok = FALSE;
+			goto leave;
+		}
+
 		class->ghcimpl = 1;
 		if (class->parent) { 
 			MonoMethod *cmethod = class->vtable [ghc_slot];
@@ -2408,13 +2578,16 @@ mono_class_init (MonoClass *class)
 		setup_interface_offsets (class, 0);
 	}
 
+ leave:
 	class->inited = 1;
 	class->init_pending = 0;
-	
+
 	mono_loader_unlock ();
 
 	if (mono_debugger_class_init_func)
 		mono_debugger_class_init_func (class);
+
+	return class_init_ok;
 }
 
 /*
@@ -2563,8 +2736,14 @@ mono_class_setup_parent (MonoClass *class, MonoClass *parent)
 	}
 
 	if (!MONO_CLASS_IS_INTERFACE (class)) {
+		/* Imported COM Objects always derive from __ComObject. */
+		if (MONO_CLASS_IS_IMPORT (class)) {
+			if (parent == mono_defaults.object_class)
+				parent = mono_defaults.com_object_class;
+		}
 		class->parent = parent;
 
+
 		if (!parent)
 			g_assert_not_reached (); /* FIXME */
 
@@ -2580,6 +2759,10 @@ mono_class_setup_parent (MonoClass *class, MonoClass *parent)
 		class->marshalbyref = parent->marshalbyref;
 		class->contextbound  = parent->contextbound;
 		class->delegate  = parent->delegate;
+		if (MONO_CLASS_IS_IMPORT (class))
+			class->is_com_object = 1;
+		else
+			class->is_com_object = parent->is_com_object;
 		
 		if (system_namespace) {
 			if (*class->name == 'M' && !strcmp (class->name, "MarshalByRefObject"))
@@ -2635,7 +2818,7 @@ mono_class_setup_supertypes (MonoClass *class)
 		class->idepth = 1;
 
 	ms = MAX (MONO_DEFAULT_SUPERTABLE_SIZE, class->idepth);
-	class->supertypes = g_new0 (MonoClass *, ms);
+	class->supertypes = mono_mempool_alloc0 (class->image->mempool, sizeof (MonoClass *) * ms);
 
 	if (class->parent) {
 		class->supertypes [class->idepth - 1] = class;
@@ -2745,7 +2928,7 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 	name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
 	nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
 
-	class = g_malloc0 (sizeof (MonoClass));
+	class = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass));
 
 	class->name = name;
 	class->name_space = nspace;
@@ -2770,6 +2953,11 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 	if (cols [MONO_TYPEDEF_EXTENDS]) {
 		parent = mono_class_get_full (
 			image, mono_metadata_token_from_dor (cols [MONO_TYPEDEF_EXTENDS]), context);
+		if (parent == NULL){
+			g_hash_table_remove (image->class_cache, GUINT_TO_POINTER (type_token));
+			mono_loader_unlock ();
+			return NULL;
+		}
 	}
 
 	/* do this early so it's available for interfaces in setup_mono_type () */
@@ -2782,7 +2970,11 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 	mono_class_setup_mono_type (class);
 
 	if (!class->enumtype) {
-		mono_metadata_interfaces_from_typedef_full (image, type_token, &interfaces, &icount, context);
+		if (!mono_metadata_interfaces_from_typedef_full (
+			    image, type_token, &interfaces, &icount, context)){
+			mono_loader_unlock ();
+			return NULL;
+		}
 
 		class->interfaces = interfaces;
 		class->interface_count = icount;
@@ -2920,7 +3112,7 @@ mono_class_create_generic (MonoInflatedGenericClass *gclass)
 
 	if (gclass->generic_class.is_dynamic) {
 		klass->instance_size = gklass->instance_size;
-		klass->class_size = gklass->class_size;
+		klass->sizes.class_size = gklass->sizes.class_size;
 		klass->size_inited = 1;
 		klass->inited = 1;
 
@@ -3030,22 +3222,28 @@ mono_ptr_class_get (MonoType *type)
 {
 	MonoClass *result;
 	MonoClass *el_class;
-	static GHashTable *ptr_hash = NULL;
+	MonoImage *image;
+	char *name;
+
+	el_class = mono_class_from_mono_type (type);
+	image = el_class->image;
 
 	mono_loader_lock ();
 
-	if (!ptr_hash)
-		ptr_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	el_class = mono_class_from_mono_type (type);
-	if ((result = g_hash_table_lookup (ptr_hash, el_class))) {
+	if (!image->ptr_cache)
+		image->ptr_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
+
+	if ((result = g_hash_table_lookup (image->ptr_cache, el_class))) {
 		mono_loader_unlock ();
 		return result;
 	}
-	result = g_new0 (MonoClass, 1);
+	result = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass));
 
 	result->parent = NULL; /* no parent for PTR types */
 	result->name_space = el_class->name_space;
-	result->name = g_strdup_printf ("%s*", el_class->name);
+	name = g_strdup_printf ("%s*", el_class->name);
+	result->name = mono_mempool_strdup (image->mempool, name);
+	g_free (name);
 	result->image = el_class->image;
 	result->inited = TRUE;
 	result->flags = TYPE_ATTRIBUTE_CLASS | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK);
@@ -3061,7 +3259,7 @@ mono_ptr_class_get (MonoType *type)
 
 	mono_class_setup_supertypes (result);
 
-	g_hash_table_insert (ptr_hash, el_class, result);
+	g_hash_table_insert (image->ptr_cache, el_class, result);
 
 	mono_loader_unlock ();
 
@@ -3074,6 +3272,8 @@ mono_fnptr_class_get (MonoMethodSignature *sig)
 	MonoClass *result;
 	static GHashTable *ptr_hash = NULL;
 
+	/* FIXME: These should be allocate from a mempool as well, but which one ? */
+
 	mono_loader_lock ();
 
 	if (!ptr_hash)
@@ -3088,7 +3288,7 @@ mono_fnptr_class_get (MonoMethodSignature *sig)
 	result->parent = NULL; /* no parent for PTR types */
 	result->name_space = "System";
 	result->name = "MonoFNPtrFakeClass";
-	result->image = NULL; /* need to fix... */
+	result->image = mono_defaults.corlib; /* need to fix... */
 	result->inited = TRUE;
 	result->flags = TYPE_ATTRIBUTE_CLASS; /* | (el_class->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK); */
 	/* Can pointers get boxed? */
@@ -3183,11 +3383,20 @@ mono_class_from_mono_type (MonoType *type)
 /**
  * @image: context where the image is created
  * @type_spec:  typespec token
+ * @context: the generic context used to evaluate generic instantiations in
  */
 static MonoClass *
-mono_class_create_from_typespec (MonoImage *image, guint32 type_spec)
+mono_class_create_from_typespec (MonoImage *image, guint32 type_spec, MonoGenericContext *context)
 {
-	return mono_class_from_mono_type (mono_type_create_from_typespec (image, type_spec));
+	MonoType *t = mono_type_create_from_typespec (image, type_spec);
+	if (!t)
+		return NULL;
+	if (context && (context->gclass || context->gmethod)) {
+		MonoType *inflated = inflate_generic_type (t, context);
+		if (inflated)
+			t = inflated;
+	}
+	return mono_class_from_mono_type (t);
 }
 
 /**
@@ -3220,10 +3429,13 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded)
 
 	mono_loader_lock ();
 
+	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 == (bounded ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
+			if ((class->rank == rank) && (class->byval_arg.type == (((rank > 1) || bounded) ? MONO_TYPE_ARRAY : MONO_TYPE_SZARRAY))) {
 				mono_loader_unlock ();
 				return class;
 			}
@@ -3234,25 +3446,13 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded)
 	if (image->assembly && image->assembly->dynamic && image->assembly_name && strcmp (image->assembly_name, "mscorlib") == 0) {
 		parent = mono_class_from_name (image, "System", "Array");
 		corlib_type = TRUE;
-	} else if (mono_defaults.generic_array_class) {
-		MonoType *inflated, **args;
-
-		args = g_new0 (MonoType *, 1);
-		args [0] = &eclass->byval_arg;
-
-		inflated = mono_class_bind_generic_parameters (
-			&mono_defaults.generic_array_class->byval_arg, 1, args);
-		parent = mono_class_from_mono_type (inflated);
-
-		if (!parent->inited)
-			mono_class_init (parent);
 	} else {
 		parent = mono_defaults.array_class;
 		if (!parent->inited)
 			mono_class_init (parent);
 	}
 
-	class = g_malloc0 (sizeof (MonoClass));
+	class = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass));
 
 	class->image = image;
 	class->name_space = eclass->name_space;
@@ -3264,15 +3464,78 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded)
 		memset (name + nsize + 1, ',', rank - 1);
 	name [nsize + rank] = ']';
 	name [nsize + rank + 1] = 0;
-	class->name = name;
+	class->name = mono_mempool_strdup (image->mempool, name);
+	g_free (name);
 	class->type_token = 0;
 	/* all arrays are marked serializable and sealed, bug #42779 */
 	class->flags = TYPE_ATTRIBUTE_CLASS | TYPE_ATTRIBUTE_SERIALIZABLE | TYPE_ATTRIBUTE_SEALED |
 		(eclass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK);
 	class->parent = parent;
 	class->instance_size = mono_class_instance_size (class->parent);
-	class->class_size = 0;
+	class->sizes.element_size = mono_class_array_element_size (eclass);
 	mono_class_setup_supertypes (class);
+
+	if (mono_defaults.generic_ilist_class) {
+		MonoClass *fclass = NULL;
+		int i;
+
+		if (eclass->valuetype) {
+			if (eclass == mono_defaults.int16_class)
+				fclass = mono_defaults.uint16_class;
+			if (eclass == mono_defaults.uint16_class)
+				fclass = mono_defaults.int16_class;
+			if (eclass == mono_defaults.int32_class)
+				fclass = mono_defaults.uint32_class;
+			if (eclass == mono_defaults.uint32_class)
+				fclass = mono_defaults.int32_class;
+			if (eclass == mono_defaults.int64_class)
+				fclass = mono_defaults.uint64_class;
+			if (eclass == mono_defaults.uint64_class)
+				fclass = mono_defaults.int64_class;
+			if (eclass == mono_defaults.byte_class)
+				fclass = mono_defaults.sbyte_class;
+			if (eclass == mono_defaults.sbyte_class)
+				fclass = mono_defaults.byte_class;
+
+			class->interface_count = fclass ? 2 : 1;
+		} else if (MONO_CLASS_IS_INTERFACE (eclass)) {
+			class->interface_count = 2 + eclass->interface_count;
+		} else {
+			class->interface_count = eclass->idepth + eclass->interface_count;
+		}
+
+		class->interfaces = g_new0 (MonoClass *, class->interface_count);
+
+		for (i = 0; i < class->interface_count; i++) {
+			MonoType *inflated, **args;
+			MonoClass *iface;
+
+			if (eclass->valuetype)
+				iface = (i == 0) ? eclass : fclass;
+			else if (MONO_CLASS_IS_INTERFACE (eclass)) {
+				if (i == 0)
+					iface = mono_defaults.object_class;
+				else if (i == 1)
+					iface = eclass;
+				else
+					iface = eclass->interfaces [i - 2];
+			} else {
+				if (i < eclass->idepth)
+					iface = eclass->supertypes [i];
+				else
+					iface = eclass->interfaces [i - eclass->idepth];
+			}
+
+			args = g_new0 (MonoType *, 1);
+			args [0] = &iface->byval_arg;
+
+			inflated = mono_class_bind_generic_parameters (
+				&mono_defaults.generic_ilist_class->byval_arg, 1, args);
+
+			class->interfaces [i] = mono_class_from_mono_type (inflated);
+		}
+	}
+
 	if (eclass->generic_class)
 		mono_class_init (eclass);
 	if (!eclass->size_inited)
@@ -3289,7 +3552,7 @@ mono_bounded_array_class_get (MonoClass *eclass, guint32 rank, gboolean bounded)
 	class->element_class = eclass;
 
 	if ((rank > 1) || bounded) {
-		MonoArrayType *at = g_new0 (MonoArrayType, 1);
+		MonoArrayType *at = mono_mempool_alloc0 (image->mempool, sizeof (MonoArrayType));
 		class->byval_arg.type = MONO_TYPE_ARRAY;
 		class->byval_arg.data.array = at;
 		at->eklass = eclass;
@@ -3398,7 +3661,12 @@ mono_class_data_size (MonoClass *klass)
 	if (!klass->inited)
 		mono_class_init (klass);
 
-	return klass->class_size;
+	/* in arrays, sizes.class_size is unioned with element_size
+	 * and arrays have no static fields
+	 */
+	if (klass->rank)
+		return 0;
+	return klass->sizes.class_size;
 }
 
 /*
@@ -3640,14 +3908,15 @@ mono_assembly_name_from_token (MonoImage *image, guint32 type_token)
 }
 
 /**
- * mono_class_get:
+ * mono_class_get_full:
  * @image: the image where the class resides
  * @type_token: the token for the class
+ * @context: the generic context used to evaluate generic instantiations in
  *
  * Returns: the MonoClass that represents @type_token in @image
  */
 MonoClass *
-mono_class_get (MonoImage *image, guint32 type_token)
+mono_class_get_full (MonoImage *image, guint32 type_token, MonoGenericContext *context)
 {
 	MonoClass *class = NULL;
 
@@ -3662,7 +3931,7 @@ mono_class_get (MonoImage *image, guint32 type_token)
 		class = mono_class_from_typeref (image, type_token);
 		break;
 	case MONO_TOKEN_TYPE_SPEC:
-		class = mono_class_create_from_typespec (image, type_token);
+		class = mono_class_create_from_typespec (image, type_token, context);
 		break;
 	default:
 		g_warning ("unknown token type %x", type_token & 0xff000000);
@@ -3679,19 +3948,108 @@ mono_class_get (MonoImage *image, guint32 type_token)
 }
 
 MonoClass *
-mono_class_get_full (MonoImage *image, guint32 type_token, MonoGenericContext *context)
+mono_class_get (MonoImage *image, guint32 type_token)
 {
-	MonoClass *class = mono_class_get (image, type_token);
+	return mono_class_get_full (image, type_token, NULL);
+}
 
-	if (!image->dynamic && ((type_token & 0xff000000) == MONO_TOKEN_TYPE_DEF))
-		return class;
+/**
+ * mono_image_init_name_cache:
+ *
+ *  Initializes the class name cache stored in image->name_cache.
+ *
+ * LOCKING: Acquires the loader lock.
+ */
+void
+mono_image_init_name_cache (MonoImage *image)
+{
+	MonoTableInfo  *t = &image->tables [MONO_TABLE_TYPEDEF];
+	guint32 cols [MONO_TYPEDEF_SIZE];
+	const char *name;
+	const char *nspace;
+	guint32 i, visib, nspace_index;
+	GHashTable *name_cache2, *nspace_table;
 
-	if (class && context && (context->gclass || context->gmethod)) {
-		MonoType *inflated = inflate_generic_type (&class->byval_arg, context);
-		if (inflated)
-			class = mono_class_from_mono_type (inflated);
+	mono_loader_lock ();
+
+	image->name_cache = g_hash_table_new (g_str_hash, g_str_equal);
+
+	if (image->dynamic) {
+		mono_loader_unlock ();
+		return;
 	}
-	return class;
+
+	/* Temporary hash table to avoid lookups in the nspace_table */
+	name_cache2 = g_hash_table_new (NULL, NULL);
+
+	for (i = 1; i <= t->rows; ++i) {
+		mono_metadata_decode_row (t, i - 1, cols, MONO_TYPEDEF_SIZE);
+		/* nested types are accessed from the nesting name */
+		visib = cols [MONO_TYPEDEF_FLAGS] & TYPE_ATTRIBUTE_VISIBILITY_MASK;
+		if (visib > TYPE_ATTRIBUTE_PUBLIC && visib <= TYPE_ATTRIBUTE_NESTED_ASSEMBLY)
+			continue;
+		name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
+		nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
+
+		nspace_index = cols [MONO_TYPEDEF_NAMESPACE];
+		nspace_table = g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index));
+		if (!nspace_table) {
+			nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
+			g_hash_table_insert (image->name_cache, (char*)nspace, nspace_table);
+			g_hash_table_insert (name_cache2, GUINT_TO_POINTER (nspace_index),
+								 nspace_table);
+		}
+		g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (i));
+	}
+
+	/* Load type names from EXPORTEDTYPES table */
+	{
+		MonoTableInfo  *t = &image->tables [MONO_TABLE_EXPORTEDTYPE];
+		guint32 cols [MONO_EXP_TYPE_SIZE];
+		int i;
+
+		for (i = 0; i < t->rows; ++i) {
+			mono_metadata_decode_row (t, i, cols, MONO_EXP_TYPE_SIZE);
+			name = mono_metadata_string_heap (image, cols [MONO_EXP_TYPE_NAME]);
+			nspace = mono_metadata_string_heap (image, cols [MONO_EXP_TYPE_NAMESPACE]);
+
+			nspace_index = cols [MONO_EXP_TYPE_NAMESPACE];
+			nspace_table = g_hash_table_lookup (name_cache2, GUINT_TO_POINTER (nspace_index));
+			if (!nspace_table) {
+				nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
+				g_hash_table_insert (image->name_cache, (char*)nspace, nspace_table);
+				g_hash_table_insert (name_cache2, GUINT_TO_POINTER (nspace_index),
+									 nspace_table);
+			}
+			g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (mono_metadata_make_token (MONO_TABLE_EXPORTEDTYPE, i + 1)));
+		}
+	}
+
+	g_hash_table_destroy (name_cache2);
+
+	mono_loader_unlock ();
+}
+
+void
+mono_image_add_to_name_cache (MonoImage *image, const char *nspace, 
+							  const char *name, guint32 index)
+{
+	GHashTable *nspace_table;
+	GHashTable *name_cache;
+
+	mono_loader_lock ();
+
+	if (!image->name_cache)
+		mono_image_init_name_cache (image);
+
+	name_cache = image->name_cache;
+	if (!(nspace_table = g_hash_table_lookup (name_cache, nspace))) {
+		nspace_table = g_hash_table_new (g_str_hash, g_str_equal);
+		g_hash_table_insert (name_cache, (char *)nspace, (char *)nspace_table);
+	}
+	g_hash_table_insert (nspace_table, (char *) name, GUINT_TO_POINTER (index));
+
+	mono_loader_unlock ();
 }
 
 typedef struct {
@@ -3718,12 +4076,6 @@ find_nocase (gpointer key, gpointer value, gpointer user_data)
  * Obtains a MonoClass with a given namespace and a given name which
  * is located in the given MonoImage.   The namespace and name
  * lookups are case insensitive.
- *
- * You can also pass @NULL to the image, and that will lookup for
- * a type with the given namespace and name in all of the loaded
- * assemblies: notice that since there might be a name clash in this
- * case, passing @NULL is not encouraged if you need a precise type.
- *
  */
 MonoClass *
 mono_class_from_name_case (MonoImage *image, const char* name_space, const char *name)
@@ -3740,6 +4092,9 @@ mono_class_from_name_case (MonoImage *image, const char* name_space, const char
 
 		mono_loader_lock ();
 
+		if (!image->name_cache)
+			mono_image_init_name_cache (image);
+
 		user_data.key = name_space;
 		user_data.value = NULL;
 		g_hash_table_foreach (image->name_cache, find_nocase, &user_data);
@@ -3810,12 +4165,6 @@ return_nested_in (MonoClass *class, char *nested) {
  *
  * Obtains a MonoClass with a given namespace and a given name which
  * is located in the given MonoImage.   
- *
- * You can also pass `NULL' to the image, and that will lookup for
- * a type with the given namespace and name in all of the loaded
- * assemblies: notice that since there might be a name clash in this
- * case, passing NULL is not encouraged if you need a precise type.
- *
  */
 MonoClass *
 mono_class_from_name (MonoImage *image, const char* name_space, const char *name)
@@ -3838,8 +4187,21 @@ mono_class_from_name (MonoImage *image, const char* name_space, const char *name
 		name = buf;
 	}
 
+	if (get_class_from_name) {
+		gboolean res = get_class_from_name (image, name_space, name, &class);
+		if (res) {
+			if (nested)
+				return class ? return_nested_in (class, nested) : NULL;
+			else
+				return class;
+		}
+	}
+
 	mono_loader_lock ();
 
+	if (!image->name_cache)
+		mono_image_init_name_cache (image);
+
 	nspace_table = g_hash_table_lookup (image->name_cache, name_space);
 
 	if (nspace_table)
@@ -4108,7 +4470,8 @@ handle_enum:
 gint32
 mono_array_element_size (MonoClass *ac)
 {
-	return mono_class_array_element_size (ac->element_class);
+	g_assert (ac->rank);
+	return ac->sizes.element_size;
 }
 
 gpointer
@@ -4232,6 +4595,12 @@ mono_class_get_cached_class_info (MonoClass *klass, MonoCachedClassInfo *res)
 		return get_cached_class_info (klass, res);
 }
 
+void
+mono_install_get_class_from_name (MonoGetClassFromName func)
+{
+	get_class_from_name = func;
+}
+
 MonoImage*
 mono_class_get_image (MonoClass *klass)
 {
@@ -4376,6 +4745,20 @@ mono_class_get_type (MonoClass *klass)
 	return &klass->byval_arg;
 }
 
+/**
+ * mono_class_get_type_token
+ * @klass: the MonoClass to act on
+ *
+ * This method returns type token for the class.
+ *
+ * Returns: the type token for the class.
+ */
+guint32
+mono_class_get_type_token (MonoClass *klass)
+{
+  return klass->type_token;
+}
+
 /**
  * mono_class_get_byref_type:
  * @klass: the MonoClass to act on
@@ -4721,6 +5104,19 @@ mono_field_get_flags (MonoClassField *field)
 	return field->type->attrs;
 }
 
+/**
+ * mono_field_get_data;
+ * @field: the MonoClassField to act on
+ *
+ * Returns: pointer to the metadata constant value or to the field
+ * data if it has an RVA flag.
+ */
+const char *
+mono_field_get_data  (MonoClassField *field)
+{
+  return field->data;
+}
+
 /**
  * mono_property_get_name: 
  * @prop: the MonoProperty to act on
@@ -4946,6 +5342,37 @@ mono_class_set_failure (MonoClass *klass, guint32 ex_type, void *ex_data)
 	return TRUE;
 }
 
+/**
+ * mono_classes_init:
+ *
+ * Initialize the resources used by this module.
+ */
+void
+mono_classes_init (void)
+{
+}
+
+/**
+ * mono_classes_cleanup:
+ *
+ * Free the resources used by this module.
+ */
+void
+mono_classes_cleanup (void)
+{
+	IOffsetInfo *cached_info, *next;
+
+	if (global_interface_bitset)
+		mono_bitset_free (global_interface_bitset);
+
+	for (cached_info = cached_offset_info; cached_info;) {
+		next = cached_info->next;
+
+		g_free (cached_info);
+		cached_info = next;
+	}
+}
+
 /**
  * mono_class_get_exception_for_failure:
  * @klass: class in which the failure was detected
@@ -4976,8 +5403,19 @@ mono_class_get_exception_for_failure (MonoClass *klass)
 	}
 	case MONO_EXCEPTION_TYPE_LOAD:
 		return mono_exception_from_name (mono_defaults.corlib, "System", "TypeLoadException");
-	/* TODO - handle other class related failures */
-	default:
+
+	default: {
+		MonoLoaderError *error;
+		MonoException *ex;
+		
+		error = mono_loader_get_last_error ();
+		if (error != NULL){
+			ex = mono_loader_error_prepare_exception (error);
+			return ex;
+		}
+		
+		/* TODO - handle other class related failures */
 		return NULL;
 	}
+	}
 }