X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fimage.c;h=bcbfa92294d5d358d9e5aa888377f638f2210030;hb=6864a4dd1d75b37ffb892ffe00f762d3abf7f380;hp=0a1220b0300dfcc7e6da27c20e2e7f43285d621a;hpb=c39d7ce9985a7067c1cbf44188007c9433901940;p=mono.git

diff --git a/mono/metadata/image.c b/mono/metadata/image.c
index 0a1220b0300..bcbfa92294d 100644
--- a/mono/metadata/image.c
+++ b/mono/metadata/image.c
@@ -17,18 +17,27 @@
 #include <string.h>
 #include "image.h"
 #include "cil-coff.h"
-#include "rawbuffer.h"
 #include "mono-endian.h"
 #include "tabledefs.h"
 #include "tokentype.h"
 #include "metadata-internals.h"
+#include "profiler-private.h"
 #include "loader.h"
+#include "marshal.h"
+#include "coree.h"
 #include <mono/io-layer/io-layer.h>
 #include <mono/utils/mono-logger.h>
 #include <mono/utils/mono-path.h>
+#include <mono/utils/mono-mmap.h>
+#include <mono/utils/mono-io-portability.h>
+#include <mono/metadata/class-internals.h>
+#include <mono/metadata/assembly.h>
+#include <mono/metadata/object-internals.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
+#endif
 
 #define INVALID_ADDRESS 0xffffffff
 
@@ -36,9 +45,7 @@
  * Keeps track of the various assemblies loaded
  */
 static GHashTable *loaded_images_hash;
-static GHashTable *loaded_images_guid_hash;
 static GHashTable *loaded_images_refonly_hash;
-static GHashTable *loaded_images_refonly_guid_hash;
 
 static gboolean debug_assembly_unload = FALSE;
 
@@ -46,9 +53,11 @@ static gboolean debug_assembly_unload = FALSE;
 #define mono_images_unlock() LeaveCriticalSection (&images_mutex)
 static CRITICAL_SECTION images_mutex;
 
+/* returns offset relative to image->raw_data */
 guint32
-mono_cli_rva_image_map (MonoCLIImageInfo *iinfo, guint32 addr)
+mono_cli_rva_image_map (MonoImage *image, guint32 addr)
 {
+	MonoCLIImageInfo *iinfo = image->image_info;
 	const int top = iinfo->cli_section_count;
 	MonoSectionTable *tables = iinfo->cli_section_tables;
 	int i;
@@ -56,6 +65,10 @@ mono_cli_rva_image_map (MonoCLIImageInfo *iinfo, guint32 addr)
 	for (i = 0; i < top; i++){
 		if ((addr >= tables->st_virtual_address) &&
 		    (addr < tables->st_virtual_address + tables->st_raw_data_size)){
+#ifdef PLATFORM_WIN32
+			if (image->is_module_handle)
+				return addr;
+#endif
 			return addr - tables->st_virtual_address + tables->st_raw_data_ptr;
 		}
 		tables++;
@@ -63,6 +76,17 @@ mono_cli_rva_image_map (MonoCLIImageInfo *iinfo, guint32 addr)
 	return INVALID_ADDRESS;
 }
 
+/**
+ * mono_images_rva_map:
+ * @image: a MonoImage
+ * @addr: relative virtual address (RVA)
+ *
+ * This is a low-level routine used by the runtime to map relative
+ * virtual address (RVA) into their location in memory. 
+ *
+ * Returns: the address in memory for the given RVA, or NULL if the
+ * RVA is not valid for this image. 
+ */
 char *
 mono_image_rva_map (MonoImage *image, guint32 addr)
 {
@@ -78,6 +102,10 @@ mono_image_rva_map (MonoImage *image, guint32 addr)
 				if (!mono_image_ensure_section_idx (image, i))
 					return NULL;
 			}
+#ifdef PLATFORM_WIN32
+			if (image->is_module_handle)
+				return image->raw_data + addr;
+#endif
 			return (char*)iinfo->cli_sections [i] +
 				(addr - tables->st_virtual_address);
 		}
@@ -97,9 +125,7 @@ mono_images_init (void)
 	InitializeCriticalSection (&images_mutex);
 
 	loaded_images_hash = g_hash_table_new (g_str_hash, g_str_equal);
-	loaded_images_guid_hash = g_hash_table_new (g_str_hash, g_str_equal);
 	loaded_images_refonly_hash = g_hash_table_new (g_str_hash, g_str_equal);
-	loaded_images_refonly_guid_hash = g_hash_table_new (g_str_hash, g_str_equal);
 
 	debug_assembly_unload = getenv ("MONO_DEBUG_ASSEMBLY_UNLOAD") != NULL;
 }
@@ -115,9 +141,7 @@ mono_images_cleanup (void)
 	DeleteCriticalSection (&images_mutex);
 
 	g_hash_table_destroy (loaded_images_hash);
-	g_hash_table_destroy (loaded_images_guid_hash);
 	g_hash_table_destroy (loaded_images_refonly_hash);
-	g_hash_table_destroy (loaded_images_refonly_guid_hash);
 }
 
 /**
@@ -148,6 +172,11 @@ mono_image_ensure_section_idx (MonoImage *image, int section)
 
 	if (sect->st_raw_data_ptr + sect->st_raw_data_size > image->raw_data_len)
 		return FALSE;
+#ifdef PLATFORM_WIN32
+	if (image->is_module_handle)
+		iinfo->cli_sections [section] = image->raw_data + sect->st_virtual_address;
+	else
+#endif
 	/* FIXME: we ignore the writable flag since we don't patch the binary */
 	iinfo->cli_sections [section] = image->raw_data + sect->st_raw_data_ptr;
 	return TRUE;
@@ -218,7 +247,7 @@ load_cli_header (MonoImage *image, MonoCLIImageInfo *iinfo)
 {
 	guint32 offset;
 	
-	offset = mono_cli_rva_image_map (iinfo, iinfo->cli_header.datadir.pe_cli_header.rva);
+	offset = mono_cli_rva_image_map (image, iinfo->cli_header.datadir.pe_cli_header.rva);
 	if (offset == INVALID_ADDRESS)
 		return FALSE;
 
@@ -286,7 +315,7 @@ load_metadata_ptrs (MonoImage *image, MonoCLIImageInfo *iinfo)
 	guint32 pad;
 	char *ptr;
 	
-	offset = mono_cli_rva_image_map (iinfo, iinfo->cli_cli_header.ch_metadata.rva);
+	offset = mono_cli_rva_image_map (image, iinfo->cli_cli_header.ch_metadata.rva);
 	if (offset == INVALID_ADDRESS)
 		return FALSE;
 
@@ -345,8 +374,11 @@ load_metadata_ptrs (MonoImage *image, MonoCLIImageInfo *iinfo)
 			image->heap_guid.size = read32 (ptr + 4);
 			ptr += 8 + 6;
 		} else if (strncmp (ptr + 8, "#-", 3) == 0) {
-			g_print ("Assembly '%s' has the non-standard metadata heap #-.\nRecompile it correctly (without the /incremental switch or in Release mode).", image->name);
-			return FALSE;
+			image->heap_tables.data = image->raw_metadata + read32 (ptr);
+			image->heap_tables.size = read32 (ptr + 4);
+			ptr += 8 + 3;
+			image->uncompressed_metadata = TRUE;
+			mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Assembly '%s' has the non-standard metadata heap #-.\nRecompile it correctly (without the /incremental switch or in Release mode).\n", image->name);
 		} else {
 			g_message ("Unknown heap type: %s\n", ptr + 8);
 			ptr += 8 + strlen (ptr + 8) + 1;
@@ -422,8 +454,68 @@ load_metadata (MonoImage *image, MonoCLIImageInfo *iinfo)
 	return load_tables (image);
 }
 
+void
+mono_image_check_for_module_cctor (MonoImage *image)
+{
+	MonoTableInfo *t, *mt;
+	t = &image->tables [MONO_TABLE_TYPEDEF];
+	mt = &image->tables [MONO_TABLE_METHOD];
+	if (mono_framework_version () == 1) {
+		image->checked_module_cctor = TRUE;
+		return;
+	}
+	if (image->dynamic) {
+		/* FIXME: */
+		image->checked_module_cctor = TRUE;
+		return;
+	}
+	if (t->rows >= 1) {
+		guint32 nameidx = mono_metadata_decode_row_col (t, 0, MONO_TYPEDEF_NAME);
+		const char *name = mono_metadata_string_heap (image, nameidx);
+		if (strcmp (name, "<Module>") == 0) {
+			guint32 first_method = mono_metadata_decode_row_col (t, 0, MONO_TYPEDEF_METHOD_LIST) - 1;
+			guint32 last_method;
+			if (t->rows > 1)
+				last_method = mono_metadata_decode_row_col (t, 1, MONO_TYPEDEF_METHOD_LIST) - 1;
+			else 
+				last_method = mt->rows;
+			for (; first_method < last_method; first_method++) {
+				nameidx = mono_metadata_decode_row_col (mt, first_method, MONO_METHOD_NAME);
+				name = mono_metadata_string_heap (image, nameidx);
+				if (strcmp (name, ".cctor") == 0) {
+					image->has_module_cctor = TRUE;
+					image->checked_module_cctor = TRUE;
+					return;
+				}
+			}
+		}
+	}
+	image->has_module_cctor = FALSE;
+	image->checked_module_cctor = TRUE;
+}
+
 static void
-load_modules (MonoImage *image, MonoImageOpenStatus *status)
+load_modules (MonoImage *image)
+{
+	MonoTableInfo *t;
+
+	if (image->modules)
+		return;
+
+	t = &image->tables [MONO_TABLE_MODULEREF];
+	image->modules = g_new0 (MonoImage *, t->rows);
+	image->modules_loaded = g_new0 (gboolean, t->rows);
+	image->module_count = t->rows;
+}
+
+/**
+ * mono_image_load_module:
+ *
+ *   Load the module with the one-based index IDX from IMAGE and return it. Return NULL if
+ * it cannot be loaded.
+ */
+MonoImage*
+mono_image_load_module (MonoImage *image, int idx)
 {
 	MonoTableInfo *t;
 	MonoTableInfo *file_table;
@@ -431,9 +523,11 @@ load_modules (MonoImage *image, MonoImageOpenStatus *status)
 	char *base_dir;
 	gboolean refonly = image->ref_only;
 	GList *list_iter, *valid_modules = NULL;
+	MonoImageOpenStatus status;
 
-	if (image->modules)
-		return;
+	g_assert (idx <= image->module_count);
+	if (image->modules_loaded [idx - 1])
+		return image->modules [idx - 1];
 
 	file_table = &image->tables [MONO_TABLE_FILE];
 	for (i = 0; i < file_table->rows; i++) {
@@ -445,16 +539,16 @@ load_modules (MonoImage *image, MonoImageOpenStatus *status)
 	}
 
 	t = &image->tables [MONO_TABLE_MODULEREF];
-	image->modules = g_new0 (MonoImage *, t->rows);
-	image->module_count = t->rows;
 	base_dir = g_path_get_dirname (image->name);
-	for (i = 0; i < t->rows; i++){
+
+	{
 		char *module_ref;
 		const char *name;
 		guint32 cols [MONO_MODULEREF_SIZE];
-		int valid = 0;
+		/* if there is no file table, we try to load the module... */
+		int valid = file_table->rows == 0;
 
-		mono_metadata_decode_row (t, i, cols, MONO_MODULEREF_SIZE);
+		mono_metadata_decode_row (t, idx - 1, cols, MONO_MODULEREF_SIZE);
 		name = mono_metadata_string_heap (image, cols [MONO_MODULEREF_NAME]);
 		for (list_iter = valid_modules; list_iter; list_iter = list_iter->next) {
 			/* be safe with string dups, but we could just compare string indexes  */
@@ -463,123 +557,98 @@ load_modules (MonoImage *image, MonoImageOpenStatus *status)
 				break;
 			}
 		}
-		if (!valid)
-			continue;
-		module_ref = g_build_filename (base_dir, name, NULL);
-		image->modules [i] = mono_image_open_full (module_ref, status, refonly);
-		if (image->modules [i]) {
-			mono_image_addref (image->modules [i]);
-			/* g_print ("loaded module %s from %s (%p)\n", module_ref, image->name, image->assembly); */
+		if (valid) {
+			module_ref = g_build_filename (base_dir, name, NULL);
+			image->modules [idx - 1] = mono_image_open_full (module_ref, &status, refonly);
+			if (image->modules [idx - 1]) {
+				mono_image_addref (image->modules [idx - 1]);
+				image->modules [idx - 1]->assembly = image->assembly;
+#ifdef PLATFORM_WIN32
+				if (image->modules [idx - 1]->is_module_handle)
+					mono_image_fixup_vtable (image->modules [idx - 1]);
+#endif
+				/* g_print ("loaded module %s from %s (%p)\n", module_ref, image->name, image->assembly); */
+			}
+			g_free (module_ref);
 		}
-		/* 
-		 * FIXME: We should probably do lazy-loading of modules.
-		 */
-		if (status)
-			*status = MONO_IMAGE_OK;
-		g_free (module_ref);
 	}
 
+	image->modules_loaded [idx - 1] = TRUE;
+
 	g_free (base_dir);
 	g_list_free (valid_modules);
+
+	return image->modules [idx - 1];
 }
 
-static void
-register_guid (gpointer key, gpointer value, gpointer user_data)
+static gpointer
+class_key_extract (gpointer value)
 {
-	MonoImage *image = (MonoImage*)value;
+	MonoClass *class = value;
 
-	if (!g_hash_table_lookup (loaded_images_guid_hash, image))
-		g_hash_table_insert (loaded_images_guid_hash, image->guid, image);
+	return GUINT_TO_POINTER (class->type_token);
 }
 
-static void
-build_guid_table (gboolean refonly)
+static gpointer*
+class_next_value (gpointer value)
 {
-	GHashTable *loaded_images = refonly ? loaded_images_refonly_hash : loaded_images_hash;
-	g_hash_table_foreach (loaded_images, register_guid, NULL);
+	MonoClass *class = value;
+
+	return (gpointer*)&class->next_class_cache;
 }
 
 void
 mono_image_init (MonoImage *image)
 {
-	image->mempool = mono_mempool_new ();
-	image->method_cache = g_hash_table_new (NULL, NULL);
-	image->class_cache = g_hash_table_new (NULL, NULL);
+	image->mempool = mono_mempool_new_size (512);
+	mono_internal_hash_table_init (&image->class_cache,
+				       g_direct_hash,
+				       class_key_extract,
+				       class_next_value);
 	image->field_cache = g_hash_table_new (NULL, NULL);
 
-	image->delegate_begin_invoke_cache = 
-		g_hash_table_new ((GHashFunc)mono_signature_hash, 
-				  (GCompareFunc)mono_metadata_signature_equal);
-	image->delegate_end_invoke_cache = 
-		g_hash_table_new ((GHashFunc)mono_signature_hash, 
-				  (GCompareFunc)mono_metadata_signature_equal);
-	image->delegate_invoke_cache = 
-		g_hash_table_new ((GHashFunc)mono_signature_hash, 
-				  (GCompareFunc)mono_metadata_signature_equal);
-	image->runtime_invoke_cache  = 
-		g_hash_table_new ((GHashFunc)mono_signature_hash, 
-				  (GCompareFunc)mono_metadata_signature_equal);
-	
-	image->managed_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
 	image->native_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->remoting_invoke_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->cominterop_invoke_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->cominterop_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->synchronized_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->unbox_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-
-	image->ldfld_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->ldflda_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->ldfld_remote_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->stfld_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->stfld_remote_wrapper_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->isinst_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->castclass_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
-	image->proxy_isinst_cache = g_hash_table_new (mono_aligned_addr_hash, NULL);
 
 	image->typespec_cache = g_hash_table_new (NULL, NULL);
 	image->memberref_signatures = g_hash_table_new (NULL, NULL);
 	image->helper_signatures = g_hash_table_new (g_str_hash, g_str_equal);
 	image->method_signatures = g_hash_table_new (NULL, NULL);
-}
-
-static MonoImage *
-do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
-		    gboolean care_about_cli)
-{
-	MonoCLIImageInfo *iinfo;
-	MonoDotNetHeader *header;
-	MonoMSDOSHeader msdos;
-	guint32 offset = 0;
 
-	mono_image_init (image);
+	image->property_hash = mono_property_hash_new ();
+}
 
-	iinfo = image->image_info;
-	header = &iinfo->cli_header;
-		
-	if (status)
-		*status = MONO_IMAGE_IMAGE_INVALID;
+#if G_BYTE_ORDER != G_LITTLE_ENDIAN
+#define SWAP64(x) (x) = GUINT64_FROM_LE ((x))
+#define SWAP32(x) (x) = GUINT32_FROM_LE ((x))
+#define SWAP16(x) (x) = GUINT16_FROM_LE ((x))
+#define SWAPPDE(x) do { (x).rva = GUINT32_FROM_LE ((x).rva); (x).size = GUINT32_FROM_LE ((x).size);} while (0)
+#else
+#define SWAP64(x)
+#define SWAP32(x)
+#define SWAP16(x)
+#define SWAPPDE(x)
+#endif
 
-	if (offset + sizeof (msdos) > image->raw_data_len)
-		goto invalid_image;
-	memcpy (&msdos, image->raw_data + offset, sizeof (msdos));
-	
-	if (!(msdos.msdos_sig [0] == 'M' && msdos.msdos_sig [1] == 'Z'))
-		goto invalid_image;
-	
-	msdos.pe_offset = GUINT32_FROM_LE (msdos.pe_offset);
+/*
+ * Returns < 0 to indicate an error.
+ */
+static int
+do_load_header (MonoImage *image, MonoDotNetHeader *header, int offset)
+{
+	MonoDotNetHeader64 header64;
 
-	offset = msdos.pe_offset;
+#ifdef PLATFORM_WIN32
+	if (!image->is_module_handle)
+#endif
+	if (offset + sizeof (MonoDotNetHeader32) > image->raw_data_len)
+		return -1;
 
-	if (offset + sizeof (MonoDotNetHeader) > image->raw_data_len)
-		goto invalid_image;
 	memcpy (header, image->raw_data + offset, sizeof (MonoDotNetHeader));
-	offset += sizeof (MonoDotNetHeader);
 
-#if G_BYTE_ORDER != G_LITTLE_ENDIAN
-#define SWAP32(x) (x) = GUINT32_FROM_LE ((x))
-#define SWAP16(x) (x) = GUINT16_FROM_LE ((x))
-#define SWAPPDE(x) do { (x).rva = GUINT32_FROM_LE ((x).rva); (x).size = GUINT32_FROM_LE ((x).size);} while (0)
+	if (header->pesig [0] != 'P' || header->pesig [1] != 'E')
+		return -1;
+
+	/* endian swap the fields common between PE and PE+ */
 	SWAP32 (header->coff.coff_time);
 	SWAP32 (header->coff.coff_symptr);
 	SWAP32 (header->coff.coff_symcount);
@@ -589,15 +658,71 @@ do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
 	SWAP16 (header->coff.coff_attributes);
 	/* MonoPEHeader */
 	SWAP32 (header->pe.pe_code_size);
-	SWAP32 (header->pe.pe_data_size);
 	SWAP32 (header->pe.pe_uninit_data_size);
 	SWAP32 (header->pe.pe_rva_entry_point);
 	SWAP32 (header->pe.pe_rva_code_base);
 	SWAP32 (header->pe.pe_rva_data_base);
 	SWAP16 (header->pe.pe_magic);
 
+	/* now we are ready for the basic tests */
+
+	if (header->pe.pe_magic == 0x10B) {
+		offset += sizeof (MonoDotNetHeader);
+		SWAP32 (header->pe.pe_data_size);
+		if (header->coff.coff_opt_header_size != (sizeof (MonoDotNetHeader) - sizeof (MonoCOFFHeader) - 4))
+			return -1;
+
+		SWAP32	(header->nt.pe_image_base); 	/* must be 0x400000 */
+		SWAP32	(header->nt.pe_stack_reserve);
+		SWAP32	(header->nt.pe_stack_commit);
+		SWAP32	(header->nt.pe_heap_reserve);
+		SWAP32	(header->nt.pe_heap_commit);
+	} else if (header->pe.pe_magic == 0x20B) {
+		/* PE32+ file format */
+		if (header->coff.coff_opt_header_size != (sizeof (MonoDotNetHeader64) - sizeof (MonoCOFFHeader) - 4))
+			return -1;
+		memcpy (&header64, image->raw_data + offset, sizeof (MonoDotNetHeader64));
+		offset += sizeof (MonoDotNetHeader64);
+		/* copy the fields already swapped. the last field, pe_data_size, is missing */
+		memcpy (&header64, header, sizeof (MonoDotNetHeader) - 4);
+		/* FIXME: we lose bits here, but we don't use this stuff internally, so we don't care much.
+		 * will be fixed when we change MonoDotNetHeader to not match the 32 bit variant
+		 */
+		SWAP64	(header64.nt.pe_image_base);
+		header->nt.pe_image_base = header64.nt.pe_image_base;
+		SWAP64	(header64.nt.pe_stack_reserve);
+		header->nt.pe_stack_reserve = header64.nt.pe_stack_reserve;
+		SWAP64	(header64.nt.pe_stack_commit);
+		header->nt.pe_stack_commit = header64.nt.pe_stack_commit;
+		SWAP64	(header64.nt.pe_heap_reserve);
+		header->nt.pe_heap_reserve = header64.nt.pe_heap_reserve;
+		SWAP64	(header64.nt.pe_heap_commit);
+		header->nt.pe_heap_commit = header64.nt.pe_heap_commit;
+
+		header->nt.pe_section_align = header64.nt.pe_section_align;
+		header->nt.pe_file_alignment = header64.nt.pe_file_alignment;
+		header->nt.pe_os_major = header64.nt.pe_os_major;
+		header->nt.pe_os_minor = header64.nt.pe_os_minor;
+		header->nt.pe_user_major = header64.nt.pe_user_major;
+		header->nt.pe_user_minor = header64.nt.pe_user_minor;
+		header->nt.pe_subsys_major = header64.nt.pe_subsys_major;
+		header->nt.pe_subsys_minor = header64.nt.pe_subsys_minor;
+		header->nt.pe_reserved_1 = header64.nt.pe_reserved_1;
+		header->nt.pe_image_size = header64.nt.pe_image_size;
+		header->nt.pe_header_size = header64.nt.pe_header_size;
+		header->nt.pe_checksum = header64.nt.pe_checksum;
+		header->nt.pe_subsys_required = header64.nt.pe_subsys_required;
+		header->nt.pe_dll_flags = header64.nt.pe_dll_flags;
+		header->nt.pe_loader_flags = header64.nt.pe_loader_flags;
+		header->nt.pe_data_dir_count = header64.nt.pe_data_dir_count;
+
+		/* copy the datadir */
+		memcpy (&header->datadir, &header64.datadir, sizeof (MonoPEDatadir));
+	} else {
+		return -1;
+	}
+
 	/* MonoPEHeaderNT: not used yet */
-	SWAP32	(header->nt.pe_image_base); 	/* must be 0x400000 */
 	SWAP32	(header->nt.pe_section_align);       /* must be 8192 */
 	SWAP32	(header->nt.pe_file_alignment);      /* must be 512 or 4096 */
 	SWAP16	(header->nt.pe_os_major);            /* must be 4 */
@@ -612,10 +737,6 @@ do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
 	SWAP32	(header->nt.pe_checksum);
 	SWAP16	(header->nt.pe_subsys_required);
 	SWAP16	(header->nt.pe_dll_flags);
-	SWAP32	(header->nt.pe_stack_reserve);
-	SWAP32	(header->nt.pe_stack_commit);
-	SWAP32	(header->nt.pe_heap_reserve);
-	SWAP32	(header->nt.pe_heap_commit);
 	SWAP32	(header->nt.pe_loader_flags);
 	SWAP32	(header->nt.pe_data_dir_count);
 
@@ -637,19 +758,57 @@ do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
  	SWAPPDE (header->datadir.pe_cli_header);
 	SWAPPDE (header->datadir.pe_reserved);
 
-#undef SWAP32
-#undef SWAP16
-#undef SWAPPDE
+#ifdef PLATFORM_WIN32
+	if (image->is_module_handle)
+		image->raw_data_len = header->nt.pe_image_size;
 #endif
 
-	if (header->coff.coff_machine != 0x14c)
+	return offset;
+}
+
+static MonoImage *
+do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
+		    gboolean care_about_cli)
+{
+	MonoCLIImageInfo *iinfo;
+	MonoDotNetHeader *header;
+	MonoMSDOSHeader msdos;
+	gint32 offset = 0;
+
+	mono_profiler_module_event (image, MONO_PROFILE_START_LOAD);
+
+	mono_image_init (image);
+
+	iinfo = image->image_info;
+	header = &iinfo->cli_header;
+		
+	if (status)
+		*status = MONO_IMAGE_IMAGE_INVALID;
+
+#ifdef PLATFORM_WIN32
+	if (!image->is_module_handle)
+#endif
+	if (offset + sizeof (msdos) > image->raw_data_len)
 		goto invalid_image;
+	memcpy (&msdos, image->raw_data + offset, sizeof (msdos));
+	
+	if (!(msdos.msdos_sig [0] == 'M' && msdos.msdos_sig [1] == 'Z'))
+		goto invalid_image;
+	
+	msdos.pe_offset = GUINT32_FROM_LE (msdos.pe_offset);
+
+	offset = msdos.pe_offset;
 
-	if (header->coff.coff_opt_header_size != (sizeof (MonoDotNetHeader) - sizeof (MonoCOFFHeader) - 4))
+	offset = do_load_header (image, header, offset);
+	if (offset < 0)
 		goto invalid_image;
 
-	if (header->pesig[0] != 'P' || header->pesig[1] != 'E' || header->pe.pe_magic != 0x10B)
+	/*
+	 * this tests for a x86 machine type, but itanium, amd64 and others could be used, too.
+	 * we skip this test.
+	if (header->coff.coff_machine != 0x14c)
 		goto invalid_image;
+	*/
 
 #if 0
 	/*
@@ -686,24 +845,27 @@ do_mono_image_load (MonoImage *image, MonoImageOpenStatus *status,
 		goto invalid_image;
 
 	/* modules don't have an assembly table row */
-	if (image->tables [MONO_TABLE_ASSEMBLY].rows)
+	if (image->tables [MONO_TABLE_ASSEMBLY].rows) {
 		image->assembly_name = mono_metadata_string_heap (image, 
 			mono_metadata_decode_row_col (&image->tables [MONO_TABLE_ASSEMBLY],
 					0, MONO_ASSEMBLY_NAME));
+	}
 
 	image->module_name = mono_metadata_string_heap (image, 
 			mono_metadata_decode_row_col (&image->tables [MONO_TABLE_MODULE],
 					0, MONO_MODULE_NAME));
 
-	load_modules (image, status);
+	load_modules (image);
 
 done:
+	mono_profiler_module_loaded (image, MONO_PROFILE_OK);
 	if (status)
 		*status = MONO_IMAGE_OK;
 
 	return image;
 
 invalid_image:
+	mono_profiler_module_loaded (image, MONO_PROFILE_FAILED);
 	mono_image_close (image);
 		return NULL;
 }
@@ -718,9 +880,19 @@ do_mono_image_open (const char *fname, MonoImageOpenStatus *status,
 	struct stat stat_buf;
 
 	if ((filed = fopen (fname, "rb")) == NULL){
-		if (status)
-			*status = MONO_IMAGE_ERROR_ERRNO;
-		return NULL;
+		if (IS_PORTABILITY_SET) {
+			gchar *ffname = mono_portability_find_file (fname, TRUE);
+			if (ffname) {
+				filed = fopen (ffname, "rb");
+				g_free (ffname);
+			}
+		}
+
+		if (filed == NULL) {
+			if (status)
+				*status = MONO_IMAGE_ERROR_ERRNO;
+			return NULL;
+		}
 	}
 
 	if (fstat (fileno (filed), &stat_buf)) {
@@ -730,15 +902,24 @@ do_mono_image_open (const char *fname, MonoImageOpenStatus *status,
 		return NULL;
 	}
 	image = g_new0 (MonoImage, 1);
-	image->file_descr = filed;
+	image->raw_buffer_used = TRUE;
 	image->raw_data_len = stat_buf.st_size;
-	image->raw_data = mono_raw_buffer_load (fileno (filed), FALSE, 0, stat_buf.st_size);
+	image->raw_data = mono_file_map (stat_buf.st_size, MONO_MMAP_READ|MONO_MMAP_PRIVATE, fileno (filed), 0, &image->raw_data_handle);
+	if (!image->raw_data) {
+		fclose (filed);
+		g_free (image);
+		if (status)
+			*status = MONO_IMAGE_IMAGE_INVALID;
+		return NULL;
+	}
 	iinfo = g_new0 (MonoCLIImageInfo, 1);
 	image->image_info = iinfo;
 	image->name = mono_path_resolve_symlinks (fname);
 	image->ref_only = refonly;
 	image->ref_count = 1;
 
+	fclose (filed);
+
 	return do_mono_image_load (image, status, care_about_cli);
 }
 
@@ -754,22 +935,50 @@ mono_image_loaded_full (const char *name, gboolean refonly)
 	return res;
 }
 
+/**
+ * mono_image_loaded:
+ * @name: name of the image to load
+ *
+ * This routine ensures that the given image is loaded.
+ *
+ * Returns: the loaded MonoImage, or NULL on failure.
+ */
 MonoImage *
 mono_image_loaded (const char *name)
 {
 	return mono_image_loaded_full (name, FALSE);
 }
 
+typedef struct {
+	MonoImage *res;
+	const char* guid;
+} GuidData;
+
+static void
+find_by_guid (gpointer key, gpointer val, gpointer user_data)
+{
+	GuidData *data = user_data;
+	MonoImage *image;
+
+	if (data->res)
+		return;
+	image = val;
+	if (strcmp (data->guid, mono_image_get_guid (image)) == 0)
+		data->res = image;
+}
+
 MonoImage *
 mono_image_loaded_by_guid_full (const char *guid, gboolean refonly)
 {
-	MonoImage *res;
-	GHashTable *loaded_images = refonly ? loaded_images_refonly_guid_hash : loaded_images_guid_hash;
+	GuidData data;
+	GHashTable *loaded_images = refonly ? loaded_images_refonly_hash : loaded_images_hash;
+	data.res = NULL;
+	data.guid = guid;
 
 	mono_images_lock ();
-	res = g_hash_table_lookup (loaded_images, guid);
+	g_hash_table_foreach (loaded_images, find_by_guid, &data);
 	mono_images_unlock ();
-	return res;
+	return data.res;
 }
 
 MonoImage *
@@ -797,7 +1006,6 @@ register_image (MonoImage *image)
 	g_hash_table_insert (loaded_images, image->name, image);
 	if (image->assembly_name && (g_hash_table_lookup (loaded_images, image->assembly_name) == NULL))
 		g_hash_table_insert (loaded_images, (char *) image->assembly_name, image);	
-	g_hash_table_insert (image->ref_only ? loaded_images_refonly_guid_hash : loaded_images_guid_hash, image->guid, image);
 	mono_images_unlock ();
 
 	return image;
@@ -848,6 +1056,31 @@ mono_image_open_from_data (char *data, guint32 data_len, gboolean need_copy, Mon
 	return mono_image_open_from_data_full (data, data_len, need_copy, status, FALSE);
 }
 
+#ifdef PLATFORM_WIN32
+/* fname is not duplicated. */
+MonoImage*
+mono_image_open_from_module_handle (HMODULE module_handle, char* fname, gboolean has_entry_point, MonoImageOpenStatus* status)
+{
+	MonoImage* image;
+	MonoCLIImageInfo* iinfo;
+
+	image = g_new0 (MonoImage, 1);
+	image->raw_data = (char*) module_handle;
+	image->is_module_handle = TRUE;
+	iinfo = g_new0 (MonoCLIImageInfo, 1);
+	image->image_info = iinfo;
+	image->name = fname;
+	image->ref_count = has_entry_point ? 0 : 1;
+	image->has_entry_point = has_entry_point;
+
+	image = do_mono_image_load (image, status, TRUE);
+	if (image == NULL)
+		return NULL;
+
+	return register_image (image);
+}
+#endif
+
 MonoImage *
 mono_image_open_full (const char *fname, MonoImageOpenStatus *status, gboolean refonly)
 {
@@ -857,6 +1090,72 @@ mono_image_open_full (const char *fname, MonoImageOpenStatus *status, gboolean r
 	
 	g_return_val_if_fail (fname != NULL, NULL);
 	
+#ifdef PLATFORM_WIN32
+	/* Load modules using LoadLibrary. */
+	if (!refonly && coree_module_handle) {
+		HMODULE module_handle;
+		guint16 *fname_utf16;
+		DWORD last_error;
+
+		absfname = mono_path_resolve_symlinks (fname);
+		fname_utf16 = NULL;
+
+		/* There is little overhead because the OS loader lock is held by LoadLibrary. */
+		mono_images_lock ();
+		image = g_hash_table_lookup (loaded_images_hash, absfname);
+		if (image) {
+			g_assert (image->is_module_handle);
+			if (image->has_entry_point && image->ref_count == 0) {
+				/* Increment reference count on images loaded outside of the runtime. */
+				fname_utf16 = g_utf8_to_utf16 (absfname, -1, NULL, NULL, NULL);
+				/* The image is already loaded because _CorDllMain removes images from the hash. */
+				module_handle = LoadLibrary (fname_utf16);
+				g_assert (module_handle == (HMODULE) image->raw_data);
+			}
+			mono_image_addref (image);
+			mono_images_unlock ();
+			if (fname_utf16)
+				g_free (fname_utf16);
+			g_free (absfname);
+			return image;
+		}
+
+		fname_utf16 = g_utf8_to_utf16 (absfname, -1, NULL, NULL, NULL);
+		module_handle = MonoLoadImage (fname_utf16);
+		if (status && module_handle == NULL)
+			last_error = GetLastError ();
+
+		/* mono_image_open_from_module_handle is called by _CorDllMain. */
+		image = g_hash_table_lookup (loaded_images_hash, absfname);
+		if (image)
+			mono_image_addref (image);
+		mono_images_unlock ();
+
+		g_free (fname_utf16);
+
+		if (module_handle == NULL) {
+			g_assert (!image);
+			g_free (absfname);
+			if (status) {
+				if (last_error == ERROR_BAD_EXE_FORMAT || last_error == STATUS_INVALID_IMAGE_FORMAT)
+					*status = MONO_IMAGE_IMAGE_INVALID;
+				else
+					*status = MONO_IMAGE_ERROR_ERRNO;
+			}
+			return NULL;
+		}
+
+		if (image) {
+			g_assert (image->is_module_handle);
+			g_assert (image->has_entry_point);
+			g_free (absfname);
+			return image;
+		}
+
+		return mono_image_open_from_module_handle (module_handle, absfname, FALSE, status);
+	}
+#endif
+
 	absfname = mono_path_canonicalize (fname);
 
 	/*
@@ -919,6 +1218,57 @@ mono_pe_file_open (const char *fname, MonoImageOpenStatus *status)
 	return(do_mono_image_open (fname, status, FALSE, FALSE));
 }
 
+void
+mono_image_fixup_vtable (MonoImage *image)
+{
+#ifdef PLATFORM_WIN32
+	MonoCLIImageInfo *iinfo;
+	MonoPEDirEntry *de;
+	MonoVTableFixup *vtfixup;
+	int count;
+	gpointer slot;
+	guint16 slot_type;
+	int slot_count;
+
+	g_assert (image->is_module_handle);
+
+	iinfo = image->image_info;
+	de = &iinfo->cli_cli_header.ch_vtable_fixups;
+	if (!de->rva || !de->size)
+		return;
+	vtfixup = (MonoVTableFixup*) mono_image_rva_map (image, de->rva);
+	if (!vtfixup)
+		return;
+	
+	count = de->size / sizeof (MonoVTableFixup);
+	while (count--) {
+		if (!vtfixup->rva || !vtfixup->count)
+			continue;
+
+		slot = mono_image_rva_map (image, vtfixup->rva);
+		g_assert (slot);
+		slot_type = vtfixup->type;
+		slot_count = vtfixup->count;
+		if (slot_type & VTFIXUP_TYPE_32BIT)
+			while (slot_count--) {
+				*((guint32*) slot) = (guint32) mono_marshal_get_vtfixup_ftnptr (image, *((guint32*) slot), slot_type);
+				((guint32*) slot)++;
+			}
+		else if (slot_type & VTFIXUP_TYPE_64BIT)
+			while (slot_count--) {
+				*((guint64*) slot) = (guint64) mono_marshal_get_vtfixup_ftnptr (image, *((guint64*) slot), slot_type);
+				((guint64*) slot)++;
+			}
+		else
+			g_assert_not_reached();
+
+		vtfixup++;
+	}
+#else
+	g_assert_not_reached();
+#endif
+}
+
 static void
 free_hash_table (gpointer key, gpointer val, gpointer user_data)
 {
@@ -933,12 +1283,6 @@ free_mr_signatures (gpointer key, gpointer val, gpointer user_data)
 }
 */
 
-static void
-free_blob_cache_entry (gpointer key, gpointer val, gpointer user_data)
-{
-	g_free (key);
-}
-
 static void
 free_remoting_wrappers (gpointer key, gpointer val, gpointer user_data)
 {
@@ -975,6 +1319,13 @@ mono_dynamic_stream_reset (MonoDynamicStream* stream)
 	}
 }
 
+static inline void
+free_hash (GHashTable *hash)
+{
+	if (hash)
+		g_hash_table_destroy (hash);
+}
+
 /**
  * mono_image_close:
  * @image: The image file we wish to close
@@ -986,7 +1337,7 @@ void
 mono_image_close (MonoImage *image)
 {
 	MonoImage *image2;
-	GHashTable *loaded_images, *loaded_images_guid;
+	GHashTable *loaded_images;
 	int i;
 
 	g_return_if_fail (image != NULL);
@@ -994,33 +1345,66 @@ mono_image_close (MonoImage *image)
 	if (InterlockedDecrement (&image->ref_count) > 0)
 		return;
 
+#ifdef PLATFORM_WIN32
+	if (image->is_module_handle && image->has_entry_point) {
+		mono_images_lock ();
+		if (image->ref_count == 0) {
+			/* Image will be closed by _CorDllMain. */
+			FreeLibrary ((HMODULE) image->raw_data);
+			mono_images_unlock ();
+			return;
+		}
+		mono_images_unlock ();
+	}
+#endif
+
+	mono_profiler_module_event (image, MONO_PROFILE_START_UNLOAD);
+
 	mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Unloading image %s [%p].", image->name, image);
-	
+
+	mono_metadata_clean_for_image (image);
+
+	/*
+	 * The caches inside a MonoImage might refer to metadata which is stored in referenced 
+	 * assemblies, so we can't release these references in mono_assembly_close () since the
+	 * MonoImage might outlive its associated MonoAssembly.
+	 */
+	if (image->references) {
+		int i;
+
+		for (i = 0; image->references [i]; i++) {
+			if (image->references [i])
+				mono_assembly_close (image->references [i]);
+		}
+
+		g_free (image->references);
+		image->references = NULL;
+	}
+
 	mono_images_lock ();
 	loaded_images = image->ref_only ? loaded_images_refonly_hash : loaded_images_hash;
-	loaded_images_guid = image->ref_only ? loaded_images_refonly_guid_hash : loaded_images_guid_hash;
 	image2 = g_hash_table_lookup (loaded_images, image->name);
 	if (image == image2) {
 		/* This is not true if we are called from mono_image_open () */
 		g_hash_table_remove (loaded_images, image->name);
-		g_hash_table_remove (loaded_images_guid, image->guid);
 	}
 	if (image->assembly_name && (g_hash_table_lookup (loaded_images, image->assembly_name) == image))
 		g_hash_table_remove (loaded_images, (char *) image->assembly_name);	
 
-	/* Multiple images might have the same guid */
-	build_guid_table (image->ref_only);
+#ifdef PLATFORM_WIN32
+	if (image->is_module_handle && !image->has_entry_point)
+		FreeLibrary ((HMODULE) image->raw_data);
+#endif
 
 	mono_images_unlock ();
 
-	if (image->file_descr) {
-		fclose (image->file_descr);
-		image->file_descr = NULL;
+	if (image->raw_buffer_used) {
 		if (image->raw_data != NULL)
-			mono_raw_buffer_free (image->raw_data);
+			mono_file_unmap (image->raw_data, image->raw_data_handle);
 	}
 	
 	if (image->raw_data_allocated) {
+		/* FIXME: do we need this? (image is disposed anyway) */
 		/* image->raw_metadata and cli_sections might lie inside image->raw_data */
 		MonoCLIImageInfo *ii = image->image_info;
 
@@ -1045,8 +1429,11 @@ mono_image_close (MonoImage *image)
 		g_free (image->files);
 	}
 
-	g_hash_table_destroy (image->method_cache);
-	g_hash_table_destroy (image->class_cache);
+	if (image->method_cache)
+		mono_value_hash_table_destroy (image->method_cache);
+	if (image->methodref_cache)
+		g_hash_table_destroy (image->methodref_cache);
+	mono_internal_hash_table_destroy (&image->class_cache);
 	g_hash_table_destroy (image->field_cache);
 	if (image->array_cache) {
 		g_hash_table_foreach (image->array_cache, free_array_cache_entry, NULL);
@@ -1058,27 +1445,31 @@ mono_image_close (MonoImage *image)
 		g_hash_table_foreach (image->name_cache, free_hash_table, NULL);
 		g_hash_table_destroy (image->name_cache);
 	}
-	g_hash_table_destroy (image->native_wrapper_cache);
-	g_hash_table_destroy (image->managed_wrapper_cache);
-	g_hash_table_destroy (image->delegate_begin_invoke_cache);
-	g_hash_table_destroy (image->delegate_end_invoke_cache);
-	g_hash_table_destroy (image->delegate_invoke_cache);
-	g_hash_table_foreach (image->remoting_invoke_cache, free_remoting_wrappers, NULL);
-	g_hash_table_destroy (image->remoting_invoke_cache);
-	g_hash_table_destroy (image->runtime_invoke_cache);
-	g_hash_table_destroy (image->synchronized_cache);
-	g_hash_table_destroy (image->unbox_wrapper_cache);
-	g_hash_table_destroy (image->cominterop_invoke_cache);
-	g_hash_table_destroy (image->cominterop_wrapper_cache);
-	g_hash_table_destroy (image->typespec_cache);
-	g_hash_table_destroy (image->ldfld_wrapper_cache);
-	g_hash_table_destroy (image->ldflda_wrapper_cache);
-	g_hash_table_destroy (image->ldfld_remote_wrapper_cache);
-	g_hash_table_destroy (image->stfld_wrapper_cache);
-	g_hash_table_destroy (image->stfld_remote_wrapper_cache);
-	g_hash_table_destroy (image->isinst_cache);
-	g_hash_table_destroy (image->castclass_cache);
-	g_hash_table_destroy (image->proxy_isinst_cache);
+
+	free_hash (image->native_wrapper_cache);
+	free_hash (image->managed_wrapper_cache);
+	free_hash (image->delegate_begin_invoke_cache);
+	free_hash (image->delegate_end_invoke_cache);
+	free_hash (image->delegate_invoke_cache);
+	free_hash (image->delegate_abstract_invoke_cache);
+	if (image->remoting_invoke_cache)
+		g_hash_table_foreach (image->remoting_invoke_cache, free_remoting_wrappers, NULL);
+	free_hash (image->remoting_invoke_cache);
+	free_hash (image->runtime_invoke_cache);
+	free_hash (image->runtime_invoke_direct_cache);
+	free_hash (image->synchronized_cache);
+	free_hash (image->unbox_wrapper_cache);
+	free_hash (image->cominterop_invoke_cache);
+	free_hash (image->cominterop_wrapper_cache);
+	free_hash (image->typespec_cache);
+	free_hash (image->ldfld_wrapper_cache);
+	free_hash (image->ldflda_wrapper_cache);
+	free_hash (image->stfld_wrapper_cache);
+	free_hash (image->isinst_cache);
+	free_hash (image->castclass_cache);
+	free_hash (image->proxy_isinst_cache);
+	free_hash (image->thunk_invoke_cache);
+	free_hash (image->static_rgctx_invoke_cache);
 
 	/* The ownership of signatures is not well defined */
 	//g_hash_table_foreach (image->memberref_signatures, free_mr_signatures, NULL);
@@ -1087,6 +1478,15 @@ mono_image_close (MonoImage *image)
 	g_hash_table_destroy (image->helper_signatures);
 	g_hash_table_destroy (image->method_signatures);
 
+	if (image->generic_class_cache)
+		g_hash_table_destroy (image->generic_class_cache);
+
+	if (image->rgctx_template_hash)
+		g_hash_table_destroy (image->rgctx_template_hash);
+
+	if (image->property_hash)
+		mono_property_hash_destroy (image->property_hash);
+
 	if (image->interface_bitset) {
 		mono_unload_interface_ids (image->interface_bitset);
 		mono_bitset_free (image->interface_bitset);
@@ -1107,8 +1507,11 @@ mono_image_close (MonoImage *image)
 	}
 	if (image->modules)
 		g_free (image->modules);
+	if (image->modules_loaded)
+		g_free (image->modules_loaded);
 	if (image->references)
 		g_free (image->references);
+	mono_perfcounters->loader_bytes -= mono_mempool_get_allocated (image->mempool);
 	/*g_print ("destroy image %p (dynamic: %d)\n", image, image->dynamic);*/
 	if (!image->dynamic) {
 		if (debug_assembly_unload)
@@ -1119,47 +1522,12 @@ mono_image_close (MonoImage *image)
 		}
 	} else {
 		/* Dynamic images are GC_MALLOCed */
-		struct _MonoDynamicImage *di = (struct _MonoDynamicImage*)image;
-		int i;
 		g_free ((char*)image->module_name);
-		if (di->typespec)
-			g_hash_table_destroy (di->typespec);
-		if (di->typeref)
-			g_hash_table_destroy (di->typeref);
-		if (di->handleref)
-			g_hash_table_destroy (di->handleref);
-		if (di->tokens)
-			mono_g_hash_table_destroy (di->tokens);
-		if (di->blob_cache) {
-			g_hash_table_foreach (di->blob_cache, free_blob_cache_entry, NULL);
-			g_hash_table_destroy (di->blob_cache);
-		}
-		g_list_free (di->array_methods);
-		if (di->gen_params)
-			g_ptr_array_free (di->gen_params, TRUE);
-		if (di->token_fixups)
-			mono_g_hash_table_destroy (di->token_fixups);
-		if (di->method_to_table_idx)
-			g_hash_table_destroy (di->method_to_table_idx);
-		if (di->field_to_table_idx)
-			g_hash_table_destroy (di->field_to_table_idx);
-		if (di->method_aux_hash)
-			g_hash_table_destroy (di->method_aux_hash);
-		g_free (di->strong_name);
-		g_free (di->win32_res);
-		/*g_print ("string heap destroy for image %p\n", di);*/
-		mono_dynamic_stream_reset (&di->sheap);
-		mono_dynamic_stream_reset (&di->code);
-		mono_dynamic_stream_reset (&di->resources);
-		mono_dynamic_stream_reset (&di->us);
-		mono_dynamic_stream_reset (&di->blob);
-		mono_dynamic_stream_reset (&di->tstream);
-		mono_dynamic_stream_reset (&di->guid);
-		for (i = 0; i < MONO_TABLE_NUM; ++i) {
-			g_free (di->tables [i].values);
-		}
+		mono_dynamic_image_free ((MonoDynamicImage*)image);
 		mono_mempool_destroy (image->mempool);
 	}
+
+	mono_profiler_module_event (image, MONO_PROFILE_END_UNLOAD);
 }
 
 /** 
@@ -1190,7 +1558,8 @@ mono_image_walk_resource_tree (MonoCLIImageInfo *info, guint32 res_id,
 			       MonoPEResourceDirEntry *entry,
 			       MonoPEResourceDir *root, guint32 level)
 {
-	gboolean is_string=entry->name_is_string;
+	gboolean is_string, is_dir;
+	guint32 name_offset, dir_offset;
 
 	/* Level 0 holds a directory entry for each type of resource
 	 * (identified by ID or name).
@@ -1202,22 +1571,27 @@ mono_image_walk_resource_tree (MonoCLIImageInfo *info, guint32 res_id,
 	 * Level 2 holds a directory entry for each language pointing to
 	 * the actual data.
 	 */
+	is_string = MONO_PE_RES_DIR_ENTRY_NAME_IS_STRING (*entry);
+	name_offset = MONO_PE_RES_DIR_ENTRY_NAME_OFFSET (*entry);
+
+	is_dir = MONO_PE_RES_DIR_ENTRY_IS_DIR (*entry);
+	dir_offset = MONO_PE_RES_DIR_ENTRY_DIR_OFFSET (*entry);
 
 	if(level==0) {
-		if((is_string==FALSE && entry->name_offset!=res_id) ||
+		if((is_string==FALSE && name_offset!=res_id) ||
 		   (is_string==TRUE)) {
 			return(NULL);
 		}
 	} else if (level==1) {
 #if 0
 		if(name!=NULL &&
-		   is_string==TRUE && name!=lookup (entry->name_offset)) {
+		   is_string==TRUE && name!=lookup (name_offset)) {
 			return(NULL);
 		}
 #endif
 	} else if (level==2) {
 		if ((is_string == FALSE &&
-		    entry->name_offset != lang_id &&
+		    name_offset != lang_id &&
 		    lang_id != 0) ||
 		   (is_string == TRUE)) {
 			return(NULL);
@@ -1226,12 +1600,12 @@ mono_image_walk_resource_tree (MonoCLIImageInfo *info, guint32 res_id,
 		g_assert_not_reached ();
 	}
 
-	if(entry->is_dir==TRUE) {
-		MonoPEResourceDir *res_dir=(MonoPEResourceDir *)(((char *)root)+entry->dir_offset);
+	if(is_dir==TRUE) {
+		MonoPEResourceDir *res_dir=(MonoPEResourceDir *)(((char *)root)+dir_offset);
 		MonoPEResourceDirEntry *sub_entries=(MonoPEResourceDirEntry *)(res_dir+1);
 		guint32 entries, i;
-		
-		entries=res_dir->res_named_entries + res_dir->res_id_entries;
+
+		entries = GUINT16_FROM_LE (res_dir->res_named_entries) + GUINT16_FROM_LE (res_dir->res_id_entries);
 
 		for(i=0; i<entries; i++) {
 			MonoPEResourceDirEntry *sub_entry=&sub_entries[i];
@@ -1248,9 +1622,17 @@ mono_image_walk_resource_tree (MonoCLIImageInfo *info, guint32 res_id,
 
 		return(NULL);
 	} else {
-		MonoPEResourceDataEntry *data_entry=(MonoPEResourceDataEntry *)((char *)(root)+entry->dir_offset);
-		
-		return(data_entry);
+		MonoPEResourceDataEntry *data_entry=(MonoPEResourceDataEntry *)((char *)(root)+dir_offset);
+		MonoPEResourceDataEntry *res;
+
+		res = g_new0 (MonoPEResourceDataEntry, 1);
+
+		res->rde_data_offset = GUINT32_TO_LE (data_entry->rde_data_offset);
+		res->rde_size = GUINT32_TO_LE (data_entry->rde_size);
+		res->rde_codepage = GUINT32_TO_LE (data_entry->rde_codepage);
+		res->rde_reserved = GUINT32_TO_LE (data_entry->rde_reserved);
+
+		return (res);
 	}
 }
 
@@ -1262,7 +1644,8 @@ mono_image_walk_resource_tree (MonoCLIImageInfo *info, guint32 res_id,
  * @name: the resource name to lookup.
  *
  * Returns: NULL if not found, otherwise a pointer to the in-memory representation
- * of the given resource.
+ * of the given resource. The caller should free it using g_free () when no longer
+ * needed.
  */
 gpointer
 mono_image_lookup_resource (MonoImage *image, guint32 res_id, guint32 lang_id, gunichar2 *name)
@@ -1303,8 +1686,8 @@ mono_image_lookup_resource (MonoImage *image, guint32 res_id, guint32 lang_id, g
 	if(resource_dir==NULL) {
 		return(NULL);
 	}
-	
-	entries=resource_dir->res_named_entries + resource_dir->res_id_entries;
+
+	entries = GUINT16_FROM_LE (resource_dir->res_named_entries) + GUINT16_FROM_LE (resource_dir->res_id_entries);
 	res_entries=(MonoPEResourceDirEntry *)(resource_dir+1);
 	
 	for(i=0; i<entries; i++) {
@@ -1381,8 +1764,11 @@ mono_image_load_file_for_image (MonoImage *image, int fileidx)
 	if (fileidx < 1 || fileidx > t->rows)
 		return NULL;
 
-	if (image->files && image->files [fileidx - 1])
+	mono_loader_lock ();
+	if (image->files && image->files [fileidx - 1]) {
+		mono_loader_unlock ();
 		return image->files [fileidx - 1];
+	}
 
 	if (!image->files)
 		image->files = g_new0 (MonoImage*, t->rows);
@@ -1402,12 +1788,28 @@ mono_image_load_file_for_image (MonoImage *image, int fileidx)
 		}
 
 		image->files [fileidx - 1] = res;
+#ifdef PLATFORM_WIN32
+		if (res->is_module_handle)
+			mono_image_fixup_vtable (res);
+#endif
 	}
+	mono_loader_unlock ();
 	g_free (name);
 	g_free (base_dir);
 	return res;
 }
 
+/**
+ * mono_image_get_strong_name:
+ * @image: a MonoImage
+ * @size: a guint32 pointer, or NULL.
+ *
+ * If the image has a strong name, and @size is not NULL, the value
+ * pointed to by size will have the size of the strong name.
+ *
+ * Returns: NULL if the image does not have a strong name, or a
+ * pointer to the public key.
+ */
 const char*
 mono_image_get_strong_name (MonoImage *image, guint32 *size)
 {
@@ -1425,37 +1827,56 @@ mono_image_get_strong_name (MonoImage *image, guint32 *size)
 	return data;
 }
 
+/**
+ * mono_image_strong_name_position:
+ * @image: a MonoImage
+ * @size: a guint32 pointer, or NULL.
+ *
+ * If the image has a strong name, and @size is not NULL, the value
+ * pointed to by size will have the size of the strong name.
+ *
+ * Returns: the position within the image file where the strong name
+ * is stored.
+ */
 guint32
 mono_image_strong_name_position (MonoImage *image, guint32 *size)
 {
 	MonoCLIImageInfo *iinfo = image->image_info;
 	MonoPEDirEntry *de = &iinfo->cli_cli_header.ch_strong_name;
-	const int top = iinfo->cli_section_count;
-	MonoSectionTable *tables = iinfo->cli_section_tables;
-	int i;
-	guint32 addr = de->rva;
-	
+	guint32 pos;
+
 	if (size)
 		*size = de->size;
 	if (!de->size || !de->rva)
 		return 0;
-	for (i = 0; i < top; i++){
-		if ((addr >= tables->st_virtual_address) &&
-		    (addr < tables->st_virtual_address + tables->st_raw_data_size)){
-			return tables->st_raw_data_ptr +
-				(addr - tables->st_virtual_address);
-		}
-		tables++;
-	}
-
-	return 0;
+	pos = mono_cli_rva_image_map (image, de->rva);
+	return pos == INVALID_ADDRESS ? 0 : pos;
 }
 
+/**
+ * mono_image_get_public_key:
+ * @image: a MonoImage
+ * @size: a guint32 pointer, or NULL.
+ *
+ * This is used to obtain the public key in the @image.
+ * 
+ * If the image has a public key, and @size is not NULL, the value
+ * pointed to by size will have the size of the public key.
+ * 
+ * Returns: NULL if the image does not have a public key, or a pointer
+ * to the public key.
+ */
 const char*
 mono_image_get_public_key (MonoImage *image, guint32 *size)
 {
 	const char *pubkey;
 	guint32 len, tok;
+
+	if (image->dynamic) {
+		if (size)
+			*size = ((MonoDynamicImage*)image)->public_key_len;
+		return (char*)((MonoDynamicImage*)image)->public_key;
+	}
 	if (image->tables [MONO_TABLE_ASSEMBLY].rows != 1)
 		return NULL;
 	tok = mono_metadata_decode_row_col (&image->tables [MONO_TABLE_ASSEMBLY], 0, MONO_ASSEMBLY_PUBLIC_KEY);
@@ -1468,12 +1889,26 @@ mono_image_get_public_key (MonoImage *image, guint32 *size)
 	return pubkey;
 }
 
+/**
+ * mono_image_get_name:
+ * @name: a MonoImage
+ *
+ * Returns: the name of the assembly.
+ */
 const char*
 mono_image_get_name (MonoImage *image)
 {
 	return image->assembly_name;
 }
 
+/**
+ * mono_image_get_filename:
+ * @image: a MonoImage
+ *
+ * Used to get the filename that hold the actual MonoImage
+ *
+ * Returns: the filename.
+ */
 const char*
 mono_image_get_filename (MonoImage *image)
 {
@@ -1508,18 +1943,45 @@ mono_table_info_get_rows (const MonoTableInfo *table)
 	return table->rows;
 }
 
+/**
+ * mono_image_get_assembly:
+ * @image: the MonoImage.
+ *
+ * Use this routine to get the assembly that owns this image.
+ *
+ * Returns: the assembly that holds this image.
+ */
 MonoAssembly* 
 mono_image_get_assembly (MonoImage *image)
 {
 	return image->assembly;
 }
 
+/**
+ * mono_image_is_dynamic:
+ * @image: the MonoImage
+ *
+ * Determines if the given image was created dynamically through the
+ * System.Reflection.Emit API
+ *
+ * Returns: TRUE if the image was created dynamically, FALSE if not.
+ */
 gboolean
 mono_image_is_dynamic (MonoImage *image)
 {
 	return image->dynamic;
 }
 
+/**
+ * mono_image_has_authenticode_entry:
+ * @image: the MonoImage
+ *
+ * Use this routine to determine if the image has a Authenticode
+ * Certificate Table.
+ *
+ * Returns: TRUE if the image contains an authenticode entry in the PE
+ * directory.
+ */
 gboolean
 mono_image_has_authenticode_entry (MonoImage *image)
 {
@@ -1529,3 +1991,25 @@ mono_image_has_authenticode_entry (MonoImage *image)
 	// the Authenticode "pre" (non ASN.1) header is 8 bytes long
 	return ((de->rva != 0) && (de->size > 8));
 }
+
+gpointer
+mono_image_alloc (MonoImage *image, guint size)
+{
+	mono_perfcounters->loader_bytes += size;
+	return mono_mempool_alloc (image->mempool, size);
+}
+
+gpointer
+mono_image_alloc0 (MonoImage *image, guint size)
+{
+	mono_perfcounters->loader_bytes += size;
+	return mono_mempool_alloc0 (image->mempool, size);
+}
+
+char*
+mono_image_strdup (MonoImage *image, const char *s)
+{
+	mono_perfcounters->loader_bytes += strlen (s);
+	return mono_mempool_strdup (image->mempool, s);
+}
+