* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
*
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
*/
#include <config.h>
#include <stdio.h>
ImageUnloadHook *hook;
for (l = image_unload_hooks; l; l = l->next) {
- hook = l->data;
+ hook = (ImageUnloadHook *)l->data;
if (hook->func == func && hook->user_data == user_data) {
g_free (hook);
ImageUnloadHook *hook;
for (l = image_unload_hooks; l; l = l->next) {
- hook = l->data;
+ hook = (ImageUnloadHook *)l->data;
hook->func (image, hook->user_data);
}
guint32
mono_cli_rva_image_map (MonoImage *image, guint32 addr)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
const int top = iinfo->cli_section_count;
MonoSectionTable *tables = iinfo->cli_section_tables;
int i;
char *
mono_image_rva_map (MonoImage *image, guint32 addr)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
const int top = iinfo->cli_section_count;
MonoSectionTable *tables = iinfo->cli_section_tables;
int i;
int
mono_image_ensure_section_idx (MonoImage *image, int section)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoSectionTable *sect;
g_return_val_if_fail (section < iinfo->cli_section_count, FALSE);
int
mono_image_ensure_section (MonoImage *image, const char *section)
{
- MonoCLIImageInfo *ii = image->image_info;
+ MonoCLIImageInfo *ii = (MonoCLIImageInfo *)image->image_info;
int i;
for (i = 0; i < ii->cli_section_count; i++){
i = ((MonoImageLoader*)image->loader)->load_tables (image);
g_assert (image->heap_guid.data);
- g_assert (image->heap_guid.size >= 16);
- image->guid = mono_guid_to_string ((guint8*)image->heap_guid.data);
+ if (!image->metadata_only) {
+ g_assert (image->heap_guid.size >= 16);
+
+ image->guid = mono_guid_to_string ((guint8*)image->heap_guid.data);
+ } else {
+ /* PPDB files have no guid */
+ guint8 empty_guid [16];
+
+ memset (empty_guid, 0, sizeof (empty_guid));
+
+ image->guid = mono_guid_to_string (empty_guid);
+ }
return i;
}
static gpointer
class_key_extract (gpointer value)
{
- MonoClass *klass = value;
+ MonoClass *klass = (MonoClass *)value;
return GUINT_TO_POINTER (klass->type_token);
}
static gpointer*
class_next_value (gpointer value)
{
- MonoClass *klass = value;
+ MonoClass *klass = (MonoClass *)value;
return (gpointer*)&klass->next_class_cache;
}
MonoMSDOSHeader msdos;
gint32 offset = 0;
- iinfo = image->image_info;
+ iinfo = (MonoCLIImageInfo *)image->image_info;
header = &iinfo->cli_header;
#ifdef HOST_WIN32
MonoCLIImageInfo *iinfo;
MonoDotNetHeader *header;
- iinfo = image->image_info;
+ iinfo = (MonoCLIImageInfo *)image->image_info;
header = &iinfo->cli_header;
/* Load the CLI header */
mono_image_init (image);
- iinfo = image->image_info;
+ iinfo = (MonoCLIImageInfo *)image->image_info;
header = &iinfo->cli_header;
if (!image->metadata_only) {
for (l = image_loaders; l; l = l->next) {
- MonoImageLoader *loader = l->data;
+ MonoImageLoader *loader = (MonoImageLoader *)l->data;
if (loader->match (image)) {
image->loader = loader;
break;
}
}
if (!image->loader) {
- *status = MONO_IMAGE_IMAGE_INVALID;
+ if (status)
+ *status = MONO_IMAGE_IMAGE_INVALID;
goto invalid_image;
}
goto done;
}
- if (image->loader == &pe_loader && !mono_verifier_verify_cli_data (image, &errors))
+ if (image->loader == &pe_loader && !image->metadata_only && !mono_verifier_verify_cli_data (image, &errors))
goto invalid_image;
if (!mono_image_load_cli_data (image))
goto invalid_image;
- if (image->loader == &pe_loader && !mono_verifier_verify_table_data (image, &errors))
+ if (image->loader == &pe_loader && !image->metadata_only && !mono_verifier_verify_table_data (image, &errors))
goto invalid_image;
mono_image_load_names (image);
invalid_image:
if (errors) {
- MonoVerifyInfo *info = errors->data;
+ MonoVerifyInfo *info = (MonoVerifyInfo *)errors->data;
g_warning ("Could not load image %s due to %s", image->name, info->message);
mono_free_verify_list (errors);
}
image = g_new0 (MonoImage, 1);
image->raw_buffer_used = TRUE;
image->raw_data_len = mono_file_map_size (filed);
- image->raw_data = mono_file_map (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
+ image->raw_data = (char *)mono_file_map (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
#if defined(HAVE_MMAP) && !defined (HOST_WIN32)
if (!image->raw_data) {
image->fileio_used = TRUE;
- image->raw_data = mono_file_map_fileio (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
+ image->raw_data = (char *)mono_file_map_fileio (image->raw_data_len, MONO_MMAP_READ|MONO_MMAP_PRIVATE, mono_file_map_fd (filed), 0, &image->raw_data_handle);
}
#endif
if (!image->raw_data) {
MonoImage *res;
mono_images_lock ();
- res = g_hash_table_lookup (get_loaded_images_hash (refonly), name);
+ res = (MonoImage *)g_hash_table_lookup (get_loaded_images_hash (refonly), name);
if (!res)
- res = g_hash_table_lookup (get_loaded_images_by_name_hash (refonly), name);
+ res = (MonoImage *)g_hash_table_lookup (get_loaded_images_by_name_hash (refonly), name);
mono_images_unlock ();
return res;
static void
find_by_guid (gpointer key, gpointer val, gpointer user_data)
{
- GuidData *data = user_data;
+ GuidData *data = (GuidData *)user_data;
MonoImage *image;
if (data->res)
return;
- image = val;
+ image = (MonoImage *)val;
if (strcmp (data->guid, mono_image_get_guid (image)) == 0)
data->res = image;
}
GHashTable *loaded_images = get_loaded_images_hash (image->ref_only);
mono_images_lock ();
- image2 = g_hash_table_lookup (loaded_images, image->name);
+ image2 = (MonoImage *)g_hash_table_lookup (loaded_images, image->name);
if (image2) {
/* Somebody else beat us to it */
}
datac = data;
if (need_copy) {
- datac = g_try_malloc (data_len);
+ datac = (char *)g_try_malloc (data_len);
if (!datac) {
if (status)
*status = MONO_IMAGE_ERROR_ERRNO;
image->image_info = iinfo;
image->ref_only = refonly;
image->metadata_only = metadata_only;
+ image->ref_count = 1;
image = do_mono_image_load (image, status, TRUE, TRUE);
if (image == NULL)
* the same image, we discard all but the first copy.
*/
mono_images_lock ();
- image = g_hash_table_lookup (loaded_images, absfname);
+ image = (MonoImage *)g_hash_table_lookup (loaded_images, absfname);
g_free (absfname);
if (image) { // Image already loaded
loaded_images = get_loaded_images_hash (image->ref_only);
loaded_images_by_name = get_loaded_images_by_name_hash (image->ref_only);
- image2 = g_hash_table_lookup (loaded_images, image->name);
+ image2 = (MonoImage *)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);
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;
+ MonoCLIImageInfo *ii = (MonoCLIImageInfo *)image->image_info;
if ((image->raw_metadata > image->raw_data) &&
(image->raw_metadata <= (image->raw_data + image->raw_data_len)))
free_hash (image->stfld_wrapper_cache);
free_hash (image->isinst_cache);
free_hash (image->castclass_cache);
+ free_hash (image->icall_wrapper_cache);
free_hash (image->proxy_isinst_cache);
free_hash (image->var_cache_slow);
free_hash (image->mvar_cache_slow);
mono_bitset_free (image->interface_bitset);
}
if (image->image_info){
- MonoCLIImageInfo *ii = image->image_info;
+ MonoCLIImageInfo *ii = (MonoCLIImageInfo *)image->image_info;
if (ii->cli_section_tables)
g_free (ii->cli_section_tables);
mono_image_ensure_section_idx (image, MONO_SECTION_RSRC);
- info=image->image_info;
+ info = (MonoCLIImageInfo *)image->image_info;
if(info==NULL) {
return(NULL);
}
const char*
mono_image_get_resource (MonoImage *image, guint32 offset, guint32 *size)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoCLIHeader *ch = &iinfo->cli_cli_header;
const char* data;
const char*
mono_image_get_strong_name (MonoImage *image, guint32 *size)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoPEDirEntry *de = &iinfo->cli_cli_header.ch_strong_name;
const char* data;
guint32
mono_image_strong_name_position (MonoImage *image, guint32 *size)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoPEDirEntry *de = &iinfo->cli_cli_header.ch_strong_name;
guint32 pos;
gboolean
mono_image_has_authenticode_entry (MonoImage *image)
{
- MonoCLIImageInfo *iinfo = image->image_info;
+ MonoCLIImageInfo *iinfo = (MonoCLIImageInfo *)image->image_info;
MonoDotNetHeader *header = &iinfo->cli_header;
MonoPEDirEntry *de = &header->datadir.pe_certificate_table;
// the Authenticode "pre" (non ASN.1) header is 8 bytes long
{
GList *new_list;
- new_list = mono_image_alloc (image, sizeof (GList));
+ new_list = (GList *)mono_image_alloc (image, sizeof (GList));
new_list->data = data;
new_list->prev = list ? list->prev : NULL;
new_list->next = list;
{
GSList *new_list;
- new_list = mono_image_alloc (image, sizeof (GSList));
+ new_list = (GSList *)mono_image_alloc (image, sizeof (GSList));
new_list->data = data;
new_list->next = NULL;
mono_image_unlock (image);
}
-#if CHECKED_BUILD
-
-// These are support for the mempool reference tracking feature in checked-build, but live in image.c due to use of static variables of this file.
-
-// Given an image and a pointer, return the mempool owner if it is either this image or one of its imagesets.
-static MonoMemPoolOwner
-check_for_mempool_owner (void *ptr, MonoImage *image)
-{
- if (mono_mempool_contains_addr (image->mempool, ptr))
- {
- MonoMemPoolOwner owner = {image, NULL};
- return owner;
- }
-
- GSList *l;
- for (l = image->image_sets; l; l = l->next) {
- MonoImageSet *set = l->data;
-
- if (mono_mempool_contains_addr (set->mempool, ptr))
- {
- MonoMemPoolOwner owner = {NULL, set};
- return owner;
- }
- }
-
- return mono_mempool_no_owner;
-}
+// This is support for the mempool reference tracking feature in checked-build, but lives in image.c due to use of static variables of this file.
/**
- * mono_find_mempool_owner:
+ * mono_find_image_owner:
*
- * Find the image or imageset, if any, which a given pointer is located in the memory of.
+ * Find the image, if any, which a given pointer is located in the memory of.
*/
-MonoMemPoolOwner
-mono_find_mempool_owner (void *ptr)
+MonoImage *
+mono_find_image_owner (void *ptr)
{
mono_images_lock ();
- MonoMemPoolOwner owner = mono_mempool_no_owner;
- gboolean searching = TRUE;
+ MonoImage *owner = NULL;
// Iterate over both by-path image hashes
const int hash_candidates[] = {IMAGES_HASH_PATH, IMAGES_HASH_PATH_REFONLY};
int hash_idx;
- for (hash_idx = 0; searching && hash_idx < G_N_ELEMENTS (hash_candidates); hash_idx++)
+ for (hash_idx = 0; !owner && hash_idx < G_N_ELEMENTS (hash_candidates); hash_idx++)
{
GHashTable *target = loaded_images_hashes [hash_candidates [hash_idx]];
GHashTableIter iter;
// Iterate over images within a hash
g_hash_table_iter_init (&iter, target);
- while (searching && g_hash_table_iter_next(&iter, NULL, (gpointer *)&image))
+ while (!owner && g_hash_table_iter_next(&iter, NULL, (gpointer *)&image))
{
mono_image_lock (image);
- owner = check_for_mempool_owner (ptr, image);
+ if (mono_mempool_contains_addr (image->mempool, ptr))
+ owner = image;
mono_image_unlock (image);
-
- // Continue searching if null owner returned
- searching = check_mempool_owner_eq (owner, mono_mempool_no_owner);
}
}
return owner;
}
-
-#endif