#include <mono/metadata/mono-ptr-array.h>
#include <mono/utils/mono-string.h>
#include <mono/utils/mono-error-internals.h>
+#include <mono/utils/checked-build.h>
static gboolean is_usertype (MonoReflectionType *ref);
static MonoReflectionType *mono_reflection_type_resolve_user_types (MonoReflectionType *type);
{
}
+static inline void
+dynamic_image_lock (MonoDynamicImage *image)
+{
+ MONO_TRY_BLOCKING;
+ mono_image_lock ((MonoImage*)image);
+ MONO_FINISH_TRY_BLOCKING;
+}
+
+static inline void
+dynamic_image_unlock (MonoDynamicImage *image)
+{
+ mono_image_unlock ((MonoImage*)image);
+}
+
+static void
+register_dyn_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj)
+{
+ MONO_REQ_GC_UNSAFE_MODE;
+
+ dynamic_image_lock (assembly);
+ mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), obj);
+ dynamic_image_unlock (assembly);
+}
+
+static MonoObject*
+lookup_dyn_token (MonoDynamicImage *assembly, guint32 token)
+{
+ MONO_REQ_GC_UNSAFE_MODE;
+
+ MonoObject *obj;
+
+ dynamic_image_lock (assembly);
+ obj = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
+ dynamic_image_unlock (assembly);
+
+ return obj;
+}
+
static void
sigbuffer_init (SigBuffer *buf, int size)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
buf->buf = g_malloc (size);
buf->p = buf->buf;
buf->end = buf->buf + size;
static void
sigbuffer_make_room (SigBuffer *buf, int size)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
if (buf->end - buf->p < size) {
int new_size = buf->end - buf->buf + size + 32;
char *p = g_realloc (buf->buf, new_size);
static void
sigbuffer_add_value (SigBuffer *buf, guint32 val)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
sigbuffer_make_room (buf, 6);
mono_metadata_encode_value (val, buf->p, &buf->p);
}
static void
sigbuffer_add_byte (SigBuffer *buf, guint8 val)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
sigbuffer_make_room (buf, 1);
buf->p [0] = val;
buf->p++;
static void
sigbuffer_add_mem (SigBuffer *buf, char *p, guint32 size)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
sigbuffer_make_room (buf, size);
memcpy (buf->p, p, size);
buf->p += size;
static void
sigbuffer_free (SigBuffer *buf)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
g_free (buf->buf);
}
static gpointer
image_g_malloc (MonoImage *image, guint size)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
if (image)
return mono_image_alloc (image, size);
else
static gpointer
image_g_malloc0 (MonoImage *image, guint size)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
if (image)
return mono_image_alloc0 (image, size);
else
static char*
image_strdup (MonoImage *image, const char *s)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
if (image)
return mono_image_strdup (image, s);
else
static void
alloc_table (MonoDynamicTable *table, guint nrows)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
table->rows = nrows;
g_assert (table->columns);
if (nrows + 1 >= table->alloc_rows) {
static void
make_room_in_stream (MonoDynamicStream *stream, int size)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
if (size <= stream->alloc_size)
return;
static guint32
string_heap_insert (MonoDynamicStream *sh, const char *str)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
guint32 idx;
guint32 len;
gpointer oldkey, oldval;
static guint32
string_heap_insert_mstring (MonoDynamicStream *sh, MonoString *str)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
char *name = mono_string_to_utf8 (str);
guint32 idx;
idx = string_heap_insert (sh, name);
static void
string_heap_init (MonoDynamicStream *sh)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
sh->index = 0;
sh->alloc_size = 4096;
sh->data = g_malloc (4096);
static guint32
mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
guint32 idx;
make_room_in_stream (stream, stream->index + len);
static guint32
mono_image_add_stream_zero (MonoDynamicStream *stream, guint32 len)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
guint32 idx;
make_room_in_stream (stream, stream->index + len);
static void
stream_data_align (MonoDynamicStream *stream)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
char buf [4] = {0};
guint32 count = stream->index % 4;
static int
mono_blob_entry_hash (const char* str)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
guint len, h;
const char *end;
len = mono_metadata_decode_blob_size (str, &str);
static gboolean
mono_blob_entry_equal (const char *str1, const char *str2) {
+ MONO_REQ_GC_NEUTRAL_MODE;
+
int len, len2;
const char *end1;
const char *end2;
static guint32
add_to_blob_cached (MonoDynamicImage *assembly, char *b1, int s1, char *b2, int s2)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
guint32 idx;
char *copy;
gpointer oldkey, oldval;
static guint32
sigbuffer_add_to_blob_cached (MonoDynamicImage *assembly, SigBuffer *buf)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
char blob_size [8];
char *b = blob_size;
guint32 size = buf->p - buf->buf;
*/
static void
swap_with_size (char *dest, const char* val, int len, int nelem) {
+ MONO_REQ_GC_NEUTRAL_MODE;
#if G_BYTE_ORDER != G_LITTLE_ENDIAN
int elem;
static guint32
add_mono_string_to_blob_cached (MonoDynamicImage *assembly, MonoString *str)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
char blob_size [64];
char *b = blob_size;
guint32 idx = 0, len;
static MonoClass *
default_class_from_mono_type (MonoType *type)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
switch (type->type) {
case MONO_TYPE_OBJECT:
return mono_defaults.object_class;
gpointer
mono_class_get_ref_info (MonoClass *klass)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
if (klass->ref_info_handle == 0)
return NULL;
else
void
mono_class_set_ref_info (MonoClass *klass, gpointer obj)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
klass->ref_info_handle = mono_gchandle_new ((MonoObject*)obj, FALSE);
g_assert (klass->ref_info_handle != 0);
}
void
mono_class_free_ref_info (MonoClass *klass)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
if (klass->ref_info_handle) {
mono_gchandle_free (klass->ref_info_handle);
klass->ref_info_handle = 0;
static void
encode_generic_class (MonoDynamicImage *assembly, MonoGenericClass *gclass, SigBuffer *buf)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
int i;
MonoGenericInst *class_inst;
MonoClass *klass;
static void
encode_type (MonoDynamicImage *assembly, MonoType *type, SigBuffer *buf)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
if (!type) {
g_assert_not_reached ();
return;
static void
encode_reflection_type (MonoDynamicImage *assembly, MonoReflectionType *type, SigBuffer *buf)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
if (!type) {
sigbuffer_add_value (buf, MONO_TYPE_VOID);
return;
static void
encode_custom_modifiers (MonoDynamicImage *assembly, MonoArray *modreq, MonoArray *modopt, SigBuffer *buf)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
int i;
if (modreq) {
static guint32
method_encode_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
SigBuffer buf;
int i;
guint32 nparams = sig->param_count;
static guint32
method_builder_encode_signature (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
/*
* FIXME: reuse code from method_encode_signature().
*/
static guint32
encode_locals (MonoDynamicImage *assembly, MonoReflectionILGen *ilgen)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 *values;
guint32 idx, sig_idx;
static guint32
method_count_clauses (MonoReflectionILGen *ilgen)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
guint32 num_clauses = 0;
int i;
static MonoExceptionClause*
method_encode_clauses (MonoImage *image, MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, guint32 num_clauses)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoExceptionClause *clauses;
MonoExceptionClause *clause;
MonoILExceptionInfo *ex_info;
static guint32
method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
char flags = 0;
guint32 idx;
guint32 code_size;
static guint32
find_index_in_table (MonoDynamicImage *assembly, int table_idx, int col, guint32 token)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
int i;
MonoDynamicTable *table;
guint32 *values;
static MonoCustomAttrInfo*
lookup_custom_attr (MonoImage *image, gpointer member)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
MonoCustomAttrInfo* res;
res = mono_image_property_lookup (image, member, MONO_PROP_DYNAMIC_CATTR);
static gboolean
custom_attr_visible (MonoImage *image, MonoReflectionCustomAttr *cattr)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
/* FIXME: Need to do more checks */
if (cattr->ctor->method && (cattr->ctor->method->klass->image != image)) {
int visibility = cattr->ctor->method->klass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
static MonoCustomAttrInfo*
mono_custom_attrs_from_builders (MonoImage *alloc_img, MonoImage *image, MonoArray *cattrs)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
int i, index, count, not_visible;
MonoCustomAttrInfo *ainfo;
MonoReflectionCustomAttr *cattr;
static void
mono_save_custom_attrs (MonoImage *image, void *obj, MonoArray *cattrs)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoCustomAttrInfo *ainfo, *tmp;
if (!cattrs || !mono_array_length (cattrs))
void
mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
if (!ainfo->cached)
g_free (ainfo);
}
static void
mono_image_add_cattrs (MonoDynamicImage *assembly, guint32 idx, guint32 type, MonoArray *cattrs)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
MonoReflectionCustomAttr *cattr;
guint32 *values;
static void
mono_image_add_decl_security (MonoDynamicImage *assembly, guint32 parent_token, MonoArray *permissions)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 *values;
guint32 count, i, idx;
static void
mono_image_basic_method (ReflectionMethodBuilder *mb, MonoDynamicImage *assembly)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 *values;
guint i, count;
static void
reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
memset (rmb, 0, sizeof (ReflectionMethodBuilder));
rmb->ilgen = mb->ilgen;
static void
reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
const char *name = mb->attrs & METHOD_ATTRIBUTE_STATIC ? ".cctor": ".ctor";
memset (rmb, 0, sizeof (ReflectionMethodBuilder));
static void
reflection_methodbuilder_from_dynamic_method (ReflectionMethodBuilder *rmb, MonoReflectionDynamicMethod *mb)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
memset (rmb, 0, sizeof (ReflectionMethodBuilder));
rmb->ilgen = mb->ilgen;
static void
mono_image_add_methodimpl (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mb->type;
MonoDynamicTable *table;
guint32 *values;
static void
mono_image_get_method_info (MonoReflectionMethodBuilder *mb, MonoDynamicImage *assembly)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 *values;
ReflectionMethodBuilder rmb;
static void
mono_image_get_ctor_info (MonoDomain *domain, MonoReflectionCtorBuilder *mb, MonoDynamicImage *assembly)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
ReflectionMethodBuilder rmb;
reflection_methodbuilder_from_ctor_builder (&rmb, mb);
static char*
type_get_fully_qualified_name (MonoType *type)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
}
static char*
-type_get_qualified_name (MonoType *type, MonoAssembly *ass) {
+type_get_qualified_name (MonoType *type, MonoAssembly *ass)
+{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoClass *klass;
MonoAssembly *ta;
static guint32
fieldref_encode_signature (MonoDynamicImage *assembly, MonoImage *field_image, MonoType *type)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
SigBuffer buf;
guint32 idx, i, token;
static guint32
field_encode_signature (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
SigBuffer buf;
guint32 idx;
guint32 typespec = 0;
}
static guint32
-encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type) {
+encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type)
+{
+ MONO_REQ_GC_UNSAFE_MODE;
+
char blob_size [64];
char *b = blob_size;
- char *p, *box_val;
+ char *box_val;
char* buf;
guint32 idx = 0, len = 0, dummy = 0;
- p = buf = g_malloc (64);
+ buf = g_malloc (64);
if (!val) {
*ret_type = MONO_TYPE_CLASS;
len = 4;
}
static guint32
-encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo) {
+encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo)
+{
+ MONO_REQ_GC_UNSAFE_MODE;
+
char *str;
SigBuffer buf;
guint32 idx, len;
static void
mono_image_get_field_info (MonoReflectionFieldBuilder *fb, MonoDynamicImage *assembly)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 *values;
static guint32
property_encode_signature (MonoDynamicImage *assembly, MonoReflectionPropertyBuilder *fb)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
SigBuffer buf;
guint32 nparams = 0;
MonoReflectionMethodBuilder *mb = fb->get_method;
static void
mono_image_get_property_info (MonoReflectionPropertyBuilder *pb, MonoDynamicImage *assembly)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 *values;
guint num_methods = 0;
static void
mono_image_get_event_info (MonoReflectionEventBuilder *eb, MonoDynamicImage *assembly)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 *values;
guint num_methods = 0;
static void
encode_constraints (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 num_constraints, i;
guint32 *values;
static void
mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
GenericParamTableEntry *entry;
/*
static void
write_generic_param_entry (MonoDynamicImage *assembly, GenericParamTableEntry *entry)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
MonoGenericParam *param;
guint32 *values;
static guint32
resolution_scope_from_image (MonoDynamicImage *assembly, MonoImage *image)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 token;
guint32 *values;
static guint32
create_typespec (MonoDynamicImage *assembly, MonoType *type)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
MonoDynamicTable *table;
guint32 *values;
guint32 token;
static guint32
mono_image_typedef_or_ref_full (MonoDynamicImage *assembly, MonoType *type, gboolean try_typespec)
{
+ MONO_REQ_GC_UNSAFE_MODE;
+
MonoDynamicTable *table;
guint32 *values;
guint32 token, scope, enclosing;
(type->type != MONO_TYPE_MVAR)) {
MonoReflectionTypeBuilder *tb = mono_class_get_ref_info (klass);
token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
- mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), mono_class_get_ref_info (klass));
+ register_dyn_token (assembly, token, mono_class_get_ref_info (klass));
return token;
}
token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
table->next_idx ++;
- mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), mono_class_get_ref_info (klass));
+ register_dyn_token (assembly, token, mono_class_get_ref_info (klass));
return token;
}
static guint32
mono_image_add_memberef_row (MonoDynamicImage *assembly, guint32 parent, const char *name, guint32 sig)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
MonoDynamicTable *table;
guint32 *values;
guint32 token, pclass;
static guint32
mono_image_get_memberref_token (MonoDynamicImage *assembly, MonoType *type, const char *name, guint32 sig)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
guint32 parent = mono_image_typedef_or_ref (assembly, type);
return mono_image_add_memberef_row (assembly, parent, name, sig);
}
static guint32
mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec)
{
+ MONO_REQ_GC_NEUTRAL_MODE;
+
guint32 token;
MonoMethodSignature *sig;
guint32 token;
MonoClass *klass;
MonoGenericClass *gclass;
- MonoDynamicGenericClass *dgclass;
MonoType *type;
char *name;
klass = mono_class_from_mono_type (type);
gclass = type->data.generic_class;
g_assert (gclass->is_dynamic);
- dgclass = (MonoDynamicGenericClass *) gclass;
name = mono_string_to_utf8 (fb->name);
token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name,
if (is_sre_ctor_builder (mono_object_class (c->cb))) {
MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder *)c->cb;
- MonoDynamicGenericClass *dgclass;
ReflectionMethodBuilder rmb;
char *name;
gclass = type->data.generic_class;
g_assert (gclass->is_dynamic);
- dgclass = (MonoDynamicGenericClass *) gclass;
reflection_methodbuilder_from_ctor_builder (&rmb, cb);
static MonoMethod*
mono_reflection_method_on_tb_inst_get_handle (MonoReflectionMethodOnTypeBuilderInst *m)
{
+ MonoError error;
MonoClass *klass;
MonoGenericContext tmp_context;
MonoType **type_argv;
tmp_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL;
tmp_context.method_inst = ginst;
- inflated = mono_class_inflate_generic_method (method, &tmp_context);
+ inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
return inflated;
}
mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
{
MonoDynamicTable *table;
- MonoClass *klass;
MonoType *custom = NULL, *type;
guint32 *values;
guint32 token, pclass, parent, sig;
if (token)
return token;
- klass = mono_class_from_mono_type (mono_reflection_type_get_handle (fb->typeb));
+ /* FIXME: is this call necessary? */
+ mono_class_from_mono_type (mono_reflection_type_get_handle (fb->typeb));
name = mono_string_to_utf8 (fb->name);
/*FIXME this is one more layer of ugliness due how types are created.*/
{
SigBuffer buf;
guint32 nargs;
- guint32 size;
guint32 i, idx;
if (!assembly->save)
else
nargs = 0;
- size = 10 + (nargs * 10);
-
sigbuffer_init (&buf, 32);
/* Encode calling convention */
char buf [16];
char *b = buf;
- MONO_ARCH_SAVE_REGS;
-
if (!module->dynamic_image)
mono_image_module_basic_init (module);
idx = assembly->us.index ++;
}
- mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (MONO_TOKEN_STRING | idx), str);
+ register_dyn_token (assembly, MONO_TOKEN_STRING | idx, (MonoObject*)str);
return MONO_TOKEN_STRING | idx;
}
}
g_hash_table_insert (assembly->vararg_aux_hash, GUINT_TO_POINTER (token), sig);
- mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), obj);
+ register_dyn_token (assembly, token, obj);
return token;
}
void
mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj)
{
- MonoObject *prev = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
+ MonoObject *prev;
+
+ dynamic_image_lock (assembly);
+ prev = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
if (prev) {
/* There could be multiple MethodInfo objects with the same token */
//g_assert (prev == obj);
} else {
mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), obj);
}
+ dynamic_image_unlock (assembly);
}
static MonoDynamicImage*
MonoDynamicImage *image;
MonoDomain *domain = mono_object_domain (assemblyb);
- MONO_ARCH_SAVE_REGS;
-
if (assemblyb->dynamic_assembly)
return;
for (i = 0; i < inst->type_argc; ++i)
if (!verify_safe_for_managed_space (inst->type_argv [i]))
return FALSE;
- break;
+ return TRUE;
}
#endif
case MONO_TYPE_VAR:
case MONO_TYPE_MVAR:
return TRUE;
+ default:
+ return TRUE;
}
- return TRUE;
}
static MonoType*
g_ptr_array_add (info->type_arguments, subinfo);
+ while (*p == ' ') p++;
if (*p == '[') {
p++;
fqname = TRUE;
if (!image)
image = mono_defaults.corlib;
+ if (!rootimage)
+ rootimage = mono_defaults.corlib;
+
if (ignorecase) {
MonoError error;
klass = mono_class_from_name_case_checked (image, info->name_space, info->name, &error);
memset (params, 0, sizeof (void*) * sig->param_count);
} else {
/* Allocate using GC so it gets GC tracking */
- params = mono_gc_alloc_fixed (sig->param_count * sizeof (void*), NULL);
+ params = mono_gc_alloc_fixed (sig->param_count * sizeof (void*), MONO_GC_DESCRIPTOR_NULL);
}
/* skip prolog */
MonoCustomAttrInfo *ainfo;
GList *tmp, *list = NULL;
const char *data;
+ MonoCustomAttrEntry* attr;
ca = &image->tables [MONO_TABLE_CUSTOMATTRIBUTE];
ainfo = g_malloc0 (MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * len);
ainfo->num_attrs = len;
ainfo->image = image;
- for (i = 0, tmp = list; i < len; ++i, tmp = tmp->next) {
+ for (i = len, tmp = list; i != 0; --i, tmp = tmp->next) {
mono_metadata_decode_row (ca, GPOINTER_TO_UINT (tmp->data), cols, MONO_CUSTOM_ATTR_SIZE);
mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> MONO_CUSTOM_ATTR_TYPE_BITS;
switch (cols [MONO_CUSTOM_ATTR_TYPE] & MONO_CUSTOM_ATTR_TYPE_MASK) {
g_error ("Unknown table for custom attr type %08x", cols [MONO_CUSTOM_ATTR_TYPE]);
break;
}
- ainfo->attrs [i].ctor = mono_get_method (image, mtoken, NULL);
- if (!ainfo->attrs [i].ctor) {
+ attr = &ainfo->attrs [i - 1];
+ attr->ctor = mono_get_method (image, mtoken, NULL);
+ if (!attr->ctor) {
g_warning ("Can't find custom attr constructor image: %s mtoken: 0x%08x", image->name, mtoken);
g_list_free (list);
g_free (ainfo);
return NULL;
}
data = mono_metadata_blob_heap (image, cols [MONO_CUSTOM_ATTR_VALUE]);
- ainfo->attrs [i].data_size = mono_metadata_decode_value (data, &data);
- ainfo->attrs [i].data = (guchar*)data;
+ attr->data_size = mono_metadata_decode_value (data, &data);
+ attr->data = (guchar*)data;
}
g_list_free (list);
char *buffer, *p;
guint32 buflen, i;
- MONO_ARCH_SAVE_REGS;
-
if (strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
/* sig is freed later so allocate it in the heap */
sig = ctor_builder_to_signature (NULL, (MonoReflectionCtorBuilder*)ctor);
MonoError error;
MonoClass *klass, *parent;
- MONO_ARCH_SAVE_REGS;
-
RESOLVE_TYPE (tb->parent);
mono_loader_lock ();
g_assert (mono_class_get_ref_info (klass) == tb);
}
- mono_g_hash_table_insert (tb->module->dynamic_image->tokens,
- GUINT_TO_POINTER (MONO_TOKEN_TYPE_DEF | tb->table_idx), tb);
+ register_dyn_token (tb->module->dynamic_image, MONO_TOKEN_TYPE_DEF | tb->table_idx, (MonoObject*)tb);
if (parent != NULL) {
mono_class_setup_parent (klass, parent);
MonoClass *klass;
int count, i;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (tb->type.type);
count = tb->generic_params ? mono_array_length (tb->generic_params) : 0;
{
MonoClass *klass;
- MONO_ARCH_SAVE_REGS;
-
klass = mono_class_from_mono_type (tb->type.type);
mono_loader_lock ();
MonoClass *klass;
MonoReflectionTypeBuilder *tb = NULL;
gboolean is_dynamic = FALSE;
- MonoDomain *domain;
MonoClass *geninst;
mono_loader_lock ();
- domain = mono_object_domain (type);
-
if (is_sre_type_builder (mono_object_class (type))) {
tb = (MonoReflectionTypeBuilder *) type;
MonoReflectionMethod*
mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types)
{
+ MonoError error;
MonoClass *klass;
MonoMethod *method, *inflated;
MonoMethodInflated *imethod;
MonoType **type_argv;
int count, i;
- MONO_ARCH_SAVE_REGS;
-
/*FIXME but this no longer should happen*/
if (!strcmp (rmethod->object.vtable->klass->name, "MethodBuilder")) {
#ifndef DISABLE_REFLECTION_EMIT
tmp_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL;
tmp_context.method_inst = ginst;
- inflated = mono_class_inflate_generic_method (method, &tmp_context);
+ inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
imethod = (MonoMethodInflated *) inflated;
/*FIXME but I think this is no longer necessary*/
g_assert (i < klass->method.count);
imethod = (MonoMethodInflated*)klass->methods [i];
} else {
- imethod = (MonoMethodInflated *) mono_class_inflate_generic_method_full (method, klass, context);
+ MonoError error;
+ imethod = (MonoMethodInflated *) mono_class_inflate_generic_method_full_checked (method, klass, context, &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
if (method->is_generic && image_is_dynamic (method->klass->image)) {
MonoType *gtype;
int i;
- MONO_ARCH_SAVE_REGS;
-
gtype = mono_reflection_type_get_handle ((MonoReflectionType*)type);
klass = mono_class_from_mono_type (gtype);
g_assert (gtype->type == MONO_TYPE_GENERICINST);
klass->methods = mono_image_alloc (klass->image, sizeof (MonoMethod*) * (klass->method.count + 1));
for (i = 0; i < klass->method.count; i++) {
- klass->methods [i] = mono_class_inflate_generic_method_full (
- gklass->methods [i], klass, mono_class_get_context (klass));
+ MonoError error;
+ klass->methods [i] = mono_class_inflate_generic_method_full_checked (
+ gklass->methods [i], klass, mono_class_get_context (klass), &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
}
}
mono_error_init (error);
if (tb->class_size) {
- if ((tb->packing_size & 0xfffffff0) != 0) {
- char *err_msg = g_strdup_printf ("Could not load struct '%s' with packing size %d >= 16", klass->name, tb->packing_size);
+ if ((tb->packing_size & 0xffffff00) != 0) {
+ char *err_msg = g_strdup_printf ("Could not load struct '%s' with packing size %d >= 256", klass->name, tb->packing_size);
mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg);
return;
}
MonoReflectionType* res;
int i, j;
- MONO_ARCH_SAVE_REGS;
-
domain = mono_object_domain (tb);
klass = mono_class_from_mono_type (tb->type.type);
MonoClass *pklass;
MonoError error;
- MONO_ARCH_SAVE_REGS;
-
image = &gparam->tbuilder->module->dynamic_image->image;
param = mono_image_new0 (image, MonoGenericParamFull, 1);
free_dynamic_method (void *dynamic_method)
{
DynamicMethodReleaseData *data = dynamic_method;
+ MonoDomain *domain = data->domain;
+ MonoMethod *method = data->handle;
+ gpointer *dis_link;
- mono_runtime_free_method (data->domain, data->handle);
+ mono_domain_lock (domain);
+ dis_link = g_hash_table_lookup (domain->method_to_dyn_method, method);
+ g_hash_table_remove (domain->method_to_dyn_method, method);
+ mono_domain_unlock (domain);
+ g_assert (dis_link);
+ mono_gc_weak_link_remove (dis_link, TRUE);
+ g_free (dis_link);
+
+ mono_runtime_free_method (domain, method);
g_free (data);
}
ReflectionMethodBuilder rmb;
MonoMethodSignature *sig;
MonoClass *klass;
+ MonoDomain *domain;
GSList *l;
+ void *dis_link;
int i;
if (mono_runtime_is_shutting_down ())
/* ilgen is no longer needed */
mb->ilgen = NULL;
+
+ domain = mono_domain_get ();
+ mono_domain_lock (domain);
+ if (!domain->method_to_dyn_method)
+ domain->method_to_dyn_method = g_hash_table_new (NULL, NULL);
+ dis_link = g_new0 (gpointer, 1);
+ mono_gc_weak_link_add (dis_link, (MonoObject*)mb, TRUE);
+ g_hash_table_insert (domain->method_to_dyn_method, handle, dis_link);
+ mono_domain_unlock (domain);
}
#endif /* DISABLE_REFLECTION_EMIT */
gboolean
mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token)
{
- return mono_g_hash_table_lookup (image->tokens, GUINT_TO_POINTER (token)) != NULL;
+ return lookup_dyn_token (image, token) != NULL;
}
MonoMethodSignature *
-mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token)
+mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error)
{
MonoMethodSignature *sig;
g_assert (image_is_dynamic (image));
+ mono_error_init (error);
+
sig = g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
if (sig)
return sig;
- return mono_method_signature (method);
+ return mono_method_signature_checked (method, error);
}
#ifndef DISABLE_REFLECTION_EMIT
MonoObject *obj;
MonoClass *klass;
- mono_loader_lock ();
- obj = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
- mono_loader_unlock ();
+ obj = lookup_dyn_token (assembly, token);
if (!obj) {
if (valid_token)
g_error ("Could not find required dynamic token 0x%08x", token);
strcmp (obj->vtable->klass->name, "MonoGenericCMethod") == 0 ||
strcmp (obj->vtable->klass->name, "MonoGenericMethod") == 0) {
result = ((MonoReflectionMethod*)obj)->method;
- if (context)
- result = mono_class_inflate_generic_method (result, context);
+ if (context) {
+ MonoError error;
+ result = mono_class_inflate_generic_method_checked (result, context, &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
+ }
*handle_class = mono_defaults.methodhandle_class;
g_assert (result);
} else if (strcmp (obj->vtable->klass->name, "MethodBuilder") == 0) {
*/
result = mb->mhandle;
}
- if (context)
- result = mono_class_inflate_generic_method (result, context);
+ if (context) {
+ MonoError error;
+ result = mono_class_inflate_generic_method_checked (result, context, &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
+ }
*handle_class = mono_defaults.methodhandle_class;
} else if (strcmp (obj->vtable->klass->name, "ConstructorBuilder") == 0) {
MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder*)obj;
mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
result = cb->mhandle;
}
- if (context)
- result = mono_class_inflate_generic_method (result, context);
+ if (context) {
+ MonoError error;
+ result = mono_class_inflate_generic_method_checked (result, context, &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
+ }
*handle_class = mono_defaults.methodhandle_class;
} else if (strcmp (obj->vtable->klass->name, "MonoField") == 0) {
MonoClassField *field = ((MonoReflectionField*)obj)->field;
MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj;
if (m->method_args) {
result = mono_reflection_method_on_tb_inst_get_handle (m);
- if (context)
- result = mono_class_inflate_generic_method (result, context);
+ if (context) {
+ MonoError error;
+ result = mono_class_inflate_generic_method_checked (result, context, &error);
+ g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
+ }
} else {
MonoType *type = mono_class_inflate_generic_type (mono_reflection_type_get_handle ((MonoReflectionType*)m->inst), context);
MonoClass *inflated_klass = mono_class_from_mono_type (type);