*
* 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 "abi-details.h"
#include <mono/utils/mono-error-internals.h>
#include <mono/utils/bsearch.h>
+#include <mono/utils/atomic.h>
/* Auxiliary structure used for caching inflated signatures */
typedef struct {
if (!etype)
return NULL;
- array = transient ? g_malloc0 (sizeof (MonoArrayType)) : mono_image_alloc0 (m, sizeof (MonoArrayType));
+ array = transient ? (MonoArrayType *)g_malloc0 (sizeof (MonoArrayType)) : (MonoArrayType *)mono_image_alloc0 (m, sizeof (MonoArrayType));
array->eklass = mono_class_from_mono_type (etype);
array->rank = mono_metadata_decode_value (ptr, &ptr);
array->numsizes = mono_metadata_decode_value (ptr, &ptr);
if (array->numsizes)
- array->sizes = transient ? g_malloc0 (sizeof (int) * array->numsizes) : mono_image_alloc0 (m, sizeof (int) * array->numsizes);
+ array->sizes = transient ? (int *)g_malloc0 (sizeof (int) * array->numsizes) : (int *)mono_image_alloc0 (m, sizeof (int) * array->numsizes);
for (i = 0; i < array->numsizes; ++i)
array->sizes [i] = mono_metadata_decode_value (ptr, &ptr);
array->numlobounds = mono_metadata_decode_value (ptr, &ptr);
if (array->numlobounds)
- array->lobounds = transient ? g_malloc0 (sizeof (int) * array->numlobounds) : mono_image_alloc0 (m, sizeof (int) * array->numlobounds);
+ array->lobounds = transient ? (int *)g_malloc0 (sizeof (int) * array->numlobounds) : (int *)mono_image_alloc0 (m, sizeof (int) * array->numlobounds);
for (i = 0; i < array->numlobounds; ++i)
array->lobounds [i] = mono_metadata_decode_signed_value (ptr, &ptr);
}
MonoArrayType *
-mono_metadata_parse_array_full (MonoImage *m, MonoGenericContainer *container,
- const char *ptr, const char **rptr)
+mono_metadata_parse_array (MonoImage *m, const char *ptr, const char **rptr)
{
MonoError error;
- MonoArrayType *ret = mono_metadata_parse_array_internal (m, container, FALSE, ptr, rptr, &error);
- if (!ret) {
- mono_loader_set_error_from_mono_error (&error);
- mono_error_cleanup (&error); /*FIXME don't swallow the error message*/
- }
- return ret;
-}
+ MonoArrayType *ret = mono_metadata_parse_array_internal (m, NULL, FALSE, ptr, rptr, &error);
+ mono_error_cleanup (&error);
-MonoArrayType *
-mono_metadata_parse_array (MonoImage *m, const char *ptr, const char **rptr)
-{
- return mono_metadata_parse_array_full (m, NULL, ptr, rptr);
+ return ret;
}
/*
{
int i;
-#ifndef MONO_SMALL_CONFIG
- if (a->id && b->id) {
+ // An optimization: if the ids of two insts are the same, we know they are the same inst and don't check contents.
+ // Furthermore, because we perform early de-duping, if the ids differ, we know the contents differ.
+#ifndef MONO_SMALL_CONFIG // Optimization does not work in MONO_SMALL_CONFIG: There are no IDs
+ if (a->id && b->id) { // "id 0" means "object has no id"-- de-duping hasn't been performed yet, must check contents.
if (a->id == b->id)
return TRUE;
+ // In signature-comparison mode id equality implies object equality, but this is not true for inequality.
+ // Two separate objects could have signature-equavalent contents.
if (!signature_only)
return FALSE;
}
*/
static MonoType*
mono_metadata_parse_type_internal (MonoImage *m, MonoGenericContainer *container,
- short opt_attrs, gboolean transient, const char *ptr, const char **rptr)
+ short opt_attrs, gboolean transient, const char *ptr, const char **rptr, MonoError *error)
{
- MonoError error;
MonoType *type, *cached;
MonoType stype;
gboolean byref = FALSE;
gboolean pinned = FALSE;
const char *tmp_ptr;
- int count = 0;
+ int count = 0; // Number of mod arguments
gboolean found;
+ mono_error_init (error);
+
/*
* According to the spec, custom modifiers should come before the byref
* flag, but the IL produced by ilasm from the following signature:
}
}
- if (count) {
+ if (count) { // There are mods, so the MonoType will be of nonstandard size.
int size;
size = MONO_SIZEOF_TYPE + ((gint32)count) * sizeof (MonoCustomMod);
- type = transient ? g_malloc0 (size) : mono_image_alloc0 (m, size);
+ type = transient ? (MonoType *)g_malloc0 (size) : (MonoType *)mono_image_alloc0 (m, size);
type->num_mods = count;
- if (count > 64)
- g_warning ("got more than 64 modifiers in type");
- } else {
+ if (count > 64) {
+ mono_error_set_bad_image (error, m, "Invalid type with more than 64 modifiers");
+ return NULL;
+ }
+ } else { // The type is of standard size, so we can allocate it on the stack.
type = &stype;
memset (type, 0, MONO_SIZEOF_TYPE);
}
- /* Parse pinned, byref and custom modifiers */
+ /* Iterate again, but now parse pinned, byref and custom modifiers */
found = TRUE;
count = 0;
while (found) {
type->byref = byref;
type->pinned = pinned ? 1 : 0;
- if (!do_mono_metadata_parse_type (type, m, container, transient, ptr, &ptr, &error)) {
- mono_loader_set_error_from_mono_error (&error);
- mono_error_cleanup (&error); /*FIXME don't swallow the error message*/
+ if (!do_mono_metadata_parse_type (type, m, container, transient, ptr, &ptr, error))
return NULL;
- }
if (rptr)
*rptr = ptr;
+ // Possibly we can return an already-allocated type instead of the one we decoded
if (!type->num_mods && !transient) {
/* no need to free type here, because it is on the stack */
if ((type->type == MONO_TYPE_CLASS || type->type == MONO_TYPE_VALUETYPE) && !type->pinned && !type->attrs) {
}
}
/* No need to use locking since nobody is modifying the hash table */
- if ((cached = g_hash_table_lookup (type_cache, type))) {
+ if ((cached = (MonoType *)g_hash_table_lookup (type_cache, type))) {
return cached;
}
}
/* printf ("%x %x %c %s\n", type->attrs, type->num_mods, type->pinned ? 'p' : ' ', mono_type_full_name (type)); */
- if (type == &stype) {
- type = transient ? g_malloc (MONO_SIZEOF_TYPE) : mono_image_alloc (m, MONO_SIZEOF_TYPE);
+ if (type == &stype) { // Type was allocated on the stack, so we need to copy it to safety
+ type = transient ? (MonoType *)g_malloc (MONO_SIZEOF_TYPE) : (MonoType *)mono_image_alloc (m, MONO_SIZEOF_TYPE);
memcpy (type, &stype, MONO_SIZEOF_TYPE);
}
return type;
mono_metadata_parse_type_checked (MonoImage *m, MonoGenericContainer *container,
short opt_attrs, gboolean transient, const char *ptr, const char **rptr, MonoError *error)
{
- MonoType *ret;
-
- mono_error_init (error);
-
- ret = mono_metadata_parse_type_internal (m, container, opt_attrs, transient, ptr, rptr);
-
- if (!ret) {
- if (mono_loader_get_last_error ())
- mono_error_set_from_loader_error (error);
- else
- mono_error_set_bad_image (error, m, "Could not parse type at %p due to unknown reasons", ptr);
- }
-
- return ret;
-}
-
-
-MonoType*
-mono_metadata_parse_type_full (MonoImage *m, MonoGenericContainer *container,
- short opt_attrs, const char *ptr, const char **rptr)
-{
- return mono_metadata_parse_type_internal (m, container, opt_attrs, FALSE, ptr, rptr);
+ return mono_metadata_parse_type_internal (m, container, opt_attrs, transient, ptr, rptr, error);
}
/*
mono_metadata_parse_type (MonoImage *m, MonoParseTypeMode mode, short opt_attrs,
const char *ptr, const char **rptr)
{
- return mono_metadata_parse_type_full (m, NULL, opt_attrs, ptr, rptr);
+ MonoError error;
+ MonoType * type = mono_metadata_parse_type_internal (m, NULL, opt_attrs, FALSE, ptr, rptr, &error);
+ mono_error_cleanup (&error);
+ return type;
}
gboolean
guint32 sig;
const char *ptr;
- if (image_is_dynamic (image))
- return mono_lookup_dynamic_token (image, token, NULL);
+ if (image_is_dynamic (image)) {
+ ret = (MonoMethodSignature *)mono_lookup_dynamic_token (image, token, NULL, &error);
+ mono_error_raise_exception (&error); /* FIXME don't raise here */
+ return ret;
+ }
g_assert (mono_metadata_token_table(token) == MONO_TABLE_STANDALONESIG);
{
MonoMethodSignature *sig;
- sig = mono_image_alloc0 (m, MONO_SIZEOF_METHOD_SIGNATURE + ((gint32)nparams) * sizeof (MonoType*));
+ sig = (MonoMethodSignature *)mono_image_alloc0 (m, MONO_SIZEOF_METHOD_SIGNATURE + ((gint32)nparams) * sizeof (MonoType*));
sig->param_count = nparams;
sig->sentinelpos = -1;
sigsize += MONO_SIZEOF_TYPE;
if (image) {
- ret = mono_image_alloc (image, sigsize);
+ ret = (MonoMethodSignature *)mono_image_alloc (image, sigsize);
} else if (mp) {
- ret = mono_mempool_alloc (mp, sigsize);
+ ret = (MonoMethodSignature *)mono_mempool_alloc (mp, sigsize);
} else {
- ret = g_malloc (sigsize);
+ ret = (MonoMethodSignature *)g_malloc (sigsize);
}
memcpy (ret, sig, sig_header_size - padding);
static gboolean
inflated_method_equal (gconstpointer a, gconstpointer b)
{
- const MonoMethodInflated *ma = a;
- const MonoMethodInflated *mb = b;
+ const MonoMethodInflated *ma = (const MonoMethodInflated *)a;
+ const MonoMethodInflated *mb = (const MonoMethodInflated *)b;
if (ma->declaring != mb->declaring)
return FALSE;
return mono_metadata_generic_context_equal (&ma->context, &mb->context);
static guint
inflated_method_hash (gconstpointer a)
{
- const MonoMethodInflated *ma = a;
+ const MonoMethodInflated *ma = (const MonoMethodInflated *)a;
return (mono_metadata_generic_context_hash (&ma->context) ^ mono_aligned_addr_hash (ma->declaring));
}
static gboolean
inflated_signature_equal (gconstpointer a, gconstpointer b)
{
- const MonoInflatedMethodSignature *sig1 = a;
- const MonoInflatedMethodSignature *sig2 = b;
+ const MonoInflatedMethodSignature *sig1 = (const MonoInflatedMethodSignature *)a;
+ const MonoInflatedMethodSignature *sig2 = (const MonoInflatedMethodSignature *)b;
/* sig->sig is assumed to be canonized */
if (sig1->sig != sig2->sig)
static guint
inflated_signature_hash (gconstpointer a)
{
- const MonoInflatedMethodSignature *sig = a;
+ const MonoInflatedMethodSignature *sig = (const MonoInflatedMethodSignature *)a;
/* sig->sig is assumed to be canonized */
return mono_metadata_generic_context_hash (&sig->context) ^ mono_aligned_addr_hash (sig->sig);
goto retry;
case MONO_TYPE_FNPTR:
return signature_in_image (type->data.method, image);
- case MONO_TYPE_VAR: {
- MonoGenericContainer *container = mono_type_get_generic_param_owner (type);
- if (container) {
- g_assert (!container->is_method);
- /*
- * FIXME: The following check is here solely
- * for monodis, which uses the internal
- * function
- * mono_metadata_load_generic_params(). The
- * caller of that function needs to fill in
- * owner->klass or owner->method of the
- * returned struct, but monodis doesn't do
- * that. The image unloading depends on that,
- * however, so a crash results without this
- * check.
- */
- if (!container->owner.klass)
- return container->image == image;
- return container->owner.klass->image == image;
- } else {
- return type->data.generic_param->image == image;
- }
- }
- case MONO_TYPE_MVAR: {
- MonoGenericContainer *container = mono_type_get_generic_param_owner (type);
- if (type->data.generic_param->image == image)
- return TRUE;
- if (container) {
- g_assert (container->is_method);
- if (!container->owner.method)
- /* RefEmit created generic param whose method is not finished */
- return container->image == image;
- return container->owner.method->klass->image == image;
- } else {
- return type->data.generic_param->image == image;
- }
- }
+ case MONO_TYPE_VAR:
+ case MONO_TYPE_MVAR:
+ return image == get_image_for_generic_param (type->data.generic_param);
default:
/* At this point, we should've avoided all potential allocations in mono_class_from_mono_type () */
return image == mono_class_from_mono_type (type)->image;
MonoImageSet *set;
GSList *l;
- /* Common case */
+ /* Common case: Image set contains corlib only. If we've seen that case before, we cached the set. */
if (nimages == 1 && images [0] == mono_defaults.corlib && mscorlib_image_set)
return mscorlib_image_set;
/* Happens with empty generic instances */
+ // FIXME: Is corlib the correct thing to return here? If so, why? This may be an artifact of generic instances previously defaulting to allocating from corlib.
if (nimages == 0)
return mscorlib_image_set;
if (!image_sets)
image_sets = g_ptr_array_new ();
+ // Before we go on, we should check to see whether a MonoImageSet with these images already exists.
+ // We can search the referred-by imagesets of any one of our images to do this. Arbitrarily pick one here:
if (images [0] == mono_defaults.corlib && nimages > 1)
- l = images [1]->image_sets;
+ l = images [1]->image_sets; // Prefer not to search the imagesets of corlib-- that will be a long list.
else
l = images [0]->image_sets;
set = NULL;
- for (; l; l = l->next) {
- set = l->data;
+ while (l) // Iterate over selected list, looking for an imageset with members equal to our target one
+ {
+ set = (MonoImageSet *)l->data;
- if (set->nimages == nimages) {
+ if (set->nimages == nimages) { // Member count differs, this can't be it
+ // Compare all members to all members-- order might be different
for (j = 0; j < nimages; ++j) {
for (k = 0; k < nimages; ++k)
if (set->images [k] == images [j])
- break;
+ break; // Break on match
+
+ // If we iterated all the way through set->images, images[j] was *not* found.
if (k == nimages)
- /* Not found */
- break;
+ break; // Break on "image not found"
}
+
+ // If we iterated all the way through images without breaking, all items in images were found in set->images
if (j == nimages)
- /* Found */
- break;
+ break; // Break on "found a set with equal members"
}
+
+ l = l->next;
}
+ // If we iterated all the way through l without breaking, the imageset does not already exist and we shuold create it
if (!l) {
- /* Not found */
set = g_new0 (MonoImageSet, 1);
set->nimages = nimages;
set->images = g_new0 (MonoImage*, nimages);
set->ginst_cache = g_hash_table_new_full (mono_metadata_generic_inst_hash, mono_metadata_generic_inst_equal, NULL, (GDestroyNotify)free_generic_inst);
set->gmethod_cache = g_hash_table_new_full (inflated_method_hash, inflated_method_equal, NULL, (GDestroyNotify)free_inflated_method);
set->gsignature_cache = g_hash_table_new_full (inflated_signature_hash, inflated_signature_equal, NULL, (GDestroyNotify)free_inflated_signature);
-
+
for (i = 0; i < nimages; ++i)
set->images [i]->image_sets = g_slist_prepend (set->images [i]->image_sets, set);
return res;
}
+// Get a descriptive string for a MonoImageSet
+// Callers are obligated to free buffer with g_free after use
+char *
+mono_image_set_description (MonoImageSet *set)
+{
+ GString *result = g_string_new (NULL);
+ int img;
+ g_string_append (result, "[");
+ for (img = 0; img < set->nimages; img++)
+ {
+ if (img > 0)
+ g_string_append (result, ", ");
+ g_string_append (result, set->images[img]->name);
+ }
+ g_string_append (result, "]");
+ return g_string_free (result, FALSE);
+}
+
/*
* Structure used by the collect_..._images functions to store the image list.
*/
case MONO_TYPE_FNPTR:
//return signature_in_image (type->data.method, image);
g_assert_not_reached ();
- case MONO_TYPE_VAR: {
- MonoGenericContainer *container = mono_type_get_generic_param_owner (type);
- if (container) {
- g_assert (!container->is_method);
- /*
- * FIXME: The following check is here solely
- * for monodis, which uses the internal
- * function
- * mono_metadata_load_generic_params(). The
- * caller of that function needs to fill in
- * owner->klass or owner->method of the
- * returned struct, but monodis doesn't do
- * that. The image unloading depends on that,
- * however, so a crash results without this
- * check.
- */
- if (!container->owner.klass)
- add_image (container->image, data);
- else
- add_image (container->owner.klass->image, data);
- } else {
- add_image (type->data.generic_param->image, data);
- }
- }
+ case MONO_TYPE_VAR:
+ case MONO_TYPE_MVAR:
+ {
+ MonoImage *image = get_image_for_generic_param (type->data.generic_param);
+ add_image (image, data);
break;
- case MONO_TYPE_MVAR: {
- MonoGenericContainer *container = mono_type_get_generic_param_owner (type);
- if (type->data.generic_param->image)
- add_image (type->data.generic_param->image, data);
- if (container) {
- if (!container->owner.method) {
- /* RefEmit created generic param whose method is not finished */
- add_image (container->image, data);
- } else {
- g_assert (container->is_method);
- add_image (container->owner.method->klass->image, data);
- }
- } else {
- add_image (type->data.generic_param->image, data);
- }
}
- break;
case MONO_TYPE_CLASS:
case MONO_TYPE_VALUETYPE:
add_image (mono_class_from_mono_type (type)->image, data);
static gboolean
steal_gclass_in_image (gpointer key, gpointer value, gpointer data)
{
- MonoGenericClass *gclass = key;
- CleanForImageUserData *user_data = data;
+ MonoGenericClass *gclass = (MonoGenericClass *)key;
+ CleanForImageUserData *user_data = (CleanForImageUserData *)data;
g_assert (gclass_in_image (gclass, user_data->image));
static gboolean
steal_ginst_in_image (gpointer key, gpointer value, gpointer data)
{
- MonoGenericInst *ginst = key;
- CleanForImageUserData *user_data = data;
+ MonoGenericInst *ginst = (MonoGenericInst *)key;
+ CleanForImageUserData *user_data = (CleanForImageUserData *)data;
// This doesn't work during corlib compilation
//g_assert (ginst_in_image (ginst, user_data->image));
static gboolean
inflated_method_in_image (gpointer key, gpointer value, gpointer data)
{
- MonoImage *image = data;
- MonoMethodInflated *method = key;
+ MonoImage *image = (MonoImage *)data;
+ MonoMethodInflated *method = (MonoMethodInflated *)key;
// FIXME:
// https://bugzilla.novell.com/show_bug.cgi?id=458168
static gboolean
inflated_signature_in_image (gpointer key, gpointer value, gpointer data)
{
- MonoImage *image = data;
- MonoInflatedMethodSignature *sig = key;
+ MonoImage *image = (MonoImage *)data;
+ MonoInflatedMethodSignature *sig = (MonoInflatedMethodSignature *)key;
return signature_in_image (sig->sig, image) ||
(sig->context.class_inst && ginst_in_image (sig->context.class_inst, image)) ||
static void
check_gmethod (gpointer key, gpointer value, gpointer data)
{
- MonoMethodInflated *method = key;
- MonoImage *image = data;
+ MonoMethodInflated *method = (MonoMethodInflated *)key;
+ MonoImage *image = (MonoImage *)data;
if (method->context.class_inst)
g_assert (!ginst_in_image (method->context.class_inst, image));
return;
for (i = 0; i < image_sets->len; ++i) {
- MonoImageSet *set = g_ptr_array_index (image_sets, i);
+ MonoImageSet *set = (MonoImageSet *)g_ptr_array_index (image_sets, i);
if (!g_slist_find (l, set)) {
g_hash_table_foreach (set->gmethod_cache, check_gmethod, image);
/* Collect the items to delete */
/* delete_image_set () modifies the lists so make a copy */
for (l = image->image_sets; l; l = l->next) {
- MonoImageSet *set = l->data;
+ MonoImageSet *set = (MonoImageSet *)l->data;
mono_image_set_lock (set);
g_hash_table_foreach_steal (set->gclass_cache, steal_gclass_in_image, &gclass_data);
/* Delete the removed items */
for (l = ginst_data.list; l; l = l->next)
- free_generic_inst (l->data);
+ free_generic_inst ((MonoGenericInst *)l->data);
for (l = gclass_data.list; l; l = l->next)
- free_generic_class (l->data);
+ free_generic_class ((MonoGenericClass *)l->data);
g_slist_free (ginst_data.list);
g_slist_free (gclass_data.list);
/* delete_image_set () modifies the lists so make a copy */
set_list = g_slist_copy (image->image_sets);
for (l = set_list; l; l = l->next) {
- MonoImageSet *set = l->data;
+ MonoImageSet *set = (MonoImageSet *)l->data;
delete_image_set (set);
}
if (method->signature)
mono_metadata_free_inflated_signature (method->signature);
- if (!((method->flags & METHOD_ATTRIBUTE_ABSTRACT) || (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) || (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) || (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))) {
- MonoMethodHeader *header = imethod->header;
-
- if (header) {
- /* Allocated in inflate_generic_header () */
- for (i = 0; i < header->num_locals; ++i)
- mono_metadata_free_type (header->locals [i]);
- g_free (header->clauses);
- g_free (header);
- }
- }
-
g_free (method);
}
mono_image_set_lock (set);
- res = g_hash_table_lookup (set->gsignature_cache, &helper);
+ res = (MonoInflatedMethodSignature *)g_hash_table_lookup (set->gsignature_cache, &helper);
if (!res) {
res = g_new0 (MonoInflatedMethodSignature, 1);
res->sig = sig;
break;
is_open = (i < type_argc);
- ginst = g_alloca (size);
+ ginst = (MonoGenericInst *)g_alloca (size);
memset (ginst, 0, sizeof (MonoGenericInst));
ginst->is_open = is_open;
ginst->type_argc = type_argc;
mono_image_set_lock (set);
- ginst = g_hash_table_lookup (set->ginst_cache, ginst);
+ ginst = (MonoGenericInst *)g_hash_table_lookup (set->ginst_cache, ginst);
if (!ginst) {
- ginst = mono_image_set_alloc0 (set, size);
+ ginst = (MonoGenericInst *)mono_image_set_alloc0 (set, size);
#ifndef MONO_SMALL_CONFIG
ginst->id = ++next_generic_inst_id;
#endif
MonoImageSet *set;
CollectData data;
+ memset (&helper, 0, sizeof(helper)); // act like g_new0
helper.container_class = container_class;
helper.context.class_inst = inst;
- helper.context.method_inst = NULL;
helper.is_dynamic = is_dynamic; /* We use this in a hash lookup, which does not attempt to downcast the pointer */
helper.is_tb_open = is_tb_open;
- helper.cached_class = NULL;
collect_data_init (&data);
mono_image_set_lock (set);
- gclass = g_hash_table_lookup (set->gclass_cache, &helper);
+ gclass = (MonoGenericClass *)g_hash_table_lookup (set->gclass_cache, &helper);
/* A tripwire just to keep us honest */
g_assert (!helper.cached_class);
return gc;
}
-/*
+MonoGenericContainer *
+get_anonymous_container_for_image (MonoImage *image, gboolean is_mvar)
+{
+ MonoGenericContainer **container_pointer;
+ if (is_mvar)
+ container_pointer = &image->anonymous_generic_method_container;
+ else
+ container_pointer = &image->anonymous_generic_class_container;
+ MonoGenericContainer *result = *container_pointer;
+
+ // This container has never been created; make it now.
+ if (!result)
+ {
+ // Note this is never deallocated anywhere-- it exists for the lifetime of the image it's allocated from
+ result = (MonoGenericContainer *)mono_image_alloc0 (image, sizeof (MonoGenericContainer));
+ result->owner.image = image;
+ result->is_anonymous = TRUE;
+ result->is_small_param = TRUE;
+ result->is_method = is_mvar;
+
+ // If another thread already made a container, use that and leak this new one.
+ // (Technically it would currently be safe to just assign instead of CASing.)
+ MonoGenericContainer *exchange = (MonoGenericContainer *)InterlockedCompareExchangePointer ((volatile gpointer *)container_pointer, result, NULL);
+ if (exchange)
+ result = exchange;
+ }
+ return result;
+}
+
+/*
* mono_metadata_parse_generic_param:
* @generic_container: Our MonoClass's or MonoMethod's MonoGenericContainer;
- * see mono_metadata_parse_type_full() for details.
+ * see mono_metadata_parse_type_checked() for details.
* Internal routine to parse a generic type parameter.
* LOCKING: Acquires the loader lock
*/
generic_container = select_container (generic_container, type);
if (!generic_container) {
+ gboolean is_mvar = FALSE;
+ switch (type)
+ {
+ case MONO_TYPE_VAR:
+ break;
+ case MONO_TYPE_MVAR:
+ is_mvar = TRUE;
+ break;
+ default:
+ g_error ("Cerating generic param object with invalid MonoType"); // This is not a generic param
+ }
+
/* Create dummy MonoGenericParam */
MonoGenericParam *param;
- param = mono_image_alloc0 (m, sizeof (MonoGenericParam));
+ param = (MonoGenericParam *)mono_image_alloc0 (m, sizeof (MonoGenericParam));
param->num = index;
- param->image = m;
+ param->owner = get_anonymous_container_for_image (m, is_mvar);
return param;
}
MonoType *cached;
/* No need to use locking since nobody is modifying the hash table */
- if ((cached = g_hash_table_lookup (type_cache, type)))
+ if ((cached = (MonoType *)g_hash_table_lookup (type_cache, type)))
return cached;
switch (type->type){
{
mono_error_init (error);
- type->type = mono_metadata_decode_value (ptr, &ptr);
+ type->type = (MonoTypeEnum)mono_metadata_decode_value (ptr, &ptr);
switch (type->type){
case MONO_TYPE_VOID:
return FALSE;
type->data.klass = mono_class_from_mono_type (etype);
+
+ if (transient)
+ mono_metadata_free_type (etype);
+
g_assert (type->data.klass); //This was previously a check for NULL, but mcfmt should never fail. It can return a borken MonoClass, but should return at least something.
break;
}
* @ptr: Points to the beginning of the Section Data (25.3)
*/
static MonoExceptionClause*
-parse_section_data (MonoImage *m, int *num_clauses, const unsigned char *ptr)
+parse_section_data (MonoImage *m, int *num_clauses, const unsigned char *ptr, MonoError *error)
{
unsigned char sect_data_flags;
int is_fat;
guint32 sect_data_len;
MonoExceptionClause* clauses = NULL;
+
+ mono_error_init (error);
while (1) {
/* align on 32-bit boundary */
int i;
*num_clauses = is_fat ? sect_data_len / 24: sect_data_len / 12;
/* we could just store a pointer if we don't need to byteswap */
- clauses = g_malloc0 (sizeof (MonoExceptionClause) * (*num_clauses));
+ clauses = (MonoExceptionClause *)g_malloc0 (sizeof (MonoExceptionClause) * (*num_clauses));
for (i = 0; i < *num_clauses; ++i) {
MonoExceptionClause *ec = &clauses [i];
guint32 tof_value;
} else if (ec->flags == MONO_EXCEPTION_CLAUSE_NONE) {
ec->data.catch_class = NULL;
if (tof_value) {
- MonoError error;
- ec->data.catch_class = mono_class_get_checked (m, tof_value, &error);
- if (!mono_error_ok (&error)) {
- mono_error_cleanup (&error); /* FIXME don't swallow the error */
+ ec->data.catch_class = mono_class_get_checked (m, tof_value, error);
+ if (!is_ok (error)) {
g_free (clauses);
return NULL;
}
* @summary: Where to store the header
*
*
- * Returns: true if the header was properly decoded.
+ * Returns: TRUE if the header was properly decoded.
*/
gboolean
mono_method_get_header_summary (MonoMethod *method, MonoMethodHeaderSummary *summary)
return FALSE;
ptr = mono_image_rva_map (img, rva);
- g_assert (ptr);
+ if (!ptr)
+ return FALSE;
flags = *(const unsigned char *)ptr;
format = flags & METHOD_HEADER_FORMAT_MASK;
* Returns: a transient MonoMethodHeader allocated from the heap.
*/
MonoMethodHeader *
-mono_metadata_parse_mh_full (MonoImage *m, MonoGenericContainer *container, const char *ptr)
+mono_metadata_parse_mh_full (MonoImage *m, MonoGenericContainer *container, const char *ptr, MonoError *error)
{
MonoMethodHeader *mh = NULL;
unsigned char flags = *(const unsigned char *) ptr;
MonoTableInfo *t = &m->tables [MONO_TABLE_STANDALONESIG];
guint32 cols [MONO_STAND_ALONE_SIGNATURE_SIZE];
- g_return_val_if_fail (ptr != NULL, NULL);
+ mono_error_init (error);
+
+ if (!ptr) {
+ mono_error_set_bad_image (error, m, "Method header with null pointer");
+ return NULL;
+ }
switch (format) {
case METHOD_HEADER_TINY_FORMAT:
- mh = g_malloc0 (MONO_SIZEOF_METHOD_HEADER);
+ mh = (MonoMethodHeader *)g_malloc0 (MONO_SIZEOF_METHOD_HEADER);
ptr++;
mh->max_stack = 8;
mh->is_transient = TRUE;
ptr = (char*)code + code_size;
break;
default:
+ mono_error_set_bad_image (error, m, "Invalid method header format %d", format);
return NULL;
}
if (local_var_sig_tok) {
int idx = (local_var_sig_tok & 0xffffff)-1;
- if (idx >= t->rows || idx < 0)
+ if (idx >= t->rows || idx < 0) {
+ mono_error_set_bad_image (error, m, "Invalid method header local vars signature token 0x%8x", idx);
goto fail;
+ }
mono_metadata_decode_row (t, idx, cols, 1);
- if (!mono_verifier_verify_standalone_signature (m, cols [MONO_STAND_ALONE_SIGNATURE], NULL))
+ if (!mono_verifier_verify_standalone_signature (m, cols [MONO_STAND_ALONE_SIGNATURE], NULL)) {
+ mono_error_set_bad_image (error, m, "Method header locals signature 0x%8x verification failed", idx);
+ goto fail;
+ }
+ }
+ if (fat_flags & METHOD_HEADER_MORE_SECTS) {
+ clauses = parse_section_data (m, &num_clauses, (const unsigned char*)ptr, error);
+ if (!is_ok (error))
goto fail;
}
- if (fat_flags & METHOD_HEADER_MORE_SECTS)
- clauses = parse_section_data (m, &num_clauses, (const unsigned char*)ptr);
if (local_var_sig_tok) {
const char *locals_ptr;
int len=0, i;
g_warning ("wrong signature for locals blob");
locals_ptr++;
len = mono_metadata_decode_value (locals_ptr, &locals_ptr);
- mh = g_malloc0 (MONO_SIZEOF_METHOD_HEADER + len * sizeof (MonoType*) + num_clauses * sizeof (MonoExceptionClause));
+ mh = (MonoMethodHeader *)g_malloc0 (MONO_SIZEOF_METHOD_HEADER + len * sizeof (MonoType*) + num_clauses * sizeof (MonoExceptionClause));
mh->num_locals = len;
for (i = 0; i < len; ++i) {
- mh->locals [i] = mono_metadata_parse_type_internal (m, container,
- 0, TRUE, locals_ptr, &locals_ptr);
- if (!mh->locals [i])
+ mh->locals [i] = mono_metadata_parse_type_internal (m, container, 0, TRUE, locals_ptr, &locals_ptr, error);
+ if (!is_ok (error))
goto fail;
}
} else {
- mh = g_malloc0 (MONO_SIZEOF_METHOD_HEADER + num_clauses * sizeof (MonoExceptionClause));
+ mh = (MonoMethodHeader *)g_malloc0 (MONO_SIZEOF_METHOD_HEADER + num_clauses * sizeof (MonoExceptionClause));
}
mh->code = code;
mh->code_size = code_size;
MonoMethodHeader *
mono_metadata_parse_mh (MonoImage *m, const char *ptr)
{
- return mono_metadata_parse_mh_full (m, NULL, ptr);
+ MonoError error;
+ MonoMethodHeader *header = mono_metadata_parse_mh_full (m, NULL, ptr, &error);
+ mono_error_cleanup (&error);
+ return header;
}
/*
*clause = *sc;
return TRUE;
}
- sc = *iter;
+ sc = (MonoExceptionClause *)*iter;
sc++;
if (sc < header->clauses + header->num_clauses) {
*iter = sc;
MonoType *
mono_metadata_parse_field_type (MonoImage *m, short field_flags, const char *ptr, const char **rptr)
{
- return mono_metadata_parse_type (m, MONO_PARSE_FIELD, field_flags, ptr, rptr);
+ MonoError error;
+ MonoType * type = mono_metadata_parse_type_internal (m, NULL, field_flags, FALSE, ptr, rptr, &error);
+ mono_error_cleanup (&error);
+ return type;
}
/**
MonoType *
mono_metadata_parse_param (MonoImage *m, const char *ptr, const char **rptr)
{
- return mono_metadata_parse_type (m, MONO_PARSE_PARAM, 0, ptr, rptr);
+ MonoError error;
+ MonoType * type = mono_metadata_parse_type_internal (m, NULL, 0, FALSE, ptr, rptr, &error);
+ mono_error_cleanup (&error);
+ return type;
}
/*
if (heap_alloc_result)
result = g_new0 (MonoClass*, pos - start);
else
- result = mono_image_alloc0 (meta, sizeof (MonoClass*) * (pos - start));
+ result = (MonoClass **)mono_image_alloc0 (meta, sizeof (MonoClass*) * (pos - start));
pos = start;
while (pos < tdef->rows) {
* image B gets that generic inst from the cache, image A is
* unloaded, so the inst is deleted, but image B still retains
* a pointer to it.
- *
- * The AOT runtime doesn't set the image when it's decoding
- * types, so we only compare it when the owner is NULL.
*/
- if (mono_generic_param_owner (p1) == mono_generic_param_owner (p2) &&
- (mono_generic_param_owner (p1) || p1->image == p2->image))
+ if (mono_generic_param_owner (p1) == mono_generic_param_owner (p2))
return TRUE;
/*
* mono_metadata_type_equal:
* @t1: a type
* @t2: another type
+ * @signature_only: If true, treat ginsts as equal which are instantiated separately but have equal positional value
*
* Determine if @t1 and @t2 represent the same type.
* Returns: #TRUE if @t1 and @t2 are equal.
if (o->num_mods)
sizeof_o += o->num_mods * sizeof (MonoCustomMod);
- r = image ? mono_image_alloc0 (image, sizeof_o) : g_malloc (sizeof_o);
+ r = image ? (MonoType *)mono_image_alloc0 (image, sizeof_o) : (MonoType *)g_malloc (sizeof_o);
memcpy (r, o, sizeof_o);
mono_error_init (error);
mono_image_lock (image);
- type = g_hash_table_lookup (image->typespec_cache, GUINT_TO_POINTER (type_spec));
+ type = (MonoType *)g_hash_table_lookup (image->typespec_cache, GUINT_TO_POINTER (type_spec));
mono_image_unlock (image);
if (type)
return type;
mono_metadata_free_type (type);
mono_image_lock (image);
- type = g_hash_table_lookup (image->typespec_cache, GUINT_TO_POINTER (type_spec));
+ type = (MonoType *)g_hash_table_lookup (image->typespec_cache, GUINT_TO_POINTER (type_spec));
/* We might leak some data in the image mempool if found */
if (!type) {
g_hash_table_insert (image->typespec_cache, GUINT_TO_POINTER (type_spec), type2);
char *res;
if (!image)
return g_strndup (data, len);
- res = mono_image_alloc (image, len + 1);
+ res = (char *)mono_image_alloc (image, len + 1);
memcpy (res, data, len);
res [len] = 0;
return res;
/* fixme: this is incomplete, but I cant find more infos in the specs */
if (image)
- res = mono_image_alloc0 (image, sizeof (MonoMarshalSpec));
+ res = (MonoMarshalSpec *)mono_image_alloc0 (image, sizeof (MonoMarshalSpec));
else
res = g_new0 (MonoMarshalSpec, 1);
len = mono_metadata_decode_value (ptr, &ptr);
- res->native = *ptr++;
+ res->native = (MonoMarshalNative)*ptr++;
if (res->native == MONO_NATIVE_LPARRAY) {
res->data.array_data.param_num = -1;
res->data.array_data.elem_mult = -1;
if (ptr - start <= len)
- res->data.array_data.elem_type = *ptr++;
+ res->data.array_data.elem_type = (MonoMarshalNative)*ptr++;
if (ptr - start <= len)
res->data.array_data.param_num = mono_metadata_decode_value (ptr, &ptr);
if (ptr - start <= len)
}
if (res->native == MONO_NATIVE_SAFEARRAY) {
- res->data.safearray_data.elem_type = 0;
+ res->data.safearray_data.elem_type = (MonoMarshalVariant)0;
res->data.safearray_data.num_elem = 0;
if (ptr - start <= len)
- res->data.safearray_data.elem_type = *ptr++;
+ res->data.safearray_data.elem_type = (MonoMarshalVariant)*ptr++;
if (ptr - start <= len)
res->data.safearray_data.num_elem = *ptr++;
}
*conv = MONO_MARSHAL_CONV_DEL_FTN;
return MONO_NATIVE_FUNC;
}
- if (mono_defaults.safehandle_class && type->data.klass == mono_defaults.safehandle_class){
+ if (mono_class_try_get_safehandle_class () && type->data.klass == mono_class_try_get_safehandle_class ()){
*conv = MONO_MARSHAL_CONV_SAFEHANDLE;
return MONO_NATIVE_INT;
}
}
if (!found)
return TRUE;
- res = mono_image_alloc0 (image, sizeof (MonoClass*) * (found + 1));
+ res = (MonoClass **)mono_image_alloc0 (image, sizeof (MonoClass*) * (found + 1));
for (i = 0, tmp = cons; i < found; ++i, tmp = tmp->next) {
- res [i] = tmp->data;
+ res [i] = (MonoClass *)tmp->data;
}
g_slist_free (cons);
*constraints = res;
mono_metadata_decode_row (tdef, i - 1, cols, MONO_GENERICPARAM_SIZE);
params = NULL;
n = 0;
- container = mono_image_alloc0 (image, sizeof (MonoGenericContainer));
- container->image = image;
+ container = (MonoGenericContainer *)mono_image_alloc0 (image, sizeof (MonoGenericContainer));
+ container->owner.image = image; // Temporarily mark as anonymous, but this will be overriden by caller
+ container->is_anonymous = TRUE;
do {
n++;
- params = g_realloc (params, sizeof (MonoGenericParamFull) * n);
+ params = (MonoGenericParamFull *)g_realloc (params, sizeof (MonoGenericParamFull) * n);
memset (¶ms [n - 1], 0, sizeof (MonoGenericParamFull));
params [n - 1].param.owner = container;
params [n - 1].param.num = cols [MONO_GENERICPARAM_NUMBER];
} while (cols [MONO_GENERICPARAM_OWNER] == owner);
container->type_argc = n;
- container->type_params = mono_image_alloc0 (image, sizeof (MonoGenericParamFull) * n);
+ container->type_params = (MonoGenericParamFull *)mono_image_alloc0 (image, sizeof (MonoGenericParamFull) * n);
memcpy (container->type_params, params, sizeof (MonoGenericParamFull) * n);
g_free (params);
container->parent = parent_container;
return NULL;
}
}
- type = *iter;
+ type = (MonoType **)*iter;
type++;
if (type < &sig->params [sig->param_count]) {
*iter = type;
return &method->klass->image->wrapper_caches;
}
}
+
+// This is support for the mempool reference tracking feature in checked-build, but lives in metadata.c due to use of static variables of this file.
+
+/**
+ * mono_find_image_set_owner:
+ *
+ * Find the imageset, if any, which a given pointer is located in the memory of.
+ */
+MonoImageSet *
+mono_find_image_set_owner (void *ptr)
+{
+ MonoImageSet *owner = NULL;
+ int i;
+
+ image_sets_lock ();
+
+ if (image_sets)
+ {
+ for (i = 0; !owner && i < image_sets->len; ++i) {
+ MonoImageSet *set = (MonoImageSet *)g_ptr_array_index (image_sets, i);
+ if (mono_mempool_contains_addr (set->mempool, ptr))
+ owner = set;
+ }
+ }
+
+ image_sets_unlock ();
+
+ return owner;
+}
projects / mono.git / blobdiff