static gboolean debug_assembly_unload = FALSE;
-#define mono_images_lock() if (mutex_inited) mono_mutex_lock (&images_mutex)
-#define mono_images_unlock() if (mutex_inited) mono_mutex_unlock (&images_mutex)
+#define mono_images_lock() if (mutex_inited) mono_os_mutex_lock (&images_mutex)
+#define mono_images_unlock() if (mutex_inited) mono_os_mutex_unlock (&images_mutex)
static gboolean mutex_inited;
static mono_mutex_t images_mutex;
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;
void
mono_images_init (void)
{
- mono_mutex_init_recursive (&images_mutex);
+ mono_os_mutex_init_recursive (&images_mutex);
int hash_idx;
for(hash_idx = 0; hash_idx < IMAGES_HASH_COUNT; hash_idx++)
GHashTableIter iter;
MonoImage *image;
- mono_mutex_destroy (&images_mutex);
+ mono_os_mutex_destroy (&images_mutex);
// If an assembly image is still loaded at shutdown, this could indicate managed code is still running.
// Reflection-only images being still loaded doesn't indicate anything as harmful, so we don't check for it.
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++){
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;
}
void
mono_image_init (MonoImage *image)
{
- mono_mutex_init_recursive (&image->lock);
- mono_mutex_init_recursive (&image->szarray_cache_lock);
+ mono_os_mutex_init_recursive (&image->lock);
+ mono_os_mutex_init_recursive (&image->szarray_cache_lock);
image->mempool = mono_mempool_new_size (INITIAL_IMAGE_SIZE);
mono_internal_hash_table_init (&image->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;
- for (l = image_loaders; l; l = l->next) {
- MonoImageLoader *loader = l->data;
- if (loader->match (image)) {
- image->loader = loader;
- break;
+ if (!image->metadata_only) {
+ for (l = image_loaders; l; l = l->next) {
+ MonoImageLoader *loader = (MonoImageLoader *)l->data;
+ if (loader->match (image)) {
+ image->loader = loader;
+ break;
+ }
+ }
+ if (!image->loader) {
+ *status = MONO_IMAGE_IMAGE_INVALID;
+ goto invalid_image;
}
- }
- if (!image->loader) {
- *status = MONO_IMAGE_IMAGE_INVALID;
- goto invalid_image;
- }
- if (status)
- *status = MONO_IMAGE_IMAGE_INVALID;
+ if (status)
+ *status = MONO_IMAGE_IMAGE_INVALID;
- if (care_about_pecoff == FALSE)
- goto done;
+ if (care_about_pecoff == FALSE)
+ goto done;
- if (!image->metadata_only) {
if (image->loader == &pe_loader && !mono_verifier_verify_pe_data (image, &errors))
goto invalid_image;
if (!mono_image_load_pe_data (image))
goto invalid_image;
+ } else {
+ image->loader = (MonoImageLoader*)&pe_loader;
}
if (care_about_cli == FALSE) {
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;
* 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)))
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);
if (image->modules_loaded)
g_free (image->modules_loaded);
- mono_mutex_destroy (&image->szarray_cache_lock);
- mono_mutex_destroy (&image->lock);
+ mono_os_mutex_destroy (&image->szarray_cache_lock);
+ mono_os_mutex_destroy (&image->lock);
/*g_print ("destroy image %p (dynamic: %d)\n", image, image->dynamic);*/
if (image_is_dynamic (image)) {
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;
void
mono_image_lock (MonoImage *image)
{
- mono_locks_acquire (&image->lock, ImageDataLock);
+ mono_locks_os_acquire (&image->lock, ImageDataLock);
}
void
mono_image_unlock (MonoImage *image)
{
- mono_locks_release (&image->lock, ImageDataLock);
+ mono_locks_os_release (&image->lock, ImageDataLock);
}
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
projects / mono.git / blobdiff