*
* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
+ * Copyright 2011 Rodrigo Kumpera
*
*/
#include <config.h>
#include <mono/utils/mono-string.h>
#include <mono/utils/mono-error-internals.h>
-
-#if HAVE_SGEN_GC
-static void* reflection_info_desc = NULL;
-#define MOVING_GC_REGISTER(addr) do { \
- if (!reflection_info_desc) { \
- gsize bmap = 1; \
- reflection_info_desc = mono_gc_make_descr_from_bitmap (&bmap, 1); \
- } \
- mono_gc_register_root ((char*)(addr), sizeof (gpointer), reflection_info_desc); \
- } while (0)
-#else
-#define MOVING_GC_REGISTER(addr)
-#endif
-
static gboolean is_usertype (MonoReflectionType *ref);
static MonoReflectionType *mono_reflection_type_resolve_user_types (MonoReflectionType *type);
#ifndef DISABLE_REFLECTION_EMIT
static guint32 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec);
-static guint32 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_methodspec);
+static guint32 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_open_instance);
static guint32 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *cb);
static guint32 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper);
static void ensure_runtime_vtable (MonoClass *klass);
static guint32 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m);
static MonoMethod * inflate_method (MonoReflectionType *type, MonoObject *obj);
+static guint32 create_typespec (MonoDynamicImage *assembly, MonoType *type);
+static void init_type_builder_generics (MonoObject *type);
+
#define RESOLVE_TYPE(type) do { type = (void*)mono_reflection_type_resolve_user_types ((MonoReflectionType*)type); } while (0)
#define RESOLVE_ARRAY_TYPE_ELEMENT(array, index) do { \
MonoReflectionType *__type = mono_array_get (array, MonoReflectionType*, index); \
if (!res)
return NULL;
- return g_memdup (res, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * res->num_attrs);
+ res = g_memdup (res, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * res->num_attrs);
+ res->cached = 0;
+ return res;
}
static gboolean
switch (mono_metadata_token_table (token)) {
case MONO_TABLE_METHOD:
type |= MONO_CUSTOM_ATTR_TYPE_METHODDEF;
+ /*
+ * fixup_cattrs () needs to fix this up. We can't use image->tokens, since it contains the old token for the
+ * method, not the one returned by mono_image_create_token ().
+ */
+ mono_g_hash_table_insert (assembly->remapped_tokens, GUINT_TO_POINTER (token), cattr->ctor);
break;
case MONO_TABLE_MEMBERREF:
type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
MonoDynamicTable *table;
guint32 *values;
guint32 tok;
+ MonoReflectionMethod *m;
+ int i;
- if (!mb->override_method)
+ if (!mb->override_methods)
return;
- table = &assembly->tables [MONO_TABLE_METHODIMPL];
- table->rows ++;
- alloc_table (table, table->rows);
- values = table->values + table->rows * MONO_METHODIMPL_SIZE;
- values [MONO_METHODIMPL_CLASS] = tb->table_idx;
- values [MONO_METHODIMPL_BODY] = MONO_METHODDEFORREF_METHODDEF | (mb->table_idx << MONO_METHODDEFORREF_BITS);
+ for (i = 0; i < mono_array_length (mb->override_methods); ++i) {
+ m = mono_array_get (mb->override_methods, MonoReflectionMethod*, i);
- tok = mono_image_create_token (assembly, (MonoObject*)mb->override_method, FALSE, FALSE);
- switch (mono_metadata_token_table (tok)) {
- case MONO_TABLE_MEMBERREF:
- tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODREF;
- break;
- case MONO_TABLE_METHOD:
- tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODDEF;
- break;
- default:
- g_assert_not_reached ();
+ table = &assembly->tables [MONO_TABLE_METHODIMPL];
+ table->rows ++;
+ alloc_table (table, table->rows);
+ values = table->values + table->rows * MONO_METHODIMPL_SIZE;
+ values [MONO_METHODIMPL_CLASS] = tb->table_idx;
+ values [MONO_METHODIMPL_BODY] = MONO_METHODDEFORREF_METHODDEF | (mb->table_idx << MONO_METHODDEFORREF_BITS);
+
+ tok = mono_image_create_token (assembly, (MonoObject*)m, FALSE, FALSE);
+ switch (mono_metadata_token_table (tok)) {
+ case MONO_TABLE_MEMBERREF:
+ tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODREF;
+ break;
+ case MONO_TABLE_METHOD:
+ tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODDEF;
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+ values [MONO_METHODIMPL_DECLARATION] = tok;
}
- values [MONO_METHODIMPL_DECLARATION] = tok;
}
#ifndef DISABLE_REFLECTION_EMIT
{
SigBuffer buf;
guint32 idx;
+ guint32 typespec = 0;
+ MonoType *type;
+ MonoClass *class;
+
+ init_type_builder_generics (fb->type);
+
+ type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type);
+ class = mono_class_from_mono_type (type);
sigbuffer_init (&buf, 32);
sigbuffer_add_value (&buf, 0x06);
encode_custom_modifiers (assembly, fb->modreq, fb->modopt, &buf);
/* encode custom attributes before the type */
- encode_reflection_type (assembly, (MonoReflectionType*)fb->type, &buf);
+
+ if (class->generic_container)
+ typespec = create_typespec (assembly, type);
+
+ if (typespec) {
+ MonoGenericClass *gclass;
+ gclass = mono_metadata_lookup_generic_class (class, class->generic_container->context.class_inst, TRUE);
+ encode_generic_class (assembly, gclass, &buf);
+ } else {
+ encode_type (assembly, type, &buf);
+ }
idx = sigbuffer_add_to_blob_cached (assembly, &buf);
sigbuffer_free (&buf);
return idx;
entry = g_new0 (GenericParamTableEntry, 1);
entry->owner = owner;
/* FIXME: track where gen_params should be freed and remove the GC root as well */
- MOVING_GC_REGISTER (&entry->gparam);
+ MONO_GC_REGISTER_ROOT_IF_MOVING (entry->gparam);
entry->gparam = gparam;
g_ptr_array_add (assembly->gen_params, entry);
if (token)
return token;
- g_assert (tb->generic_params);
-
reflection_methodbuilder_from_ctor_builder (&rmb, mb);
- parent = create_generic_typespec (assembly, tb);
+ if (tb->generic_params)
+ parent = create_generic_typespec (assembly, tb);
+ else
+ parent = mono_image_typedef_or_ref (assembly, mono_reflection_type_get_handle ((MonoReflectionType*)tb));
+
name = mono_string_to_utf8 (rmb.name);
sig = method_builder_encode_signature (assembly, &rmb);
if (is_field_on_inst (field))
type = get_field_on_inst_generic_type (field);
else
- type = field->type;
+ type = mono_field_get_type (field);
}
token = mono_image_get_memberref_token (assembly, &field->parent->byval_arg,
mono_field_get_name (field),
MonoMethod *method, *inflated;
int count, i;
+ init_type_builder_generics ((MonoObject*)m->inst);
+
method = inflate_method (m->inst, (MonoObject*)m->mb);
klass = method->klass;
return t;
}
+static void
+init_type_builder_generics (MonoObject *type)
+{
+ MonoReflectionTypeBuilder *tb;
+
+ if (!is_sre_type_builder(mono_object_class (type)))
+ return;
+ tb = (MonoReflectionTypeBuilder *)type;
+
+ if (tb && tb->generic_container)
+ mono_reflection_create_generic_class (tb);
+}
+
static guint32
mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
{
MonoDynamicTable *table;
MonoClass *klass;
- MonoType *custom = NULL;
+ MonoType *custom = NULL, *type;
guint32 *values;
guint32 token, pclass, parent, sig;
gchar *name;
klass = 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.*/
+ init_type_builder_generics (fb->type);
+
/* fb->type does not include the custom modifiers */
/* FIXME: We should do this in one place when a fieldbuilder is created */
- if (fb->modreq || fb->modopt) {
- custom = add_custom_modifiers (assembly, mono_reflection_type_get_handle ((MonoReflectionType*)fb->type), fb->modreq, fb->modopt);
- sig = fieldref_encode_signature (assembly, NULL, custom);
- g_free (custom);
- } else {
- sig = fieldref_encode_signature (assembly, NULL, mono_reflection_type_get_handle ((MonoReflectionType*)fb->type));
- }
+ type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type);
+ if (fb->modreq || fb->modopt)
+ type = custom = add_custom_modifiers (assembly, type, fb->modreq, fb->modopt);
+
+ sig = fieldref_encode_signature (assembly, NULL, type);
+ g_free (custom);
parent = create_generic_typespec (assembly, (MonoReflectionTypeBuilder *) fb->typeb);
g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC);
if ((type & MONO_CUSTOM_ATTR_TYPE_MASK) == MONO_CUSTOM_ATTR_TYPE_METHODDEF) {
idx = type >> MONO_CUSTOM_ATTR_TYPE_BITS;
token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
- ctor = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
+ ctor = mono_g_hash_table_lookup (assembly->remapped_tokens, GUINT_TO_POINTER (token));
g_assert (ctor);
if (!strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
MonoMethod *m = ((MonoReflectionMethod*)ctor)->method;
idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
+ } else if (!strcmp (ctor->vtable->klass->name, "ConstructorBuilder")) {
+ MonoMethod *m = ((MonoReflectionCtorBuilder*)ctor)->mhandle;
+ idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
+ values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
}
}
}
*/
guint32
mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj,
- gboolean create_methodspec, gboolean register_token)
+ gboolean create_open_instance, gboolean register_token)
{
MonoClass *klass;
guint32 token = 0;
if (tb->module->dynamic_image == assembly && !tb->generic_params && !mb->generic_params)
token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
else
- token = mono_image_get_methodbuilder_token (assembly, mb, create_methodspec);
+ token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance);
/*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
} else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
if (tb->generic_params) {
token = mono_image_get_generic_field_token (assembly, fb);
} else {
- if ((tb->module->dynamic_image == assembly)) {
+ if (tb->module->dynamic_image == assembly) {
token = fb->table_idx | MONO_TOKEN_FIELD_DEF;
} else {
token = mono_image_get_fieldref_token (assembly, (MonoObject*)fb, fb->handle);
}
} else if (strcmp (klass->name, "TypeBuilder") == 0) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
- token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
+ if (create_open_instance && tb->generic_params) {
+ MonoType *type;
+ init_type_builder_generics (obj);
+ type = mono_reflection_type_get_handle ((MonoReflectionType *)obj);
+ token = mono_image_typedef_or_ref_full (assembly, type, TRUE);
+ token = mono_metadata_token_from_dor (token);
+ } else if (tb->module->dynamic_image == assembly) {
+ token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
+ } else {
+ MonoType *type;
+ type = mono_reflection_type_get_handle ((MonoReflectionType *)obj);
+ token = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, type));
+ }
} else if (strcmp (klass->name, "MonoType") == 0) {
MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj);
MonoClass *mc = mono_class_from_mono_type (type);
- if (!mono_class_init (mc))
- mono_raise_exception (mono_class_get_exception_for_failure (mc));
-
token = mono_metadata_token_from_dor (
- mono_image_typedef_or_ref_full (assembly, type, mc->generic_container == NULL));
+ mono_image_typedef_or_ref_full (assembly, type, mc->generic_container == NULL || create_open_instance));
} else if (strcmp (klass->name, "GenericTypeParameterBuilder") == 0) {
MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj);
token = mono_metadata_token_from_dor (
strcmp (klass->name, "MonoGenericCMethod") == 0) {
MonoReflectionMethod *m = (MonoReflectionMethod *)obj;
if (m->method->is_inflated) {
- if (create_methodspec)
+ if (create_open_instance)
token = mono_image_get_methodspec_token (assembly, m->method);
else
token = mono_image_get_inflated_method_token (assembly, m->method);
token = MONO_TOKEN_METHOD_DEF | method_table_idx;
}
} else {
- token = mono_image_get_methodref_token (assembly, m->method, create_methodspec);
+ token = mono_image_get_methodref_token (assembly, m->method, create_open_instance);
}
/*g_print ("got token 0x%08x for %s\n", token, m->method->name);*/
} else if (strcmp (klass->name, "MonoField") == 0) {
token = mono_image_get_field_on_inst_token (assembly, f);
} else if (strcmp (klass->name, "ConstructorOnTypeBuilderInst") == 0) {
MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)obj;
- token = mono_image_get_ctor_on_inst_token (assembly, c, create_methodspec);
+ token = mono_image_get_ctor_on_inst_token (assembly, c, create_open_instance);
} else if (strcmp (klass->name, "MethodOnTypeBuilderInst") == 0) {
MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj;
- token = mono_image_get_method_on_inst_token (assembly, m, create_methodspec);
+ token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance);
} else if (is_sre_array (klass) || is_sre_byref (klass) || is_sre_pointer (klass)) {
MonoReflectionType *type = (MonoReflectionType *)obj;
token = mono_metadata_token_from_dor (
image->typeref = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
image->blob_cache = g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal);
image->gen_params = g_ptr_array_new ();
+ image->remapped_tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC);
/*g_print ("string heap create for image %p (%s)\n", image, module_name);*/
string_heap_init (&image->sheap);
g_free (key);
}
+static void
+release_hashtable (MonoGHashTable **hash)
+{
+ if (*hash) {
+ mono_g_hash_table_destroy (*hash);
+ *hash = NULL;
+ }
+}
+
+void
+mono_dynamic_image_release_gc_roots (MonoDynamicImage *image)
+{
+ release_hashtable (&image->token_fixups);
+ release_hashtable (&image->handleref_managed);
+ release_hashtable (&image->tokens);
+ release_hashtable (&image->remapped_tokens);
+ release_hashtable (&image->generic_def_objects);
+ release_hashtable (&image->methodspec);
+}
+
void
mono_dynamic_image_free (MonoDynamicImage *image)
{
mono_g_hash_table_destroy (di->handleref_managed);
if (di->tokens)
mono_g_hash_table_destroy (di->tokens);
+ if (di->remapped_tokens)
+ mono_g_hash_table_destroy (di->remapped_tokens);
if (di->generic_def_objects)
mono_g_hash_table_destroy (di->generic_def_objects);
if (di->blob_cache) {
if (di->gen_params) {
for (i = 0; i < di->gen_params->len; i++) {
GenericParamTableEntry *entry = g_ptr_array_index (di->gen_params, i);
- if (entry->gparam->type.type) {
- MonoGenericParam *param = entry->gparam->type.type->data.generic_param;
- g_free ((char*)mono_generic_param_info (param)->name);
- g_free (param);
- }
mono_gc_deregister_root ((char*) &entry->gparam);
g_free (entry);
}
return res;
}
-static gboolean
-mymono_metadata_type_equal (MonoType *t1, MonoType *t2)
-{
- if ((t1->type != t2->type) ||
- (t1->byref != t2->byref))
- return FALSE;
-
- switch (t1->type) {
- case MONO_TYPE_VOID:
- case MONO_TYPE_BOOLEAN:
- case MONO_TYPE_CHAR:
- case MONO_TYPE_I1:
- case MONO_TYPE_U1:
- case MONO_TYPE_I2:
- case MONO_TYPE_U2:
- case MONO_TYPE_I4:
- case MONO_TYPE_U4:
- case MONO_TYPE_I8:
- case MONO_TYPE_U8:
- case MONO_TYPE_R4:
- case MONO_TYPE_R8:
- case MONO_TYPE_STRING:
- case MONO_TYPE_I:
- case MONO_TYPE_U:
- case MONO_TYPE_OBJECT:
- case MONO_TYPE_TYPEDBYREF:
- return TRUE;
- case MONO_TYPE_VALUETYPE:
- case MONO_TYPE_CLASS:
- case MONO_TYPE_SZARRAY:
- return t1->data.klass == t2->data.klass;
- case MONO_TYPE_PTR:
- return mymono_metadata_type_equal (t1->data.type, t2->data.type);
- case MONO_TYPE_ARRAY:
- if (t1->data.array->rank != t2->data.array->rank)
- return FALSE;
- return t1->data.array->eklass == t2->data.array->eklass;
- case MONO_TYPE_GENERICINST: {
- int i;
- MonoGenericInst *i1 = t1->data.generic_class->context.class_inst;
- MonoGenericInst *i2 = t2->data.generic_class->context.class_inst;
- if (i1->type_argc != i2->type_argc)
- return FALSE;
- if (!mono_metadata_type_equal (&t1->data.generic_class->container_class->byval_arg,
- &t2->data.generic_class->container_class->byval_arg))
- return FALSE;
- /* FIXME: we should probably just compare the instance pointers directly. */
- for (i = 0; i < i1->type_argc; ++i) {
- if (!mono_metadata_type_equal (i1->type_argv [i], i2->type_argv [i]))
- return FALSE;
- }
- return TRUE;
- }
- case MONO_TYPE_VAR:
- case MONO_TYPE_MVAR:
- return t1->data.generic_param == t2->data.generic_param;
- default:
- g_error ("implement type compare for %0x!", t1->type);
- return FALSE;
- }
-
- return FALSE;
-}
-
-static guint
-mymono_metadata_type_hash (MonoType *t1)
-{
- guint hash;
-
- hash = t1->type;
-
- hash |= t1->byref << 6; /* do not collide with t1->type values */
- switch (t1->type) {
- case MONO_TYPE_VALUETYPE:
- case MONO_TYPE_CLASS:
- case MONO_TYPE_SZARRAY:
- /* check if the distribution is good enough */
- return ((hash << 5) - hash) ^ g_str_hash (t1->data.klass->name);
- case MONO_TYPE_PTR:
- return ((hash << 5) - hash) ^ mymono_metadata_type_hash (t1->data.type);
- case MONO_TYPE_GENERICINST: {
- int i;
- MonoGenericInst *inst = t1->data.generic_class->context.class_inst;
- hash += g_str_hash (t1->data.generic_class->container_class->name);
- hash *= 13;
- for (i = 0; i < inst->type_argc; ++i) {
- hash += mymono_metadata_type_hash (inst->type_argv [i]);
- hash *= 13;
- }
- return hash;
- }
- }
- return hash;
-}
-
static gboolean
verify_safe_for_managed_space (MonoType *type)
{
mono_loader_lock (); /*FIXME mono_class_init and mono_class_vtable acquire it*/
mono_domain_lock (domain);
if (!domain->type_hash)
- domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mymono_metadata_type_hash,
- (GCompareFunc)mymono_metadata_type_equal, MONO_HASH_VALUE_GC);
+ domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
+ (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC);
if ((res = mono_g_hash_table_lookup (domain->type_hash, type))) {
mono_domain_unlock (domain);
mono_loader_unlock ();
return mono_class_get_ref_info (klass);
}
}
-#ifdef HAVE_SGEN_GC
- res = (MonoReflectionType *)mono_gc_alloc_pinned_obj (mono_class_vtable (domain, mono_defaults.monotype_class), mono_class_instance_size (mono_defaults.monotype_class));
-#else
- res = (MonoReflectionType *)mono_object_new (domain, mono_defaults.monotype_class);
-#endif
+ /* This is stored in vtables/JITted code so it has to be pinned */
+ res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.monotype_class);
res->type = type;
mono_g_hash_table_insert (domain->type_hash, type, res);
res->klass = klass;
res->field = field;
MONO_OBJECT_SETREF (res, name, mono_string_new (domain, mono_field_get_name (field)));
- if (is_field_on_inst (field))
+
+ if (is_field_on_inst (field)) {
res->attrs = get_field_on_inst_generic_type (field)->attrs;
- else
- res->attrs = field->type->attrs;
- MONO_OBJECT_SETREF (res, type, mono_type_get_object (domain, field->type));
+ MONO_OBJECT_SETREF (res, type, mono_type_get_object (domain, field->type));
+ } else {
+ if (field->type)
+ MONO_OBJECT_SETREF (res, type, mono_type_get_object (domain, field->type));
+ res->attrs = mono_field_get_flags (field);
+ }
CACHE_OBJECT (MonoReflectionField *, field, res, klass);
}
{
static MonoClass *System_Reflection_ParameterInfo;
static MonoClass *System_Reflection_ParameterInfo_array;
+ MonoError error;
MonoArray *res = NULL;
MonoReflectionMethod *member = NULL;
MonoReflectionParameter *param = NULL;
mono_memory_barrier ();
System_Reflection_ParameterInfo_array = klass;
}
-
- if (!mono_method_signature (method)->param_count)
+
+ sig = mono_method_signature_checked (method, &error);
+ if (!mono_error_ok (&error))
+ mono_error_raise_exception (&error);
+
+ if (!sig->param_count)
return mono_array_new_specific (mono_class_vtable (domain, System_Reflection_ParameterInfo_array), 0);
/* Note: the cache is based on the address of the signature into the method
*/
CHECK_OBJECT (MonoArray*, &(method->signature), refclass);
- sig = mono_method_signature (method);
member = mono_method_get_object (domain, method, refclass);
names = g_new (char *, sig->param_count);
mono_method_get_param_names (method, (const char **) names);
}
if (mspecs [i + 1])
- MONO_OBJECT_SETREF (param, MarshalAsImpl, (MonoObject*)mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [i + 1]));
+ MONO_OBJECT_SETREF (param, MarshalAsImpl, (MonoObject*)mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [i + 1]));
mono_array_setref (res, i, param);
}
static MonoClass *System_Reflection_ExceptionHandlingClause = NULL;
MonoReflectionMethodBody *ret;
MonoMethodHeader *header;
+ MonoImage *image;
guint32 method_rva, local_var_sig_token;
char *ptr;
unsigned char format, flags;
int i;
+ /* for compatibility with .net */
+ if (method->dynamic)
+ mono_raise_exception (mono_get_exception_invalid_operation (NULL));
+
if (!System_Reflection_MethodBody)
System_Reflection_MethodBody = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MethodBody");
if (!System_Reflection_LocalVariableInfo)
(method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
(method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME))
return NULL;
+
+ image = method->klass->image;
header = mono_method_get_header (method);
-
- /* Obtain local vars signature token */
- method_rva = mono_metadata_decode_row_col (&method->klass->image->tables [MONO_TABLE_METHOD], mono_metadata_token_index (method->token) - 1, MONO_METHOD_RVA);
- ptr = mono_image_rva_map (method->klass->image, method_rva);
- flags = *(const unsigned char *) ptr;
- format = flags & METHOD_HEADER_FORMAT_MASK;
- switch (format){
- case METHOD_HEADER_TINY_FORMAT:
- local_var_sig_token = 0;
- break;
- case METHOD_HEADER_FAT_FORMAT:
- ptr += 2;
- ptr += 2;
- ptr += 4;
- local_var_sig_token = read32 (ptr);
- break;
- default:
- g_assert_not_reached ();
- }
+
+ if (!image->dynamic) {
+ /* Obtain local vars signature token */
+ method_rva = mono_metadata_decode_row_col (&image->tables [MONO_TABLE_METHOD], mono_metadata_token_index (method->token) - 1, MONO_METHOD_RVA);
+ ptr = mono_image_rva_map (image, method_rva);
+ flags = *(const unsigned char *) ptr;
+ format = flags & METHOD_HEADER_FORMAT_MASK;
+ switch (format){
+ case METHOD_HEADER_TINY_FORMAT:
+ local_var_sig_token = 0;
+ break;
+ case METHOD_HEADER_FAT_FORMAT:
+ ptr += 2;
+ ptr += 2;
+ ptr += 4;
+ local_var_sig_token = read32 (ptr);
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+ } else
+ local_var_sig_token = 0; //FIXME
ret = (MonoReflectionMethodBody*)mono_object_new (domain, System_Reflection_MethodBody);
assembly_name_to_aname (MonoAssemblyName *assembly, char *p) {
int found_sep;
char *s;
+ gboolean quoted = FALSE;
memset (assembly, 0, sizeof (MonoAssemblyName));
- assembly->name = p;
assembly->culture = "";
memset (assembly->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
- while (*p && (isalnum (*p) || *p == '.' || *p == '-' || *p == '_' || *p == '$' || *p == '@'))
+ if (*p == '"') {
+ quoted = TRUE;
+ p++;
+ }
+ assembly->name = p;
+ while (*p && (isalnum (*p) || *p == '.' || *p == '-' || *p == '_' || *p == '$' || *p == '@' || g_ascii_isspace (*p)))
p++;
- found_sep = 0;
- while (g_ascii_isspace (*p) || *p == ',') {
- *p++ = 0;
- found_sep = 1;
- continue;
- }
- /* failed */
- if (!found_sep)
+ if (quoted) {
+ if (*p != '"')
+ return 1;
+ *p = 0;
+ p++;
+ }
+ if (*p != ',')
return 1;
+ *p = 0;
+ /* Remove trailing whitespace */
+ s = p - 1;
+ while (*s && g_ascii_isspace (*s))
+ *s-- = 0;
+ p ++;
+ while (g_ascii_isspace (*p))
+ p++;
while (*p) {
if (*p == 'V' && g_ascii_strncasecmp (p, "Version=", 8) == 0) {
p += 8;
}
if (!klass)
return NULL;
- mono_class_init (klass);
if (info->type_arguments) {
MonoType **type_args = g_new0 (MonoType *, info->type_arguments->len);
} else { /* array rank */
klass = mono_bounded_array_class_get (klass, modval, bounded);
}
- mono_class_init (klass);
}
return &klass->byval_arg;
} else if (strcmp (klass->name, "FieldBuilder") == 0) {
MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
- /* Call mono_image_create_token so the object gets added to the tokens hash table */
- token = mono_image_create_token (((MonoReflectionTypeBuilder*)fb->typeb)->module->dynamic_image, obj, FALSE, TRUE);
+ token = fb->table_idx | MONO_TOKEN_FIELD_DEF;
} else if (strcmp (klass->name, "TypeBuilder") == 0) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
int etype = *p;
p ++;
- if (etype == 0x51)
- /* See Partition II, Appendix B3 */
- etype = MONO_TYPE_OBJECT;
type = MONO_TYPE_SZARRAY;
- simple_type.type = etype;
- tklass = mono_class_from_mono_type (&simple_type);
+ if (etype == 0x50) {
+ tklass = mono_defaults.systemtype_class;
+ } else {
+ if (etype == 0x51)
+ /* See Partition II, Appendix B3 */
+ etype = MONO_TYPE_OBJECT;
+ simple_type.type = etype;
+ tklass = mono_class_from_mono_type (&simple_type);
+ }
goto handle_enum;
} else if (subt == 0x55) {
char *n;
val = load_cattr_value (image, &subc->byval_arg, p, end);
obj = mono_object_new (mono_domain_get (), subc);
g_assert (!subc->has_references);
- memcpy ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
+ mono_gc_memmove ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
g_free (val);
return obj;
}
}
static MonoObject*
-create_custom_attr (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len)
+create_custom_attr (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoError *error)
{
const char *p = (const char*)data;
const char *named;
void **params;
MonoMethodSignature *sig;
+ mono_error_init (error);
+
mono_class_init (method->klass);
- if (!mono_verifier_verify_cattr_content (image, method, data, len, NULL))
+ if (!mono_verifier_verify_cattr_content (image, method, data, len, NULL)) {
+ mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
return NULL;
+ }
if (len == 0) {
attr = mono_object_new (mono_domain_get (), method->klass);
*named_args = namedargs;
}
-static MonoObject*
-create_custom_attr_data (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len)
+void
+mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod *ref_method, MonoReflectionAssembly *assembly, gpointer data, guint32 len, MonoArray **ctor_args, MonoArray **named_args)
{
- MonoArray *typedargs, *namedargs;
- static MonoMethod *ctor;
MonoDomain *domain;
- MonoObject *attr;
- void *params [3];
+ MonoArray *typedargs, *namedargs;
+ MonoImage *image;
+ MonoMethod *method;
CattrNamedArg *arginfo;
int i;
- mono_class_init (method->klass);
+ *ctor_args = NULL;
+ *named_args = NULL;
- if (!ctor)
- ctor = mono_class_get_method_from_name (mono_defaults.customattribute_data_class, ".ctor", 3);
+ if (len == 0)
+ return;
- domain = mono_domain_get ();
- if (len == 0) {
- /* This is for Attributes with no parameters */
- attr = mono_object_new (domain, mono_defaults.customattribute_data_class);
- params [0] = mono_method_get_object (domain, method, NULL);
- params [1] = params [2] = NULL;
- mono_runtime_invoke (method, attr, params, NULL);
- return attr;
- }
+ image = assembly->assembly->image;
+ method = ref_method->method;
+ domain = mono_object_domain (ref_method);
+
+ if (!mono_class_init (method->klass))
+ mono_raise_exception (mono_class_get_exception_for_failure (method->klass));
mono_reflection_create_custom_attr_data_args (image, method, data, len, &typedargs, &namedargs, &arginfo);
+ if (mono_loader_get_last_error ())
+ mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ()));
+
if (!typedargs || !namedargs)
- return NULL;
+ return;
for (i = 0; i < mono_method_signature (method)->param_count; ++i) {
MonoObject *obj = mono_array_get (typedargs, MonoObject*, i);
mono_array_setref (namedargs, i, namedarg);
}
- attr = mono_object_new (domain, mono_defaults.customattribute_data_class);
- params [0] = mono_method_get_object (domain, method, NULL);
- params [1] = typedargs;
- params [2] = namedargs;
- mono_runtime_invoke (ctor, attr, params, NULL);
- return attr;
+ *ctor_args = typedargs;
+ *named_args = namedargs;
}
-MonoArray*
-mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo)
+static MonoObject*
+create_custom_attr_data (MonoImage *image, MonoCustomAttrEntry *cattr)
{
- MonoArray *result;
+ static MonoMethod *ctor;
+ MonoDomain *domain;
MonoObject *attr;
- int i;
+ void *params [4];
- result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, cinfo->num_attrs);
- for (i = 0; i < cinfo->num_attrs; ++i) {
- if (!cinfo->attrs [i].ctor)
- /* The cattr type is not finished yet */
- /* We should include the type name but cinfo doesn't contain it */
- mono_raise_exception (mono_get_exception_type_load (NULL, NULL));
- attr = create_custom_attr (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size);
- mono_array_setref (result, i, attr);
- }
- return result;
+ g_assert (image->assembly);
+
+ if (!ctor)
+ ctor = mono_class_get_method_from_name (mono_defaults.customattribute_data_class, ".ctor", 4);
+
+ domain = mono_domain_get ();
+ attr = mono_object_new (domain, mono_defaults.customattribute_data_class);
+ params [0] = mono_method_get_object (domain, cattr->ctor, NULL);
+ params [1] = mono_assembly_get_object (domain, image->assembly);
+ params [2] = (gpointer)&cattr->data;
+ params [3] = &cattr->data_size;
+ mono_runtime_invoke (ctor, attr, params, NULL);
+ return attr;
}
static MonoArray*
-mono_custom_attrs_construct_by_type (MonoCustomAttrInfo *cinfo, MonoClass *attr_klass)
+mono_custom_attrs_construct_by_type (MonoCustomAttrInfo *cinfo, MonoClass *attr_klass, MonoError *error)
{
MonoArray *result;
MonoObject *attr;
int i, n;
+ mono_error_init (error);
+
n = 0;
for (i = 0; i < cinfo->num_attrs; ++i) {
- if (mono_class_is_assignable_from (attr_klass, cinfo->attrs [i].ctor->klass))
+ if (!attr_klass || mono_class_is_assignable_from (attr_klass, cinfo->attrs [i].ctor->klass))
n ++;
}
result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, n);
n = 0;
for (i = 0; i < cinfo->num_attrs; ++i) {
- if (mono_class_is_assignable_from (attr_klass, cinfo->attrs [i].ctor->klass)) {
- attr = create_custom_attr (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size);
+ if (!cinfo->attrs [i].ctor)
+ /* The cattr type is not finished yet */
+ /* We should include the type name but cinfo doesn't contain it */
+ mono_raise_exception (mono_get_exception_type_load (NULL, NULL));
+ if (!attr_klass || mono_class_is_assignable_from (attr_klass, cinfo->attrs [i].ctor->klass)) {
+ attr = create_custom_attr (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size, error);
+ if (!mono_error_ok (error))
+ return result;
mono_array_setref (result, n, attr);
n ++;
}
return result;
}
+MonoArray*
+mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo)
+{
+ MonoError error;
+
+ return mono_custom_attrs_construct_by_type (cinfo, NULL, &error);
+}
+
static MonoArray*
mono_custom_attrs_data_construct (MonoCustomAttrInfo *cinfo)
{
result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, cinfo->num_attrs);
for (i = 0; i < cinfo->num_attrs; ++i) {
- attr = create_custom_attr_data (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size);
+ attr = create_custom_attr_data (cinfo->image, &cinfo->attrs [i]);
mono_array_setref (result, i, attr);
}
return result;
image = method->klass->image;
method_index = mono_method_get_index (method);
+ if (!method_index)
+ return NULL;
ca = &image->tables [MONO_TABLE_METHOD];
param_list = mono_metadata_decode_row_col (ca, method_index - 1, MONO_METHOD_PARAMLIST);
if (klass == mono_defaults.monotype_class) {
MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj);
klass = mono_class_from_mono_type (type);
- if (!mono_class_init (klass))
- mono_raise_exception (mono_class_get_exception_for_failure (klass));
+ /*We cannot mono_class_init the class from which we'll load the custom attributes since this must work with broken types.*/
cinfo = mono_custom_attrs_from_class (klass);
} else if (strcmp ("Assembly", klass->name) == 0 || strcmp ("MonoAssembly", klass->name) == 0) {
MonoReflectionAssembly *rassembly = (MonoReflectionAssembly*)obj;
* occurs.
*/
MonoArray*
-mono_reflection_get_custom_attrs_by_type (MonoObject *obj, MonoClass *attr_klass)
+mono_reflection_get_custom_attrs_by_type (MonoObject *obj, MonoClass *attr_klass, MonoError *error)
{
MonoArray *result;
MonoCustomAttrInfo *cinfo;
+ mono_error_init (error);
+
cinfo = mono_reflection_get_custom_attrs_info (obj);
if (cinfo) {
- if (attr_klass)
- result = mono_custom_attrs_construct_by_type (cinfo, attr_klass);
- else
- result = mono_custom_attrs_construct (cinfo);
+ result = mono_custom_attrs_construct_by_type (cinfo, attr_klass, error);
if (!cinfo->cached)
mono_custom_attrs_free (cinfo);
} else {
MonoArray*
mono_reflection_get_custom_attrs (MonoObject *obj)
{
- return mono_reflection_get_custom_attrs_by_type (obj, NULL);
+ MonoError error;
+
+ return mono_reflection_get_custom_attrs_by_type (obj, NULL, &error);
}
/*
mono_class_setup_supertypes (class);
} else {
if (!domain->type_hash)
- domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mymono_metadata_type_hash,
- (GCompareFunc)mymono_metadata_type_equal, MONO_HASH_VALUE_GC);
+ domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
+ (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC);
mono_g_hash_table_insert (domain->type_hash, res, type);
}
mono_domain_unlock (domain);
return FALSE;
}
+static void
+init_type_builder_generics (MonoObject *type)
+{
+}
+
#endif /* !DISABLE_REFLECTION_EMIT */
(!strcmp (klass->name, "Enum") && !strcmp (klass->name_space, "System"))) {
klass->instance_size = sizeof (MonoObject);
klass->size_inited = 1;
- mono_class_setup_vtable_general (klass, NULL, 0);
+ mono_class_setup_vtable_general (klass, NULL, 0, NULL);
}
mono_class_setup_mono_type (klass);
* to create objects of the enum type (for use in SetConstant).
*/
/* FIXME: Does this mean enums can't have method overrides ? */
- mono_class_setup_vtable_general (klass, NULL, 0);
+ mono_class_setup_vtable_general (klass, NULL, 0, NULL);
}
mono_loader_unlock ();
}
}
#endif /* !DISABLE_REFLECTION_EMIT */
-MonoReflectionMarshal*
-mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
+MonoReflectionMarshalAsAttribute*
+mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
MonoMarshalSpec *spec)
{
- static MonoClass *System_Reflection_Emit_UnmanagedMarshalClass;
- MonoReflectionMarshal *minfo;
+ static MonoClass *System_Reflection_Emit_MarshalAsAttribute;
+ MonoReflectionMarshalAsAttribute *minfo;
MonoType *mtype;
- if (!System_Reflection_Emit_UnmanagedMarshalClass) {
- System_Reflection_Emit_UnmanagedMarshalClass = mono_class_from_name (
- mono_defaults.corlib, "System.Reflection.Emit", "UnmanagedMarshal");
- g_assert (System_Reflection_Emit_UnmanagedMarshalClass);
+ if (!System_Reflection_Emit_MarshalAsAttribute) {
+ System_Reflection_Emit_MarshalAsAttribute = mono_class_from_name (
+ mono_defaults.corlib, "System.Runtime.InteropServices", "MarshalAsAttribute");
+ g_assert (System_Reflection_Emit_MarshalAsAttribute);
}
- minfo = (MonoReflectionMarshal*)mono_object_new (domain, System_Reflection_Emit_UnmanagedMarshalClass);
- minfo->type = spec->native;
+ minfo = (MonoReflectionMarshalAsAttribute*)mono_object_new (domain, System_Reflection_Emit_MarshalAsAttribute);
+ minfo->utype = spec->native;
- switch (minfo->type) {
+ switch (minfo->utype) {
case MONO_NATIVE_LPARRAY:
- minfo->eltype = spec->data.array_data.elem_type;
- minfo->count = spec->data.array_data.num_elem;
- minfo->param_num = spec->data.array_data.param_num;
+ minfo->array_subtype = spec->data.array_data.elem_type;
+ minfo->size_const = spec->data.array_data.num_elem;
+ if (spec->data.array_data.param_num != -1)
+ minfo->size_param_index = spec->data.array_data.param_num;
break;
case MONO_NATIVE_BYVALTSTR:
case MONO_NATIVE_BYVALARRAY:
- minfo->count = spec->data.array_data.num_elem;
+ minfo->size_const = spec->data.array_data.num_elem;
break;
case MONO_NATIVE_CUSTOM:
if (spec->data.custom_data.custom_name) {
mtype = mono_reflection_type_from_name (spec->data.custom_data.custom_name, klass->image);
if (mtype)
- MONO_OBJECT_SETREF (minfo, marshaltyperef, mono_type_get_object (domain, mtype));
+ MONO_OBJECT_SETREF (minfo, marshal_type_ref, mono_type_get_object (domain, mtype));
- MONO_OBJECT_SETREF (minfo, marshaltype, mono_string_new (domain, spec->data.custom_data.custom_name));
+ MONO_OBJECT_SETREF (minfo, marshal_type, mono_string_new (domain, spec->data.custom_data.custom_name));
}
if (spec->data.custom_data.cookie)
- MONO_OBJECT_SETREF (minfo, mcookie, mono_string_new (domain, spec->data.custom_data.cookie));
+ MONO_OBJECT_SETREF (minfo, marshal_cookie, mono_string_new (domain, spec->data.custom_data.cookie));
break;
default:
m->slot = -1;
m->flags = rmb->attrs;
m->iflags = rmb->iattrs;
- m->name = mono_string_to_utf8_image (image, rmb->name, &error);
- g_assert (mono_error_ok (&error));
+ m->name = mono_string_to_utf8_image_ignore (image, rmb->name);
m->klass = klass;
m->signature = sig;
m->sre_method = TRUE;
container->type_params [i] = *param;
}
+ /*
+ * The method signature might have pointers to generic parameters that belong to other methods.
+ * This is a valid SRE case, but the resulting method signature must be encoded using the proper
+ * generic parameters.
+ */
+ for (i = 0; i < m->signature->param_count; ++i) {
+ MonoType *t = m->signature->params [i];
+ if (t->type == MONO_TYPE_MVAR) {
+ MonoGenericParam *gparam = t->data.generic_param;
+ if (gparam->num < count) {
+ m->signature->params [i] = mono_metadata_type_dup (image, m->signature->params [i]);
+ m->signature->params [i]->data.generic_param = mono_generic_container_get_param (container, gparam->num);
+ }
+
+ }
+ }
+
if (klass->generic_container) {
container->parent = klass->generic_container;
container->context.class_inst = klass->generic_container->context.class_inst;
{
MonoClassField *field;
MonoType *custom;
+ MonoError error;
field = g_new0 (MonoClassField, 1);
- field->name = mono_string_to_utf8 (fb->name);
+ field->name = mono_string_to_utf8_image (klass->image, fb->name, &error);
+ g_assert (mono_error_ok (&error));
if (fb->attrs || fb->modreq || fb->modopt) {
field->type = mono_metadata_type_dup (NULL, mono_reflection_type_get_handle ((MonoReflectionType*)fb->type));
field->type->attrs = fb->attrs;
g_assert (klass->image->dynamic);
custom = add_custom_modifiers ((MonoDynamicImage*)klass->image, field->type, fb->modreq, fb->modopt);
g_free (field->type);
- field->type = custom;
+ field->type = mono_metadata_type_dup (klass->image, custom);
+ g_free (custom);
} else {
field->type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type);
}
mono_g_hash_table_insert (image->generic_def_objects, imethod, rmethod);
mono_loader_unlock ();
}
+
+ if (!mono_verifier_is_method_valid_generic_instantiation (inflated))
+ mono_raise_exception (mono_get_exception_argument ("typeArguments", "Invalid generic arguments"));
return mono_method_get_object (mono_object_domain (rmethod), inflated, NULL);
}
/*TODO avoid saving custom attrs for generic classes as it's enough to have them on the generic type definition.*/
void
-mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods,
- MonoArray *ctors, MonoArray *fields, MonoArray *properties,
- MonoArray *events)
+mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields)
{
MonoGenericClass *gclass;
MonoDynamicGenericClass *dgclass;
gklass = gclass->container_class;
mono_class_init (gklass);
- dgclass->count_methods = methods ? mono_array_length (methods) : 0;
- dgclass->count_ctors = ctors ? mono_array_length (ctors) : 0;
dgclass->count_fields = fields ? mono_array_length (fields) : 0;
- dgclass->methods = g_new0 (MonoMethod *, dgclass->count_methods);
- dgclass->ctors = g_new0 (MonoMethod *, dgclass->count_ctors);
- dgclass->fields = g_new0 (MonoClassField, dgclass->count_fields);
- dgclass->field_objects = g_new0 (MonoObject*, dgclass->count_fields);
- dgclass->field_generic_types = g_new0 (MonoType*, dgclass->count_fields);
-
- for (i = 0; i < dgclass->count_methods; i++) {
- MonoObject *obj = mono_array_get (methods, gpointer, i);
-
- dgclass->methods [i] = inflate_method ((MonoReflectionType*)type, obj);
- }
-
- for (i = 0; i < dgclass->count_ctors; i++) {
- MonoObject *obj = mono_array_get (ctors, gpointer, i);
-
- dgclass->ctors [i] = inflate_method ((MonoReflectionType*)type, obj);
- }
+ dgclass->fields = mono_image_set_new0 (gclass->owner, MonoClassField, dgclass->count_fields);
+ dgclass->field_objects = mono_image_set_new0 (gclass->owner, MonoObject*, dgclass->count_fields);
+ dgclass->field_generic_types = mono_image_set_new0 (gclass->owner, MonoType*, dgclass->count_fields);
for (i = 0; i < dgclass->count_fields; i++) {
MonoObject *obj = mono_array_get (fields, gpointer, i);
dgclass->fields [i].type = mono_class_inflate_generic_type (
field->type, mono_generic_class_get_context ((MonoGenericClass *) dgclass));
dgclass->field_generic_types [i] = field->type;
- MOVING_GC_REGISTER (&dgclass->field_objects [i]);
+ MONO_GC_REGISTER_ROOT_IF_MOVING (dgclass->field_objects [i]);
dgclass->field_objects [i] = obj;
if (inflated_field) {
g_free (inflated_field);
} else {
- dgclass->fields [i].name = g_strdup (dgclass->fields [i].name);
+ dgclass->fields [i].name = mono_image_set_strdup (gclass->owner, dgclass->fields [i].name);
}
}
dgclass->initialized = TRUE;
}
+void
+mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass)
+{
+ MonoDynamicGenericClass *dgclass;
+ int i;
+
+ g_assert (gclass->is_dynamic);
+
+ dgclass = (MonoDynamicGenericClass *)gclass;
+
+ for (i = 0; i < dgclass->count_fields; ++i) {
+ MonoClassField *field = dgclass->fields + i;
+ mono_metadata_free_type (field->type);
+ MONO_GC_UNREGISTER_ROOT_IF_MOVING (dgclass->field_objects [i]);
+ }
+}
+
static void
fix_partial_generic_class (MonoClass *klass)
{
}
if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
- for (i = 0; i < klass->method.count; ++i)
- klass->methods [i]->slot = i;
+ int slot_num = 0;
+ for (i = 0; i < klass->method.count; ++i) {
+ MonoMethod *im = klass->methods [i];
+ if (!(im->flags & METHOD_ATTRIBUTE_STATIC))
+ im->slot = slot_num++;
+ }
klass->interfaces_packed = NULL; /*make setup_interface_offsets happy*/
mono_class_setup_interface_offsets (klass);
mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides)
{
MonoReflectionTypeBuilder *tb;
- int i, onum;
+ int i, j, onum;
+ MonoReflectionMethod *m;
*overrides = NULL;
*num_overrides = 0;
for (i = 0; i < tb->num_methods; ++i) {
MonoReflectionMethodBuilder *mb =
mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
- if (mb->override_method)
- onum ++;
+ if (mb->override_methods)
+ onum += mono_array_length (mb->override_methods);
}
}
for (i = 0; i < tb->num_methods; ++i) {
MonoReflectionMethodBuilder *mb =
mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
- if (mb->override_method) {
- (*overrides) [onum * 2] = mono_reflection_method_get_handle ((MonoObject *)mb->override_method);
- (*overrides) [onum * 2 + 1] = mb->mhandle;
+ if (mb->override_methods) {
+ for (j = 0; j < mono_array_length (mb->override_methods); ++j) {
+ m = mono_array_get (mb->override_methods, MonoReflectionMethod*, j);
+
+ (*overrides) [onum * 2] = mono_reflection_method_get_handle ((MonoObject*)m);
+ (*overrides) [onum * 2 + 1] = mb->mhandle;
- g_assert (mb->mhandle);
+ g_assert (mb->mhandle);
- onum ++;
+ onum ++;
+ }
}
}
}
mono_error_init (error);
if (tb->class_size) {
- g_assert ((tb->packing_size & 0xfffffff0) == 0);
+ 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);
+ mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg);
+ return;
+ }
klass->packing_size = tb->packing_size;
real_size = klass->instance_size + tb->class_size;
}
klass->size_inited = 1;
for (i = 0; i < klass->field.count; ++i) {
+ MonoArray *rva_data;
fb = mono_array_get (tb->fields, gpointer, i);
field = &klass->fields [i];
field->name = mono_string_to_utf8_image (image, fb->name, error);
} else {
field->type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type);
}
- if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && fb->rva_data)
- klass->ext->field_def_values [i].data = mono_array_addr (fb->rva_data, char, 0);
+
+ if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && (rva_data = fb->rva_data)) {
+ char *base = mono_array_addr (rva_data, char, 0);
+ size_t size = mono_array_length (rva_data);
+ char *data = mono_image_alloc (klass->image, size);
+ memcpy (data, base, size);
+ klass->ext->field_def_values [i].data = data;
+ }
if (fb->offset != -1)
field->offset = fb->offset;
field->parent = klass;
klass->flags = tb->attrs;
klass->has_cctor = 1;
klass->has_finalize = 1;
+ klass->has_finalize_inited = 1;
/* fool mono_class_setup_parent */
klass->supertypes = NULL;
MonoGenericParamFull *param;
MonoImage *image;
MonoClass *pklass;
+ MonoError error;
MONO_ARCH_SAVE_REGS;
- param = g_new0 (MonoGenericParamFull, 1);
+ image = &gparam->tbuilder->module->dynamic_image->image;
+
+ param = mono_image_new0 (image, MonoGenericParamFull, 1);
+
+ param->info.name = mono_string_to_utf8_image (image, gparam->name, &error);
+ g_assert (mono_error_ok (&error));
+ param->param.num = gparam->index;
if (gparam->mbuilder) {
if (!gparam->mbuilder->generic_container) {
param->param.owner = gparam->tbuilder->generic_container;
}
- param->info.name = mono_string_to_utf8 (gparam->name);
- param->param.num = gparam->index;
-
- image = &gparam->tbuilder->module->dynamic_image->image;
pklass = mono_class_from_generic_parameter ((MonoGenericParam *) param, image, gparam->mbuilder != NULL);
gparam->type.type = &pklass->byval_arg;
return result;
}
+typedef struct {
+ MonoMethod *handle;
+ MonoDomain *domain;
+} DynamicMethodReleaseData;
+
+/*
+ * The runtime automatically clean up those after finalization.
+*/
+static MonoReferenceQueue *dynamic_method_queue;
+
+static void
+free_dynamic_method (void *dynamic_method)
+{
+ DynamicMethodReleaseData *data = dynamic_method;
+
+ mono_runtime_free_method (data->domain, data->handle);
+ g_free (data);
+}
+
void
mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *mb)
{
+ MonoReferenceQueue *queue;
+ MonoMethod *handle;
+ DynamicMethodReleaseData *release_data;
ReflectionMethodBuilder rmb;
MonoMethodSignature *sig;
MonoClass *klass;
GSList *l;
int i;
+ if (mono_runtime_is_shutting_down ())
+ mono_raise_exception (mono_get_exception_invalid_operation (""));
+
+ if (!(queue = dynamic_method_queue)) {
+ mono_loader_lock ();
+ if (!(queue = dynamic_method_queue))
+ queue = dynamic_method_queue = mono_gc_reference_queue_new (free_dynamic_method);
+ mono_loader_unlock ();
+ }
+
sig = dynamic_method_to_signature (mb);
reflection_methodbuilder_from_dynamic_method (&rmb, mb);
klass = mb->owner ? mono_class_from_mono_type (mono_reflection_type_get_handle ((MonoReflectionType*)mb->owner)) : mono_defaults.object_class;
- mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
+ mb->mhandle = handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
+ release_data = g_new (DynamicMethodReleaseData, 1);
+ release_data->handle = handle;
+ release_data->domain = mono_object_get_domain ((MonoObject*)mb);
+ if (!mono_gc_reference_queue_add (queue, (MonoObject*)mb, release_data))
+ g_free (release_data);
/* Fix up refs entries pointing at us */
for (l = mb->referenced_by; l; l = l->next) {
#endif /* DISABLE_REFLECTION_EMIT */
-void
-mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb)
-{
- g_assert (mb);
-
- if (mb->mhandle)
- mono_runtime_free_method (
- mono_object_get_domain ((MonoObject*)mb), mb->mhandle);
-}
-
/**
*
* mono_reflection_is_valid_dynamic_token:
return mono_g_hash_table_lookup (image->tokens, GUINT_TO_POINTER (token)) != NULL;
}
+MonoMethodSignature *
+mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token)
+{
+ MonoMethodSignature *sig;
+ g_assert (image->dynamic);
+
+ sig = g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
+ if (sig)
+ return sig;
+
+ return mono_method_signature (method);
+}
+
#ifndef DISABLE_REFLECTION_EMIT
/**
return resolve_object (image, obj, handle_class, context);
}
-MonoMethodSignature *
-mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token)
-{
- MonoMethodSignature *sig;
- g_assert (image->dynamic);
-
- sig = g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
- if (sig)
- return sig;
-
- return mono_method_signature (method);
-}
-
/*
* ensure_complete_type:
*
is_sre_pointer (mono_object_get_class(obj))) {
MonoReflectionType *ref_type = (MonoReflectionType *)obj;
MonoType *type = mono_reflection_type_get_handle (ref_type);
- result = mono_class_from_mono_type (type);
+
+ if (context) {
+ MonoType *inflated = mono_class_inflate_generic_type (type, context);
+ result = mono_class_from_mono_type (inflated);
+ mono_metadata_free_type (inflated);
+ } else {
+ result = mono_class_from_mono_type (type);
+ }
*handle_class = mono_defaults.typehandle_class;
} else {
g_print ("%s\n", obj->vtable->klass->name);
guint32
mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj,
- gboolean create_methodspec, gboolean register_token)
+ gboolean create_open_instance, gboolean register_token)
{
g_assert_not_reached ();
return 0;
}
void
-mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods,
- MonoArray *ctors, MonoArray *fields, MonoArray *properties,
- MonoArray *events)
+mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields)
{
g_assert_not_reached ();
}
return ref->type;
}
+void
+mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass)
+{
+ g_assert_not_reached ();
+}
+
#endif /* DISABLE_REFLECTION_EMIT */
/* SECURITY_ACTION_* are defined in mono/metadata/tabledefs.h */
else
return *(MonoBoolean*)mono_object_unbox (res);
}
+
+/**
+ * mono_reflection_type_get_type:
+ * @reftype: the System.Type object
+ *
+ * Returns the MonoType* associated with the C# System.Type object @reftype.
+ */
+MonoType*
+mono_reflection_type_get_type (MonoReflectionType *reftype)
+{
+ g_assert (reftype);
+
+ return mono_reflection_type_get_handle (reftype);
+}
+
projects / mono.git / blobdiff