X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fclass.c;h=7de930864c2e3fb36b661b3409a7e5922c9df550;hb=b9db0ccd140cdf9e18f39c78288f198110c0e83f;hp=60d674ff2c79a7f6b2f3bce929256f85f5bf2e14;hpb=f0350560874900b220559bbb5b366910942201c9;p=mono.git

diff --git a/mono/metadata/class.c b/mono/metadata/class.c
index 60d674ff2c7..7de930864c2 100644
--- a/mono/metadata/class.c
+++ b/mono/metadata/class.c
@@ -18,6 +18,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <signal.h>
 #include <mono/metadata/image.h>
 #include <mono/metadata/cil-coff.h>
 #include <mono/metadata/metadata.h>
@@ -25,38 +26,20 @@
 #include <mono/metadata/tokentype.h>
 #include <mono/metadata/class.h>
 #include <mono/metadata/object.h>
+#include <mono/metadata/appdomain.h>
+#include <mono/metadata/mono-endian.h>
+#if HAVE_BOEHM_GC
+#include <gc/gc.h>
+#endif
 
 #define CSIZE(x) (sizeof (x) / 4)
 
-static gpointer
-default_trampoline (MonoMethod *method)
-{
-	return method;
-}
-
-static void
-default_runtime_class_init (MonoClass *klass)
-{
-	return;
-}
-
-static MonoTrampoline arch_create_jit_trampoline = default_trampoline;
-static MonoRuntimeClassInit mono_runtime_class_init = default_runtime_class_init;
-
-void
-mono_install_trampoline (MonoTrampoline func) 
-{
-	arch_create_jit_trampoline = func? func: default_trampoline;
-}
+gboolean mono_print_vtable = FALSE;
 
-void
-mono_install_runtime_class_init (MonoRuntimeClassInit func)
-{
-	mono_runtime_class_init = func? func: default_runtime_class_init;
-}
+static MonoClass * mono_class_create_from_typedef (MonoImage *image, guint32 type_token);
 
-static MonoClass *
-mono_class_create_from_typeref (MonoImage *image, guint32 type_token)
+MonoClass *
+mono_class_from_typeref (MonoImage *image, guint32 type_token)
 {
 	guint32 cols [MONO_TYPEREF_SIZE];
 	MonoTableInfo  *t = &image->tables [MONO_TABLE_TYPEREF];
@@ -65,8 +48,24 @@ mono_class_create_from_typeref (MonoImage *image, guint32 type_token)
 	MonoClass *res;
 
 	mono_metadata_decode_row (t, (type_token&0xffffff)-1, cols, MONO_TYPEREF_SIZE);
-	g_assert ((cols [MONO_TYPEREF_SCOPE] & 0x3) == 2);
-	idx = cols [MONO_TYPEREF_SCOPE] >> 2;
+
+	name = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAME]);
+	nspace = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAMESPACE]);
+	
+	idx = cols [MONO_TYPEREF_SCOPE] >> RESOLTION_SCOPE_BITS;
+	switch (cols [MONO_TYPEREF_SCOPE] & RESOLTION_SCOPE_MASK) {
+	case RESOLTION_SCOPE_MODULE:
+		if (!idx)
+			g_error ("null ResolutionScope not yet handled");
+		/* a typedef in disguise */
+		return mono_class_from_name (image, nspace, name);
+	case RESOLTION_SCOPE_MODULEREF:
+			g_error ("ModuleRef ResolutionScope not yet handled");
+	case RESOLTION_SCOPE_TYPEREF:
+			g_error ("TypeRef ResolutionScope not yet handled");
+	case RESOLTION_SCOPE_ASSEMBLYREF:
+		break;
+	}
 
 	if (!image->references ||  !image->references [idx-1]) {
 		/* 
@@ -74,6 +73,7 @@ mono_class_create_from_typeref (MonoImage *image, guint32 type_token)
 		 * until we have a better solution.
 		 */
 		fprintf(stderr, "Sending dummy where %s.%s expected\n", mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAMESPACE]), mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAME])); 
+		
 		res = mono_class_from_name (image, "System", "MonoDummy");
 		/* prevent method loading */
 		res->dummy = 1;
@@ -82,9 +82,6 @@ mono_class_create_from_typeref (MonoImage *image, guint32 type_token)
 		return res;
 	}	
 
-	name = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAME]);
-	nspace = mono_metadata_string_heap (image, cols [MONO_TYPEREF_NAMESPACE]);
-	
 	/* load referenced assembly */
 	image = image->references [idx-1]->image;
 
@@ -109,6 +106,7 @@ class_compute_field_layout (MonoClass *class)
 	guint32 layout = class->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
 	MonoTableInfo *t = &m->tables [MONO_TABLE_FIELD];
 	int i;
+	guint32 rva;
 
 	/*
 	 * Fetch all the field information.
@@ -128,41 +126,48 @@ class_compute_field_layout (MonoClass *class)
 		class->fields [i].type = mono_metadata_parse_field_type (
 			m, cols [MONO_FIELD_FLAGS], sig + 1, &sig);
 		if (cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_HAS_FIELD_RVA) {
-			mono_metadata_field_info (m, idx, NULL, &class->fields [i].data, NULL);
-			if (!class->fields [i].data)
+			mono_metadata_field_info (m, idx, NULL, &rva, NULL);
+			if (!rva)
 				g_warning ("field %s in %s should have RVA data, but hasn't", class->fields [i].name, class->name);
+			class->fields [i].data = mono_cli_rva_map (class->image->image_info, rva);
 		}
-		if (class->enumtype && !(cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_STATIC))
+		if (class->enumtype && !(cols [MONO_FIELD_FLAGS] & FIELD_ATTRIBUTE_STATIC)) {
 			class->enum_basetype = class->fields [i].type;
+			class->element_class = mono_class_from_mono_type (class->enum_basetype);
+		}
+	}
+	if (class->enumtype && !class->enum_basetype) {
+		if (!((strcmp (class->name, "Enum") == 0) && (strcmp (class->name_space, "System") == 0)))
+			G_BREAKPOINT ();
 	}
 	/*
-	 * Compute field layout and total size.
+	 * Compute field layout and total size (not considering static fields)
 	 */
-	switch (layout){
+	switch (layout) {
 	case TYPE_ATTRIBUTE_AUTO_LAYOUT:
 	case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
 		for (i = 0; i < top; i++){
 			int size, align;
 			
+			if (class->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC)
+				continue;
+
 			size = mono_type_size (class->fields [i].type, &align);
+
 			class->min_align = MAX (align, class->min_align);
-			if (class->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC) {
-				class->fields [i].offset = class->class_size;
-				class->class_size += (class->class_size % align);
-				class->class_size += size;
-			} else {
-				class->fields [i].offset = class->instance_size;
-				class->instance_size += (class->instance_size % align);
-				class->instance_size += size;
-			}
+			class->fields [i].offset = class->instance_size;
+			class->fields [i].offset += align - 1;
+			class->fields [i].offset &= ~(align - 1);
+			class->instance_size = class->fields [i].offset + size;
 		}
+       
 		if (class->instance_size & (class->min_align - 1)) {
 			class->instance_size += class->min_align - 1;
 			class->instance_size &= ~(class->min_align - 1);
 		}
 		break;
 	case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT:
-		for (i = 0; i < top; i++){
+		for (i = 0; i < top; i++) {
 			int size, align;
 			int idx = class->field.first + i;
 
@@ -171,43 +176,205 @@ class_compute_field_layout (MonoClass *class)
 			 * uses explicit layout.
 			 */
 
+			if (class->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC)
+				continue;
+
 			size = mono_type_size (class->fields [i].type, &align);
-			if (class->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC) {
-				class->fields [i].offset = class->class_size;
-				class->class_size += (class->class_size % align);
-				class->class_size += size;
-			} else {
-				mono_metadata_field_info (m, idx, &class->fields [i].offset, NULL, NULL);
-				if (class->fields [i].offset == (guint32)-1)
-						g_warning ("%s not initialized correctly (missing field layout info for %s)", class->name, class->fields [i].name);
-				/*
-				 * The offset is from the start of the object: this works for both
-				 * classes and valuetypes.
-				 */
-				class->fields [i].offset += sizeof (MonoObject);
-				/*
-				 * Calc max size.
-				 */
-				size += class->fields [i].offset;
-				class->instance_size = MAX (class->instance_size, size);
-			}
+			
+			mono_metadata_field_info (m, idx, &class->fields [i].offset, NULL, NULL);
+			if (class->fields [i].offset == (guint32)-1)
+				g_warning ("%s not initialized correctly (missing field layout info for %s)", class->name, class->fields [i].name);
+			/*
+			 * The offset is from the start of the object: this works for both
+			 * classes and valuetypes.
+			 */
+			class->fields [i].offset += sizeof (MonoObject);
+			/*
+			 * Calc max size.
+			 */
+			size += class->fields [i].offset;
+			class->instance_size = MAX (class->instance_size, size);
+		}
+		break;
+	}
+
+	class->size_inited = 1;
+
+	/*
+	 * Compute static field layout and size
+	 */
+	switch (layout) {
+	case TYPE_ATTRIBUTE_AUTO_LAYOUT:
+	case TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT:
+		for (i = 0; i < top; i++){
+			int size, align;
+			
+			if (!(class->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC))
+				continue;
+			
+			size = mono_type_size (class->fields [i].type, &align);
+			class->fields [i].offset = class->class_size;
+			class->fields [i].offset += align - 1;
+			class->fields [i].offset &= ~(align - 1);
+			class->class_size = class->fields [i].offset + size;
+		}
+		break;
+	case TYPE_ATTRIBUTE_EXPLICIT_LAYOUT:
+		for (i = 0; i < top; i++){
+			int size, align;
+
+			/*
+			 * There must be info about all the fields in a type if it
+			 * uses explicit layout.
+			 */
+
+			
+			if (!(class->fields [i].type->attrs & FIELD_ATTRIBUTE_STATIC))
+				continue;
+
+			size = mono_type_size (class->fields [i].type, &align);
+			class->fields [i].offset = class->class_size;
+			class->fields [i].offset += align - 1;
+			class->fields [i].offset &= ~(align - 1);
+			class->class_size = class->fields [i].offset + size;
 		}
 		break;
 	}
 }
 
+static void
+init_properties (MonoClass *class)
+{
+	guint startm, endm, i, j;
+	guint32 cols [MONO_PROPERTY_SIZE];
+	MonoTableInfo *pt = &class->image->tables [MONO_TABLE_PROPERTY];
+	MonoTableInfo *msemt = &class->image->tables [MONO_TABLE_METHODSEMANTICS];
+
+	class->property.first = mono_metadata_properties_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &class->property.last);
+	class->property.count = class->property.last - class->property.first;
+
+	class->properties = g_new0 (MonoProperty, class->property.count);
+	for (i = class->property.first; i < class->property.last; ++i) {
+		mono_metadata_decode_row (pt, i, cols, MONO_PROPERTY_SIZE);
+		class->properties [i - class->property.first].attrs = cols [MONO_PROPERTY_FLAGS];
+		class->properties [i - class->property.first].name = mono_metadata_string_heap (class->image, cols [MONO_PROPERTY_NAME]);
+
+		startm = mono_metadata_methods_from_property (class->image, i, &endm);
+		for (j = startm; j < endm; ++j) {
+			mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE);
+			switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
+			case METHOD_SEMANTIC_SETTER:
+				class->properties [i - class->property.first].set = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first];
+				break;
+			case METHOD_SEMANTIC_GETTER:
+				class->properties [i - class->property.first].get = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first];
+				break;
+			default:
+				break;
+			}
+		}
+	}
+}
+
+static void
+init_events (MonoClass *class)
+{
+	guint startm, endm, i, j;
+	guint32 cols [MONO_EVENT_SIZE];
+	MonoTableInfo *pt = &class->image->tables [MONO_TABLE_EVENT];
+	MonoTableInfo *msemt = &class->image->tables [MONO_TABLE_METHODSEMANTICS];
+
+	class->event.first = mono_metadata_events_from_typedef (class->image, mono_metadata_token_index (class->type_token) - 1, &class->event.last);
+	class->event.count = class->event.last - class->event.first;
+
+	class->events = g_new0 (MonoEvent, class->event.count);
+	for (i = class->event.first; i < class->event.last; ++i) {
+		mono_metadata_decode_row (pt, i, cols, MONO_EVENT_SIZE);
+		class->events [i - class->event.first].attrs = cols [MONO_EVENT_FLAGS];
+		class->events [i - class->event.first].name = mono_metadata_string_heap (class->image, cols [MONO_EVENT_NAME]);
+
+		startm = mono_metadata_methods_from_event (class->image, i, &endm);
+		for (j = startm; j < endm; ++j) {
+			mono_metadata_decode_row (msemt, j, cols, MONO_METHOD_SEMA_SIZE);
+			switch (cols [MONO_METHOD_SEMA_SEMANTICS]) {
+			case METHOD_SEMANTIC_ADD_ON:
+				class->events [i - class->event.first].add = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first];
+				break;
+			case METHOD_SEMANTIC_REMOVE_ON:
+				class->events [i - class->event.first].remove = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first];
+				break;
+			case METHOD_SEMANTIC_FIRE:
+				class->events [i - class->event.first].raise = class->methods [cols [MONO_METHOD_SEMA_METHOD] - 1 - class->method.first];
+				break;
+			case METHOD_SEMANTIC_OTHER: /* don't care for now */
+			default:
+				break;
+			}
+		}
+	}
+}
+
+static guint
+mono_get_unique_iid (MonoClass *class)
+{
+	static GHashTable *iid_hash = NULL;
+	static guint iid = 0;
+
+	char *str;
+	gpointer value;
+	
+	g_assert (class->flags & TYPE_ATTRIBUTE_INTERFACE);
+
+	if (!iid_hash)
+		iid_hash = g_hash_table_new (g_str_hash, g_str_equal);
+
+	str = g_strdup_printf ("%s|%s.%s\n", class->image->name, class->name_space, class->name);
+
+	if (g_hash_table_lookup_extended (iid_hash, str, NULL, &value)) {
+		g_free (str);
+		return (guint)value;
+	} else {
+		g_hash_table_insert (iid_hash, str, (gpointer)iid);
+		++iid;
+	}
+
+	return iid - 1;
+}
+
+/**
+ * mono_class_init:
+ * @class: the class to initialize
+ *
+ * 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.  
+ */
 void
 mono_class_init (MonoClass *class)
 {
 	MonoClass *k, *ic;
-	MonoMethod **tmp_vtable, **vtable = (MonoMethod **)class->vtable;
-	int i, max_iid, cur_slot = 0;
+	MonoMethod **vtable;
+	int i, max_vtsize = 0, max_iid, cur_slot = 0;
+	static MonoMethod *default_ghc = NULL;
+	static MonoMethod *default_finalize = NULL;
+	static int finalize_slot = -1;
+	static int ghc_slot = -1;
+	guint32 packing_size = 0;
 
 	g_assert (class);
 
 	if (class->inited)
 		return;
-	class->inited = 1;
+
+	if (class->init_pending) {
+		/* this indicates a cyclic dependency */
+		g_error ("pending init %s.%s\n", class->name_space, class->name);
+	}
+
+	class->init_pending = 1;
+
+//	mono_stats.initialized_class_count++;
 
 	if (class->parent) {
 		if (!class->parent->inited)
@@ -216,28 +383,60 @@ mono_class_init (MonoClass *class)
 		class->class_size += class->parent->class_size;
 		class->min_align = class->parent->min_align;
 		cur_slot = class->parent->vtable_size;
-	}
+	} else
+		class->min_align = 1;
+
+	if (mono_metadata_packing_from_typedef (class->image, class->type_token, &packing_size, &class->instance_size))
+		class->instance_size += sizeof (MonoObject);
+	/* use packing_size in field layout */
 
 	/*
 	 * Computes the size used by the fields, and their locations
 	 */
-	if (class->field.count > 0){
+	if (!class->size_inited && class->field.count > 0){
 		class->fields = g_new0 (MonoClassField, class->field.count);
 		class_compute_field_layout (class);
 	}
 
-	if (class->class_size)
-		class->data = g_malloc0 (class->class_size);
+	if (!(class->flags & TYPE_ATTRIBUTE_INTERFACE)) {
+		for (i = 0; i < class->interface_count; i++) 
+			max_vtsize += class->interfaces [i]->method.count;
+	
+		if (class->parent)
+			max_vtsize += class->parent->vtable_size;
 
-	/* initialize mothod pointers */
+		max_vtsize += class->method.count;
+	}
+
+	vtable = alloca (sizeof (gpointer) * max_vtsize);
+	memset (vtable, 0, sizeof (gpointer) * max_vtsize);
+
+	/* initialize method pointers */
 	class->methods = g_new (MonoMethod*, class->method.count);
 	for (i = 0; i < class->method.count; ++i)
 		class->methods [i] = mono_get_method (class->image,
 		        MONO_TOKEN_METHOD_DEF | (i + class->method.first + 1), class);
 
+	init_properties (class);
+	init_events (class);
+
+	i = mono_metadata_nesting_typedef (class->image, class->type_token);
+	while (i) {
+		MonoClass* nclass;
+		guint32 cols [MONO_NESTED_CLASS_SIZE];
+		mono_metadata_decode_row (&class->image->tables [MONO_TABLE_NESTEDCLASS], i - 1, cols, MONO_NESTED_CLASS_SIZE);
+		if (cols [MONO_NESTED_CLASS_ENCLOSING] != mono_metadata_token_index (class->type_token))
+			break;
+		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);
+		++i;
+	}
+
 	if (class->flags & TYPE_ATTRIBUTE_INTERFACE) {
 		for (i = 0; i < class->method.count; ++i)
 			class->methods [i]->slot = i;
+		class->init_pending = 0;
+		class->inited = 1;
 		return;
 	}
 
@@ -262,43 +461,40 @@ mono_class_init (MonoClass *class)
 	class->interface_offsets = g_malloc (sizeof (gpointer) * (max_iid + 1));
 
 	for (i = 0; i <= max_iid; i++)
-		class->interface_offsets [i] = NULL;
+		class->interface_offsets [i] = -1;
 
 	for (i = 0; i < class->interface_count; i++) {
 		ic = class->interfaces [i];
-		class->interface_offsets [ic->interface_id] = &class->vtable [cur_slot];
+		class->interface_offsets [ic->interface_id] = cur_slot;
 		cur_slot += ic->method.count;
 	}
 
 	for (k = class->parent; k ; k = k->parent) {
 		for (i = 0; i < k->interface_count; i++) {
 			ic = k->interfaces [i]; 
-			if (class->interface_offsets [ic->interface_id] == NULL) {
-				int io = (k->interface_offsets [ic->interface_id] - (gpointer)k->vtable)>>2;
+			if (class->interface_offsets [ic->interface_id] == -1) {
+				int io = k->interface_offsets [ic->interface_id];
 
 				g_assert (io >= 0);
-				g_assert (io <= class->vtable_size);
+				g_assert (io <= max_vtsize);
 
-				class->interface_offsets [ic->interface_id] = &class->vtable [io];
+				class->interface_offsets [ic->interface_id] = io;
 			}
 		}
 	}
 
 	if (class->parent && class->parent->vtable_size)
-		memcpy (class->vtable, class->parent->vtable,  sizeof (gpointer) * class->parent->vtable_size);
+		memcpy (vtable, class->parent->vtable,  sizeof (gpointer) * class->parent->vtable_size);
  
-	tmp_vtable = alloca (class->vtable_size * sizeof (gpointer));
-	memset (tmp_vtable, 0, class->vtable_size * sizeof (gpointer));
-
 	for (k = class; k ; k = k->parent) {
 		for (i = 0; i < k->interface_count; i++) {
 			int j, l, io;
-			ic = k->interfaces [i];
 
-			io = (k->interface_offsets [ic->interface_id] - (gpointer)k->vtable)>>2;
+			ic = k->interfaces [i];
+			io = k->interface_offsets [ic->interface_id];
 			
 			g_assert (io >= 0);
-			g_assert (io <= class->vtable_size);
+			g_assert (io <= max_vtsize);
 
 			if (k == class) {
 				for (l = 0; l < ic->method.count; l++) {
@@ -311,7 +507,8 @@ mono_class_init (MonoClass *class)
 							continue;
 						if (!strcmp(cm->name, im->name) && 
 						    mono_metadata_signature_equal (cm->signature, im->signature)) {
-							tmp_vtable [io + l] = cm;
+							g_assert (io + l <= max_vtsize);
+							vtable [io + l] = cm;
 						}
 					}
 				}
@@ -325,9 +522,9 @@ mono_class_init (MonoClass *class)
 				MonoMethod *im = ic->methods [l];						
 				MonoClass *k1;
 
-				g_assert (io <= class->vtable_size);
+				g_assert (io + l <= max_vtsize);
 
-				if (tmp_vtable [io + l] || vtable [io + l])
+				if (vtable [io + l])
 					continue;
 					
 				for (k1 = class; k1; k1 = k1->parent) {
@@ -340,23 +537,27 @@ mono_class_init (MonoClass *class)
 						
 						if (!strcmp(cm->name, im->name) && 
 						    mono_metadata_signature_equal (cm->signature, im->signature)) {
-							tmp_vtable [io + l] = cm;
+							g_assert (io + l <= max_vtsize);
+							vtable [io + l] = cm;
 							break;
 						}
 						
 					}
-					if (tmp_vtable [io + l])
+					g_assert (io + l <= max_vtsize);
+					if (vtable [io + l])
 						break;
 				}
 			}
 
 			for (l = 0; l < ic->method.count; l++) {
 				MonoMethod *im = ic->methods [l];						
-				char *qname;
+				char *qname, *fqname;
+				
+				qname = g_strconcat (ic->name, ".", im->name, NULL); 
 				if (ic->name_space && ic->name_space [0])
-					qname = g_strconcat (ic->name_space, ".", ic->name, ".", im->name, NULL);
+					fqname = g_strconcat (ic->name_space, ".", ic->name, ".", im->name, NULL);
 				else
-					qname = g_strconcat (ic->name, ".", im->name, NULL); 
+					fqname = NULL;
 
 				for (j = 0; j < class->method.count; ++j) {
 					MonoMethod *cm = class->methods [j];
@@ -364,20 +565,23 @@ mono_class_init (MonoClass *class)
 					if (!(cm->flags & METHOD_ATTRIBUTE_VIRTUAL))
 						continue;
 					
-					if (!strcmp (cm->name, qname) &&
+					if (((fqname && !strcmp (cm->name, fqname)) || !strcmp (cm->name, qname)) &&
 					    mono_metadata_signature_equal (cm->signature, im->signature)) {
-						tmp_vtable [io + l] = cm;
+						g_assert (io + l <= max_vtsize);
+						vtable [io + l] = cm;
 						break;
 					}
 				}
 				g_free (qname);
+				g_free (fqname);
 			}
 
 			
 			if (!(class->flags & TYPE_ATTRIBUTE_ABSTRACT)) {
 				for (l = 0; l < ic->method.count; l++) {
 					MonoMethod *im = ic->methods [l];						
-					if (!(tmp_vtable [io + l] || vtable [io + l])) {
+					g_assert (io + l <= max_vtsize);
+					if (!(vtable [io + l])) {
 						printf ("no implementation for interface method %s.%s::%s in class %s.%s\n",
 							ic->name_space, ic->name, im->name, class->name_space, class->name);
 						
@@ -392,12 +596,15 @@ mono_class_init (MonoClass *class)
 			}
 		
 			for (l = 0; l < ic->method.count; l++) {
-				MonoMethod *im = tmp_vtable [io + l];
-
-				if (im && !(im->flags & METHOD_ATTRIBUTE_ABSTRACT)) {
-					im->slot = io + l;
-					//printf ("  ASLOT%d %s.%s:%s\n", io + l, ic->name_space, ic->name, im->name);
-					vtable [io + l] = arch_create_jit_trampoline (im);
+				MonoMethod *im = vtable [io + l];
+
+				if (im) {
+					g_assert (io + l <= max_vtsize);
+					if (im->slot < 0) {
+						// fixme: why do we need this ?
+						im->slot = io + l;
+						// g_assert_not_reached ();
+					}
 				}
 			}
 		}
@@ -408,11 +615,17 @@ mono_class_init (MonoClass *class)
 	       
 		cm = class->methods [i];
 
+		
+#if 0
 		if (!(cm->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
 		    (cm->slot >= 0))
 			continue;
-		
-		if (!(cm->flags & METHOD_ATTRIBUTE_NEW_SLOT)) {
+#else  /* EXT_VTABLE_HACK */
+		if (cm->slot >= 0)
+			continue;
+#endif
+
+		if (!(cm->flags & METHOD_ATTRIBUTE_NEW_SLOT) && (cm->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
 			for (k = class->parent; k ; k = k->parent) {
 				int j;
 				for (j = 0; j < k->method.count; ++j) {
@@ -422,6 +635,7 @@ mono_class_init (MonoClass *class)
 					if (!strcmp(cm->name, m1->name) && 
 					    mono_metadata_signature_equal (cm->signature, m1->signature)) {
 						cm->slot = k->methods [j]->slot;
+						g_assert (cm->slot < max_vtsize);
 						break;
 					}
 				}
@@ -434,25 +648,114 @@ mono_class_init (MonoClass *class)
 			cm->slot = cur_slot++;
 
 		if (!(cm->flags & METHOD_ATTRIBUTE_ABSTRACT))
-			vtable [cm->slot] = arch_create_jit_trampoline (cm);
+			vtable [cm->slot] = cm;
 	}
 
-	mono_runtime_class_init (class);
 
-	/*
-	for (i = 0; i < class->vtable_size; ++i) {
-		MonoMethod *cm;
+	class->vtable_size = cur_slot;
+	class->vtable = g_malloc0 (sizeof (gpointer) * class->vtable_size);
+	memcpy (class->vtable, vtable,  sizeof (gpointer) * class->vtable_size);
+
+	class->inited = 1;
+	class->init_pending = 0;
+
+	if (mono_print_vtable) {
+		int icount = 0;
+
+		for (i = 0; i <= max_iid; i++)
+			if (class->interface_offsets [i] != -1)
+				icount++;
+
+		printf ("VTable %s.%s (size = %d, interfaces = %d)\n", class->name_space, 
+			class->name, class->vtable_size, icount); 
+
+		for (i = 0; i < class->vtable_size; ++i) {
+			MonoMethod *cm;
 	       
-		cm = vtable [i];
-		if (cm) 
-			printf ("  METH%d %p %s %d\n", i, cm, cm->name, cm->slot);
+			cm = vtable [i];
+			if (cm) {
+				printf ("  slot %03d(%03d) %s.%s:%s\n", i, cm->slot,
+					cm->klass->name_space, cm->klass->name,
+					cm->name);
+			}
+		}
+
+
+		if (icount) {
+			printf ("Interfaces %s.%s (max_iid = %d)\n", class->name_space, 
+				class->name, max_iid);
+	
+			for (i = 0; i < class->interface_count; i++) {
+				ic = class->interfaces [i];
+				printf ("  slot %03d(%03d) %s.%s\n",  
+					class->interface_offsets [ic->interface_id],
+					ic->method.count, ic->name_space, ic->name);
+			}
 
+			for (k = class->parent; k ; k = k->parent) {
+				for (i = 0; i < k->interface_count; i++) {
+					ic = k->interfaces [i]; 
+					printf ("  slot %03d(%03d) %s.%s\n", 
+						class->interface_offsets [ic->interface_id],
+						ic->method.count, ic->name_space, ic->name);
+				}
+			}
+		}
 	}
-	*/
 
-	//printf ("METAEND %s.%s\n", class->name_space, class->name);
+	if (!default_ghc) {
+		if (class == mono_defaults.object_class) { 
+		       
+			for (i = 0; i < class->vtable_size; ++i) {
+				MonoMethod *cm = vtable [i];
+	       
+				if (!strcmp (cm->name, "GetHashCode")) {
+					ghc_slot = i;
+					break;
+				}
+			}
+
+			g_assert (ghc_slot > 0);
+
+			default_ghc = vtable [ghc_slot];
+		}
+	}
+	
+	class->ghcimpl = 1;
+	if (class != mono_defaults.object_class) { 
+
+		if (vtable [ghc_slot] == default_ghc) {
+			class->ghcimpl = 0;
+		}
+	}
+
+	if (!default_finalize) {
+		if (class == mono_defaults.object_class) { 
+		       
+			for (i = 0; i < class->vtable_size; ++i) {
+				MonoMethod *cm = vtable [i];
+	       
+				if (!strcmp (cm->name, "Finalize")) {
+					finalize_slot = i;
+					break;
+				}
+			}
+
+			g_assert (finalize_slot > 0);
+
+			default_finalize = vtable [finalize_slot];
+		}
+	}
+
+	/* Object::Finalize should have empty implemenatation */
+	class->has_finalize = 0;
+	if (class != mono_defaults.object_class) { 
+		if (vtable [finalize_slot] != default_finalize)
+			class->has_finalize = 1;
+	}
 }
 
+
 /*
  * Compute a relative numbering of the class hierarchy as described in
  * "Java for Large-Scale Scientific Computations?"
@@ -472,59 +775,11 @@ mono_compute_relative_numbering (MonoClass *class, int *c)
 	class->diffval = *c -  class->baseval;
 }
 
-/**
- * @image: context where the image is created
- * @type_token:  typedef token
- */
-static MonoClass *
-mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
+void
+mono_class_setup_mono_type (MonoClass *class)
 {
-	MonoTableInfo *tt = &image->tables [MONO_TABLE_TYPEDEF];
-	MonoClass *class, *parent = NULL;
-	guint32 cols [MONO_TYPEDEF_SIZE];
-	guint32 cols_next [MONO_TYPEDEF_SIZE];
-	guint tidx = mono_metadata_token_index (type_token);
-	const char *name, *nspace;
-	guint vtsize = 0, icount = 0; 
-	static guint interface_id = 0;
-	MonoClass **interfaces;
-	int i;
-
-	g_assert (mono_metadata_token_table (type_token) == MONO_TABLE_TYPEDEF);
-	
-	mono_metadata_decode_row (tt, tidx - 1, cols, CSIZE (cols));
-	
-	if (tt->rows > tidx) {		
-		mono_metadata_decode_row (tt, tidx, cols_next, CSIZE (cols_next));
-		vtsize += cols_next [MONO_TYPEDEF_METHOD_LIST] - cols [MONO_TYPEDEF_METHOD_LIST];
-	} else {
-		vtsize += image->tables [MONO_TABLE_METHOD].rows - cols [MONO_TYPEDEF_METHOD_LIST] + 1;
-	}
-
-	name = mono_metadata_string_heap (image, cols[1]);
-	nspace = mono_metadata_string_heap (image, cols[2]);
-
-	if (!(!strcmp (nspace, "System") && !strcmp (name, "Object")) &&
-	    !(cols [0] & TYPE_ATTRIBUTE_INTERFACE)) {
-		parent = mono_class_get (image, mono_metadata_token_from_dor (cols [3]));
-	}
-	interfaces = mono_metadata_interfaces_from_typedef (image, type_token, &icount);
-
-	for (i = 0; i < icount; i++) 
-		vtsize += interfaces [i]->method.count;
-	
-	if (parent)
-		vtsize += parent->vtable_size;
-
-	if (cols [0] & TYPE_ATTRIBUTE_INTERFACE)
-		vtsize = 0;
-
-	class = g_malloc0 (sizeof (MonoClass) + vtsize * sizeof (gpointer));
-
-	class->parent = parent;
-	class->interfaces = interfaces;
-	class->interface_count = icount;
-	class->vtable_size = vtsize;
+	const char *name = class->name;
+	const char *nspace = class->name_space;
 
 	class->this_arg.byref = 1;
 	class->this_arg.data.klass = class;
@@ -532,34 +787,19 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 	class->byval_arg.data.klass = class;
 	class->byval_arg.type = MONO_TYPE_CLASS;
 
-	class->name = name;
-	class->name_space = nspace;
-
-	class->image = image;
-	class->type_token = type_token;
-	class->flags = cols [0];
-
-	/*g_print ("Init class %s\n", name);*/
-
-	/* if root of the hierarchy */
-	if (!strcmp (nspace, "System") && !strcmp (name, "Object")) {
-		class->parent = NULL;
-		class->instance_size = sizeof (MonoObject);
-	} else if (!(cols [0] & TYPE_ATTRIBUTE_INTERFACE)) {
-		int rnum = 0;
-		class->parent = mono_class_get (image,  mono_metadata_token_from_dor (cols [3]));
-		class->valuetype = class->parent->valuetype;
-		class->enumtype = class->parent->enumtype;
-		class->parent->subclasses = g_list_prepend (class->parent->subclasses, class);
-		mono_compute_relative_numbering (mono_defaults.object_class, &rnum);
-	}
-
 	if (!strcmp (nspace, "System")) {
 		if (!strcmp (name, "ValueType")) {
-			class->valuetype = 1;
+			/*
+			 * do not set the valuetype bit for System.ValueType.
+			 * class->valuetype = 1;
+			 */
 		} else if (!strcmp (name, "Enum")) {
-			class->valuetype = 1;
-			class->enumtype = 1;
+			/*
+			 * do not set the valuetype bit for System.Enum.
+			 * class->valuetype = 1;
+			 */
+			class->valuetype = 0;
+			class->enumtype = 0;
 		} else if (!strcmp (name, "Object")) {
 			class->this_arg.type = class->byval_arg.type = MONO_TYPE_OBJECT;
 		} else if (!strcmp (name, "String")) {
@@ -619,7 +859,7 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 				break;
 			case 'V':
 				if (!strcmp (name, "Void")) {
-					t = MONO_TYPE_CHAR;
+					t = MONO_TYPE_VOID;
 				}
 				break;
 			default:
@@ -628,6 +868,115 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 		}
 		class->this_arg.type = class->byval_arg.type = t;
 	}
+}
+
+void
+mono_class_setup_parent (MonoClass *class, MonoClass *parent)
+{
+	gboolean system_namespace;
+
+	system_namespace = !strcmp (class->name_space, "System");
+
+	/* if root of the hierarchy */
+	if (system_namespace && !strcmp (class->name, "Object")) {
+		class->parent = NULL;
+		class->instance_size = sizeof (MonoObject);
+		return;
+	}
+	if (!strcmp (class->name, "<Module>")) {
+		class->parent = NULL;
+		class->instance_size = 0;
+		return;
+	}
+
+	if (!(class->flags & TYPE_ATTRIBUTE_INTERFACE)) {
+		int rnum = 0;
+		class->parent = parent;
+
+		if (!parent)
+			g_assert_not_reached (); /* FIXME */
+
+		class->marshalbyref = parent->marshalbyref;
+		class->contextbound  = parent->contextbound;
+		class->delegate  = parent->delegate;
+		
+		if (system_namespace) {
+			if (*class->name == 'M' && !strcmp (class->name, "MarshalByRefObject"))
+				class->marshalbyref = 1;
+
+			if (*class->name == 'C' && !strcmp (class->name, "ContextBoundObject")) 
+				class->contextbound  = 1;
+
+			if (*class->name == 'D' && !strcmp (class->name, "Delegate")) 
+				class->delegate  = 1;
+		}
+
+		if (class->parent->enumtype || ((strcmp (class->parent->name, "ValueType") == 0) && 
+						(strcmp (class->parent->name_space, "System") == 0)))
+			class->valuetype = 1;
+		if (((strcmp (class->parent->name, "Enum") == 0) && (strcmp (class->parent->name_space, "System") == 0))) {
+			class->valuetype = class->enumtype = 1;
+		}
+		//class->enumtype = class->parent->enumtype;
+		class->parent->subclasses = g_list_prepend (class->parent->subclasses, class);
+		mono_compute_relative_numbering (mono_defaults.object_class, &rnum);
+	} else {
+		class->parent = NULL;
+	}
+
+}
+
+/**
+ * @image: context where the image is created
+ * @type_token:  typedef token
+ */
+static MonoClass *
+mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
+{
+	MonoTableInfo *tt = &image->tables [MONO_TABLE_TYPEDEF];
+	MonoClass *class, *parent = NULL;
+	guint32 cols [MONO_TYPEDEF_SIZE];
+	guint32 cols_next [MONO_TYPEDEF_SIZE];
+	guint tidx = mono_metadata_token_index (type_token);
+	const char *name, *nspace;
+	guint icount = 0; 
+	MonoClass **interfaces;
+
+	if ((class = g_hash_table_lookup (image->class_cache, GUINT_TO_POINTER (type_token))))
+		return class;
+
+	g_assert (mono_metadata_token_table (type_token) == MONO_TABLE_TYPEDEF);
+	
+	mono_metadata_decode_row (tt, tidx - 1, cols, MONO_TYPEDEF_SIZE);
+	
+	name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
+	nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
+
+	if (cols [MONO_TYPEDEF_EXTENDS])
+		parent = mono_class_get (image, mono_metadata_token_from_dor (cols [MONO_TYPEDEF_EXTENDS]));
+	interfaces = mono_metadata_interfaces_from_typedef (image, type_token, &icount);
+
+	class = g_malloc0 (sizeof (MonoClass));
+			   
+	g_hash_table_insert (image->class_cache, GUINT_TO_POINTER (type_token), class);
+
+	class->interfaces = interfaces;
+	class->interface_count = icount;
+
+	class->name = name;
+	class->name_space = nspace;
+
+	class->image = image;
+	class->type_token = type_token;
+	class->flags = cols [MONO_TYPEDEF_FLAGS];
+
+	class->element_class = class;
+
+	/*g_print ("Init class %s\n", name);*/
+
+	mono_class_setup_parent (class, parent);
+
+	mono_class_setup_mono_type (class);
 
 	/*
 	 * Compute the field and method lists
@@ -662,13 +1011,56 @@ mono_class_create_from_typedef (MonoImage *image, guint32 type_token)
 	}
 
 	if (class->flags & TYPE_ATTRIBUTE_INTERFACE)
-		class->interface_id = interface_id++;
+		class->interface_id = mono_get_unique_iid (class);
 
 	//class->interfaces = mono_metadata_interfaces_from_typedef (image, type_token, &class->interface_count);
-	
+
+	if (class->enumtype) {
+		class->fields = g_new0 (MonoClassField, class->field.count);
+		class_compute_field_layout (class);
+	} 
+
+	if ((type_token = mono_metadata_nested_in_typedef (image, type_token)))
+		class->nested_in = mono_class_create_from_typedef (image, type_token);
 	return class;
 }
 
+MonoClass *
+mono_ptr_class_get (MonoType *type)
+{
+	MonoClass *result;
+	MonoClass *el_class;
+	static GHashTable *ptr_hash = NULL;
+
+	if (!ptr_hash)
+		ptr_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
+	el_class = mono_class_from_mono_type (type);
+	if ((result = g_hash_table_lookup (ptr_hash, el_class)))
+		return result;
+	result = g_new0 (MonoClass, 1);
+
+	result->parent = NULL; /* no parent for PTR types */
+	result->name = "System";
+	result->name_space = "MonoPtrFakeClass";
+	result->image = el_class->image;
+	result->inited = TRUE;
+	/* Can pointers get boxed? */
+	result->instance_size = sizeof (gpointer);
+	/*
+	 * baseval, diffval: need them to allow casting ?
+	 */
+	result->element_class = el_class;
+	result->enum_basetype = &result->element_class->byval_arg;
+
+	result->this_arg.type = result->byval_arg.type = MONO_TYPE_PTR;
+	result->this_arg.data.type = result->byval_arg.data.type = result->enum_basetype;
+	result->this_arg.byref = TRUE;
+
+	g_hash_table_insert (ptr_hash, el_class, result);
+
+	return result;
+}
+
 MonoClass *
 mono_class_from_mono_type (MonoType *type)
 {
@@ -682,9 +1074,9 @@ mono_class_from_mono_type (MonoType *type)
 	case MONO_TYPE_CHAR:
 		return mono_defaults.char_class;
 	case MONO_TYPE_I1:
-		return mono_defaults.byte_class;
-	case MONO_TYPE_U1:
 		return mono_defaults.sbyte_class;
+	case MONO_TYPE_U1:
+		return mono_defaults.byte_class;
 	case MONO_TYPE_I2:
 		return mono_defaults.int16_class;
 	case MONO_TYPE_U2:
@@ -708,11 +1100,11 @@ mono_class_from_mono_type (MonoType *type)
 	case MONO_TYPE_STRING:
 		return mono_defaults.string_class;
 	case MONO_TYPE_ARRAY:
-		return mono_defaults.array_class;
-	case MONO_TYPE_SZARRAY:
+		return mono_array_class_get (type->data.array->type, type->data.array->rank);
 	case MONO_TYPE_PTR:
-		/* Not really sure about these. */
-		return mono_class_from_mono_type (type->data.type);
+		return mono_ptr_class_get (type->data.type);
+	case MONO_TYPE_SZARRAY:
+		return mono_array_class_get (type->data.type, 1);
 	case MONO_TYPE_CLASS:
 	case MONO_TYPE_VALUETYPE:
 		return type->data.klass;
@@ -727,38 +1119,29 @@ mono_class_from_mono_type (MonoType *type)
 /**
  * @image: context where the image is created
  * @type_spec:  typespec token
- * @at: an optional pointer to return the array type
  */
 static MonoClass *
 mono_class_create_from_typespec (MonoImage *image, guint32 type_spec)
 {
-	guint32 idx = mono_metadata_token_index (type_spec);
-	MonoTableInfo *t;
-	guint32 cols [MONO_TYPESPEC_SIZE];       
-	const char *ptr;
-	guint32 len;
 	MonoType *type;
-	MonoClass *class, *eclass;
+	MonoClass *class;
 
-	t = &image->tables [MONO_TABLE_TYPESPEC];
-	
-	mono_metadata_decode_row (t, idx-1, cols, MONO_TYPESPEC_SIZE);
-	ptr = mono_metadata_blob_heap (image, cols [MONO_TYPESPEC_SIGNATURE]);
-	len = mono_metadata_decode_value (ptr, &ptr);
-	type = mono_metadata_parse_type (image, MONO_PARSE_TYPE, 0, ptr, &ptr);
+	type = mono_type_create_from_typespec (image, type_spec);
 
 	switch (type->type) {
 	case MONO_TYPE_ARRAY:
-		eclass = mono_class_from_mono_type (type->data.array->type);
-		class = mono_array_class_get (eclass, type->data.array->rank);
+		class = mono_array_class_get (type->data.array->type, type->data.array->rank);
 		break;
 	case MONO_TYPE_SZARRAY:
-		eclass = mono_class_from_mono_type (type->data.type);
-		class = mono_array_class_get (eclass, 1);
+		class = mono_array_class_get (type->data.type, 1);
+		break;
+	case MONO_TYPE_PTR:
+		class = mono_class_from_mono_type (type->data.type);
 		break;
 	default:
-		g_warning ("implement me: %08x", type->type);
-		g_assert_not_reached ();		
+		/* it seems any type can be stored in TypeSpec as well */
+		class = mono_class_from_mono_type (type);
+		break;
 	}
 
 	mono_metadata_free_type (type);
@@ -768,37 +1151,39 @@ mono_class_create_from_typespec (MonoImage *image, guint32 type_spec)
 
 /**
  * mono_array_class_get:
- * @eclass: element type class
+ * @element_type: element type 
  * @rank: the dimension of the array class
  *
- * Returns: a class object describing the array with element type @etype and 
+ * Returns: a class object describing the array with element type @element_type and 
  * dimension @rank. 
  */
 MonoClass *
-mono_array_class_get (MonoClass *eclass, guint32 rank)
+mono_array_class_get (MonoType *element_type, guint32 rank)
 {
+	MonoClass *eclass;
 	MonoImage *image;
 	MonoClass *class;
-	static MonoClass *parent = NULL;
-	guint32 key;
+	MonoClass *parent = NULL;
+	GSList *list;
 	int rnum = 0;
 
+	eclass = mono_class_from_mono_type (element_type);
 	g_assert (rank <= 255);
 
-	if (!parent)
-		parent = mono_defaults.array_class;
+	parent = mono_defaults.array_class;
 
 	if (!parent->inited)
 		mono_class_init (parent);
 
 	image = eclass->image;
 
-	g_assert (!eclass->type_token ||
-		  mono_metadata_token_table (eclass->type_token) == MONO_TABLE_TYPEDEF);
-
-	key = ((rank & 0xff) << 24) | (eclass->type_token & 0xffffff);
-	if ((class = g_hash_table_lookup (image->array_cache, GUINT_TO_POINTER (key))))
-		return class;
+	if ((list = g_hash_table_lookup (image->array_cache, element_type))) {
+		for (; list; list = list->next) {
+			class = list->data;
+			if (class->rank == rank)
+				return class;
+		}
+	}
 	
 	class = g_malloc0 (sizeof (MonoClass) + parent->vtable_size * sizeof (gpointer));
 
@@ -817,16 +1202,22 @@ mono_array_class_get (MonoClass *eclass, guint32 rank)
 	class->rank = rank;
 	class->element_class = eclass;
 	if (rank > 1) {
+		MonoArrayType *at = g_new0 (MonoArrayType, 1);
 		class->byval_arg.type = MONO_TYPE_ARRAY;
+		class->byval_arg.data.array = at;
+		at->type = &eclass->byval_arg;
+		at->rank = rank;
 		/* FIXME: complete.... */
 	} else {
+		/* FIXME: this is not correct. the lbound could be >0 */
 		class->byval_arg.type = MONO_TYPE_SZARRAY;
 		class->byval_arg.data.type = &eclass->byval_arg;
 	}
 	class->this_arg = class->byval_arg;
 	class->this_arg.byref = 1;
-	
-	g_hash_table_insert (image->array_cache, GUINT_TO_POINTER (key), class);
+
+	list = g_slist_append (list, class);
+	g_hash_table_insert (image->array_cache, &class->element_class->byval_arg, list);
 	return class;
 }
 
@@ -840,7 +1231,7 @@ gint32
 mono_class_instance_size (MonoClass *klass)
 {
 	
-	if (!klass->inited)
+	if (!klass->size_inited)
 		mono_class_init (klass);
 
 	return klass->instance_size;
@@ -867,12 +1258,8 @@ mono_class_value_size      (MonoClass *klass, guint32 *align)
 
 	size = mono_class_instance_size (klass) - sizeof (MonoObject);
 
-	if (align) {
-		if (size <= 4)
-			*align = 4;
-		else
-			*align = 8;
-	}
+	if (align)
+		*align = klass->min_align;
 
 	return size;
 }
@@ -927,9 +1314,6 @@ mono_class_get_field (MonoClass *class, guint32 field_token)
 {
 	int idx = mono_metadata_token_index (field_token);
 
-	if (mono_metadata_token_code (field_token) == MONO_TOKEN_MEMBER_REF)
-		g_error ("Unsupported Field Token is a MemberRef, implement me");
-
 	g_assert (mono_metadata_token_code (field_token) == MONO_TOKEN_FIELD_DEF);
 
 	return mono_class_get_field_idx (class, idx - 1);
@@ -939,12 +1323,9 @@ MonoClassField *
 mono_class_get_field_from_name (MonoClass *klass, const char *name)
 {
 	int i;
-	guint32 token;
-	MonoTableInfo *t = &klass->image->tables [MONO_TABLE_FIELD];
 
 	for (i = 0; i < klass->field.count; ++i) {
-		token = mono_metadata_decode_row_col (t, klass->field.first + i, MONO_FIELD_NAME);
-		if (strcmp (name, mono_metadata_string_heap (klass->image, token)) == 0)
+		if (strcmp (name, klass->fields [i].name) == 0)
 			return &klass->fields [i];
 	}
 	return NULL;
@@ -965,27 +1346,21 @@ mono_class_get (MonoImage *image, guint32 type_token)
 
 	switch (type_token & 0xff000000){
 	case MONO_TOKEN_TYPE_DEF:
-		if ((class = g_hash_table_lookup (image->class_cache, 
-						  GUINT_TO_POINTER (type_token))))
-			return class;
 		class = mono_class_create_from_typedef (image, type_token);
 		break;		
 	case MONO_TOKEN_TYPE_REF:
-		return mono_class_create_from_typeref (image, type_token);
+		class = mono_class_from_typeref (image, type_token);
+		break;
 	case MONO_TOKEN_TYPE_SPEC:
-		if ((class = g_hash_table_lookup (image->class_cache, 
-						  GUINT_TO_POINTER (type_token))))
-			return class;
-
 		class = mono_class_create_from_typespec (image, type_token);
 		break;
 	default:
 		g_warning ("unknown token type %x", type_token & 0xff000000);
 		g_assert_not_reached ();
 	}
-	
-	g_hash_table_insert (image->class_cache, GUINT_TO_POINTER (type_token), class);
 
+	if (!class)
+		g_warning ("Could not load class from token 0x%08x in %s", type_token, image->name);
 	return class;
 }
 
@@ -1001,7 +1376,7 @@ mono_class_from_name (MonoImage *image, const char* name_space, const char *name
 	token = GPOINTER_TO_UINT (g_hash_table_lookup (nspace_table, name));
 	
 	if (!token) {
-		g_warning ("token not found for %s.%s in image %s", name_space, name, image->name);
+		/*g_warning ("token not found for %s.%s in image %s", name_space, name, image->name);*/
 		return NULL;
 	}
 
@@ -1019,14 +1394,10 @@ mono_class_from_name (MonoImage *image, const char* name_space, const char *name
 gint32
 mono_array_element_size (MonoClass *ac)
 {
-	gint32 esize;
-
-	esize = mono_class_instance_size (ac->element_class);
-	
 	if (ac->element_class->valuetype)
-		esize -= sizeof (MonoObject);
-	
-	return esize;
+		return mono_class_instance_size (ac->element_class) - sizeof (MonoObject);
+	else
+		return sizeof (gpointer);
 }
 
 gpointer
@@ -1039,6 +1410,7 @@ mono_ldtoken (MonoImage *image, guint32 token, MonoClass **handle_class)
 		if (handle_class)
 			*handle_class = mono_defaults.typehandle_class;
 		class = mono_class_get (image, token);
+		mono_class_init (class);
 		/* We return a MonoType* as handle */
 		return &class->byval_arg;
 	}
@@ -1046,10 +1418,8 @@ mono_ldtoken (MonoImage *image, guint32 token, MonoClass **handle_class)
 		MonoClass *class;
 		if (handle_class)
 			*handle_class = mono_defaults.typehandle_class;
-		if ((class = g_hash_table_lookup (image->class_cache, 
-						  GUINT_TO_POINTER (token))))
-			return &class->byval_arg;
 		class = mono_class_create_from_typespec (image, token);
+		mono_class_init (class);
 		return &class->byval_arg;
 	}
 	case MONO_TOKEN_FIELD_DEF: {