gpointer user_data;
};
-GSList *image_unload_hooks;
+static GSList *image_unload_hooks;
void
mono_install_image_unload_hook (MonoImageUnloadFunc func, gpointer user_data)
const int top = iinfo->cli_section_count;
MonoSectionTable *tables = iinfo->cli_section_tables;
int i;
-
+
+ if (image->metadata_only)
+ return addr;
+
for (i = 0; i < top; i++){
if ((addr >= tables->st_virtual_address) &&
(addr < tables->st_virtual_address + tables->st_raw_data_size)){
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 if (strncmp (ptr + 8, "#Pdb", 5) == 0) {
+ image->heap_pdb.data = image->raw_metadata + read32 (ptr);
+ image->heap_pdb.size = read32 (ptr + 4);
+ ptr += 8 + 5;
} else {
g_message ("Unknown heap type: %s\n", ptr + 8);
ptr += 8 + strlen (ptr + 8) + 1;
continue;
}
if (table > MONO_TABLE_LAST) {
- g_warning("bits in valid must be zero above 0x2d (II - 23.1.6)");
+ g_warning("bits in valid must be zero above 0x37 (II - 23.1.6)");
} else {
image->tables [table].rows = read32 (rows);
}
g_direct_hash,
class_key_extract,
class_next_value);
- image->field_cache = mono_conc_hashtable_new (&image->lock, NULL, NULL);
+ image->field_cache = mono_conc_hashtable_new (NULL, NULL);
image->typespec_cache = g_hash_table_new (NULL, NULL);
image->memberref_signatures = g_hash_table_new (NULL, NULL);
0, MONO_ASSEMBLY_NAME));
}
- image->module_name = mono_metadata_string_heap (image,
+ /* Portable pdb images don't have a MODULE row */
+ if (image->tables [MONO_TABLE_MODULE].rows) {
+ image->module_name = mono_metadata_string_heap (image,
mono_metadata_decode_row_col (&image->tables [MONO_TABLE_MODULE],
0, MONO_MODULE_NAME));
+ }
}
static MonoImage *
if (care_about_pecoff == FALSE)
goto done;
- if (!mono_verifier_verify_pe_data (image, &errors))
- goto invalid_image;
+ if (!image->metadata_only) {
+ if (!mono_verifier_verify_pe_data (image, &errors))
+ goto invalid_image;
+
+ if (!mono_image_load_pe_data (image))
+ goto invalid_image;
+ }
- if (!mono_image_load_pe_data (image))
- goto invalid_image;
-
if (care_about_cli == FALSE) {
goto done;
}
static MonoImage *
do_mono_image_open (const char *fname, MonoImageOpenStatus *status,
- gboolean care_about_cli, gboolean care_about_pecoff, gboolean refonly)
+ gboolean care_about_cli, gboolean care_about_pecoff, gboolean refonly, gboolean metadata_only)
{
MonoCLIImageInfo *iinfo;
MonoImage *image;
image->image_info = iinfo;
image->name = mono_path_resolve_symlinks (fname);
image->ref_only = refonly;
+ image->metadata_only = metadata_only;
image->ref_count = 1;
/* if MONO_SECURITY_MODE_CORE_CLR is set then determine if this image is platform code */
image->core_clr_platform_code = mono_security_core_clr_determine_platform_image (image);
}
MonoImage *
-mono_image_open_from_data_with_name (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, const char *name)
+mono_image_open_from_data_internal (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, gboolean metadata_only, const char *name)
{
MonoCLIImageInfo *iinfo;
MonoImage *image;
iinfo = g_new0 (MonoCLIImageInfo, 1);
image->image_info = iinfo;
image->ref_only = refonly;
+ image->metadata_only = metadata_only;
image = do_mono_image_load (image, status, TRUE, TRUE);
if (image == NULL)
return register_image (image);
}
+MonoImage *
+mono_image_open_from_data_with_name (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, const char *name)
+{
+ return mono_image_open_from_data_internal (data, data_len, need_copy, status, refonly, FALSE, name);
+}
+
MonoImage *
mono_image_open_from_data_full (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly)
{
}
mono_images_unlock ();
- image = do_mono_image_open (fname, status, TRUE, TRUE, refonly);
+ image = do_mono_image_open (fname, status, TRUE, TRUE, refonly, FALSE);
if (image == NULL)
return NULL;
{
g_return_val_if_fail (fname != NULL, NULL);
- return(do_mono_image_open (fname, status, FALSE, TRUE, FALSE));
+ return do_mono_image_open (fname, status, FALSE, TRUE, FALSE, FALSE);
}
/**
{
g_return_val_if_fail (fname != NULL, NULL);
- return(do_mono_image_open (fname, status, FALSE, FALSE, FALSE));
+ return do_mono_image_open (fname, status, FALSE, FALSE, FALSE, FALSE);
+}
+
+/*
+ * mono_image_open_metadata_only:
+ *
+ * Open an image which contains metadata only without a PE header.
+ */
+MonoImage *
+mono_image_open_metadata_only (const char *fname, MonoImageOpenStatus *status)
+{
+ return do_mono_image_open (fname, status, TRUE, TRUE, FALSE, TRUE);
}
void
g_hash_table_destroy (hash);
}
+void
+mono_wrapper_caches_free (MonoWrapperCaches *cache)
+{
+ free_hash (cache->delegate_invoke_cache);
+ free_hash (cache->delegate_begin_invoke_cache);
+ free_hash (cache->delegate_end_invoke_cache);
+ free_hash (cache->runtime_invoke_cache);
+ free_hash (cache->runtime_invoke_vtype_cache);
+
+ free_hash (cache->delegate_abstract_invoke_cache);
+
+ free_hash (cache->runtime_invoke_direct_cache);
+ free_hash (cache->managed_wrapper_cache);
+
+ free_hash (cache->native_wrapper_cache);
+ free_hash (cache->native_wrapper_aot_cache);
+ free_hash (cache->native_wrapper_check_cache);
+ free_hash (cache->native_wrapper_aot_check_cache);
+
+ free_hash (cache->native_func_wrapper_aot_cache);
+ free_hash (cache->remoting_invoke_cache);
+ free_hash (cache->synchronized_cache);
+ free_hash (cache->unbox_wrapper_cache);
+ free_hash (cache->cominterop_invoke_cache);
+ free_hash (cache->cominterop_wrapper_cache);
+ free_hash (cache->thunk_invoke_cache);
+}
+
/*
* Returns whether mono_image_close_finish() must be called as well.
* We must unload images in two steps because clearing the domain in
g_hash_table_destroy (image->name_cache);
}
- free_hash (image->native_wrapper_cache);
- free_hash (image->native_wrapper_aot_cache);
- free_hash (image->native_wrapper_check_cache);
- free_hash (image->native_wrapper_aot_check_cache);
- free_hash (image->native_func_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);
free_hash (image->delegate_bound_static_invoke_cache);
- free_hash (image->delegate_invoke_generic_cache);
- free_hash (image->delegate_begin_invoke_generic_cache);
- free_hash (image->delegate_end_invoke_generic_cache);
- free_hash (image->synchronized_generic_cache);
- free_hash (image->remoting_invoke_cache);
- free_hash (image->runtime_invoke_cache);
- free_hash (image->runtime_invoke_vtype_cache);
- free_hash (image->runtime_invoke_direct_cache);
free_hash (image->runtime_invoke_vcall_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->var_cache_slow);
free_hash (image->mvar_cache_slow);
free_hash (image->var_cache_constrained);
free_hash (image->wrapper_param_names);
free_hash (image->pinvoke_scopes);
free_hash (image->pinvoke_scope_filenames);
+ free_hash (image->native_func_wrapper_cache);
+ free_hash (image->typespec_cache);
+
+ mono_wrapper_caches_free (&image->wrapper_caches);
+
for (i = 0; i < image->gshared_types_len; ++i)
free_hash (image->gshared_types [i]);
g_free (image->gshared_types);
mono_image_unlock (image);
return image->files [fileidx - 1];
}
+ mono_image_unlock (image);
fname_id = mono_metadata_decode_row_col (t, fileidx - 1, MONO_FILE_NAME);
fname = mono_metadata_string_heap (image, fname_id);
if (image->files && image->files [fileidx - 1]) {
MonoImage *old = res;
res = image->files [fileidx - 1];
- mono_loader_unlock ();
+ mono_image_unlock (image);
mono_image_close (old);
} else {
int i;
if (!image->files)
image->files = g_new0 (MonoImage*, t->rows);
image->files [fileidx - 1] = res;
- mono_loader_unlock ();
+ mono_image_unlock (image);
/* vtable fixup can't happen with the image lock held */
#ifdef HOST_WIN32
if (res->is_module_handle)