*
*/
#include <config.h>
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
#include "mono/utils/mono-digest.h"
#include "mono/utils/mono-membar.h"
#include "mono/metadata/reflection.h"
#include "mono-endian.h"
#include <mono/metadata/gc-internal.h>
#include <mono/metadata/mempool-internals.h>
+#include <mono/metadata/security-core-clr.h>
#if HAVE_SGEN_GC
static void* reflection_info_desc = NULL;
};
-static void reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb);
-static void reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb);
-static guint32 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type);
-static guint32 mono_image_typedef_or_ref_full (MonoDynamicImage *assembly, MonoType *type, gboolean try_typespec);
+#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_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 gpointer resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context);
+static guint32 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method);
+static guint32 encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context);
+static gpointer register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly);
+#endif
+
+static void reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb);
+static void reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb);
+static guint32 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type);
+static guint32 mono_image_typedef_or_ref_full (MonoDynamicImage *assembly, MonoType *type, gboolean try_typespec);
static void mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly);
static guint32 encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo);
static guint32 encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type);
static char* type_get_qualified_name (MonoType *type, MonoAssembly *ass);
-static void ensure_runtime_vtable (MonoClass *klass);
-static gpointer resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context);
static void encode_type (MonoDynamicImage *assembly, MonoType *type, SigBuffer *buf);
static void get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types);
static MonoObject *mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob);
static MonoReflectionType *mono_reflection_type_get_underlying_system_type (MonoReflectionType* t);
static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve);
-static guint32 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method);
-static guint32 encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context);
-
-#define mono_reflection_lock() EnterCriticalSection (&reflection_mutex)
-#define mono_reflection_unlock() LeaveCriticalSection (&reflection_mutex)
-static CRITICAL_SECTION reflection_mutex;
void
mono_reflection_init (void)
{
- InitializeCriticalSection (&reflection_mutex);
}
static void
g_free (buf->buf);
}
+#ifndef DISABLE_REFLECTION_EMIT
/**
* mp_g_alloc:
*
else
return g_malloc (size);
}
+#endif /* !DISABLE_REFLECTION_EMIT */
/**
* image_g_alloc0:
return g_malloc0 (size);
}
+#ifndef DISABLE_REFLECTION_EMIT
static char*
image_strdup (MonoImage *image, const char *s)
{
else
return g_strdup (s);
}
+#endif
#define image_g_new(image,struct_type, n_structs) \
((struct_type *) image_g_malloc (image, ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
return idx;
}
+#ifndef DISABLE_REFLECTION_EMIT
static void
string_heap_init (MonoDynamicStream *sh)
{
sh->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
string_heap_insert (sh, "");
}
+#endif
static guint32
mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
mono_image_add_stream_data (stream, buf, 4 - count);
}
+#ifndef DISABLE_REFLECTION_EMIT
static int
mono_blob_entry_hash (const char* str)
{
return 0;
return memcmp (end1, end2, len) == 0;
}
-
+#endif
static guint32
add_to_blob_cached (MonoDynamicImage *assembly, char *b1, int s1, char *b2, int s2)
{
return idx;
}
-/* modified version needed to handle building corlib */
-static MonoClass*
-my_mono_class_from_mono_type (MonoType *type) {
- switch (type->type) {
- case MONO_TYPE_ARRAY:
- case MONO_TYPE_PTR:
- case MONO_TYPE_SZARRAY:
- case MONO_TYPE_GENERICINST:
- return mono_class_from_mono_type (type);
- case MONO_TYPE_VAR:
- case MONO_TYPE_MVAR:
- g_assert (type->data.generic_param->pklass);
- return type->data.generic_param->pklass;
- default:
- /* should be always valid when we reach this case... */
- return type->data.klass;
- }
-}
-
+#ifndef DISABLE_REFLECTION_EMIT
static MonoClass *
default_class_from_mono_type (MonoType *type)
{
return NULL;
}
+#endif
static void
encode_generic_class (MonoDynamicImage *assembly, MonoGenericClass *gclass, SigBuffer *buf)
case MONO_TYPE_VAR:
case MONO_TYPE_MVAR:
sigbuffer_add_value (buf, type->type);
- sigbuffer_add_value (buf, type->data.generic_param->num);
+ sigbuffer_add_value (buf, mono_type_get_generic_param_num (type));
break;
default:
g_error ("need to encode type %x", type->type);
if (modreq) {
for (i = 0; i < mono_array_length (modreq); ++i) {
- MonoReflectionType *mod = mono_array_get (modreq, MonoReflectionType*, i);
+ MonoReflectionType *mod = mono_type_array_get (modreq, i);
sigbuffer_add_byte (buf, MONO_TYPE_CMOD_REQD);
sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, mod->type));
}
}
if (modopt) {
for (i = 0; i < mono_array_length (modopt); ++i) {
- MonoReflectionType *mod = mono_array_get (modopt, MonoReflectionType*, i);
+ MonoReflectionType *mod = mono_type_array_get (modopt, i);
sigbuffer_add_byte (buf, MONO_TYPE_CMOD_OPT);
sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, mod->type));
}
}
}
+#ifndef DISABLE_REFLECTION_EMIT
static guint32
method_encode_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig)
{
sigbuffer_free (&buf);
return idx;
}
+#endif
static guint32
method_builder_encode_signature (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
if (mb->param_modopt && (i < mono_array_length (mb->param_modopt)))
modopt = mono_array_get (mb->param_modopt, MonoArray*, i);
encode_custom_modifiers (assembly, modreq, modopt, &buf);
- pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
+ pt = mono_type_array_get (mb->parameters, i);
encode_reflection_type (assembly, pt, &buf);
}
if (notypes)
for (i = 0; i < notypes; ++i) {
MonoReflectionType *pt;
- pt = mono_array_get (mb->opt_types, MonoReflectionType*, i);
+ pt = mono_type_array_get (mb->opt_types, i);
encode_reflection_type (assembly, pt, &buf);
}
if (lb->is_pinned)
sigbuffer_add_value (&buf, MONO_TYPE_PINNED);
- encode_reflection_type (assembly, lb->type, &buf);
+ encode_reflection_type (assembly, monotype_cast (lb->type), &buf);
}
sig_idx = sigbuffer_add_to_blob_cached (assembly, &buf);
sigbuffer_free (&buf);
return num_clauses;
}
+#ifndef DISABLE_REFLECTION_EMIT
static MonoExceptionClause*
method_encode_clauses (MonoImage *image, MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, guint32 num_clauses)
{
clause->handler_offset = ex_block->start;
clause->handler_len = ex_block->len;
if (ex_block->extype) {
- clause->data.catch_class = mono_class_from_mono_type (ex_block->extype->type);
+ clause->data.catch_class = mono_class_from_mono_type (monotype_cast (ex_block->extype)->type);
} else {
if (ex_block->type == MONO_EXCEPTION_CLAUSE_FILTER)
clause->data.filter_offset = ex_block->filter_offset;
return clauses;
}
+#endif /* !DISABLE_REFLECTION_EMIT */
static guint32
method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
finally_start = ex_block->start + ex_block->len;
if (ex_block->extype) {
- val = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, ex_block->extype->type));
+ val = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, monotype_cast (ex_block->extype)->type));
} else {
if (ex_block->type == MONO_EXCEPTION_CLAUSE_FILTER)
val = ex_block->filter_offset;
return ainfo;
}
+#ifndef DISABLE_REFLECTION_EMIT
/*
* LOCKING: Acquires the loader lock.
*/
mono_loader_unlock ();
}
+#endif
void
mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
memset (rmb, 0, sizeof (ReflectionMethodBuilder));
rmb->ilgen = mb->ilgen;
- rmb->rtype = mb->rtype;
+ rmb->rtype = monotype_cast (mb->rtype);
rmb->parameters = mb->parameters;
rmb->generic_params = mb->generic_params;
rmb->generic_container = mb->generic_container;
rmb->refs = NULL;
}
+#ifndef DISABLE_REFLECTION_EMIT
static void
reflection_methodbuilder_from_dynamic_method (ReflectionMethodBuilder *rmb, MonoReflectionDynamicMethod *mb)
{
rmb->nrefs = 0;
rmb->refs = NULL;
}
+#endif
static void
mono_image_add_methodimpl (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb)
MonoClass *klass;
MonoAssembly *ta;
- klass = my_mono_class_from_mono_type (type);
+ klass = mono_class_from_mono_type (type);
if (!klass)
return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_REFLECTION);
ta = klass->image->assembly;
return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
}
+#ifndef DISABLE_REFLECTION_EMIT
static guint32
fieldref_encode_signature (MonoDynamicImage *assembly, MonoType *type)
{
sigbuffer_free (&buf);
return idx;
}
+#endif
static guint32
field_encode_signature (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
sigbuffer_add_value (&buf, 0x06);
encode_custom_modifiers (assembly, fb->modreq, fb->modopt, &buf);
/* encode custom attributes before the type */
- encode_reflection_type (assembly, fb->type, &buf);
+ encode_reflection_type (assembly, monotype_cast (fb->type), &buf);
idx = sigbuffer_add_to_blob_cached (assembly, &buf);
sigbuffer_free (&buf);
return idx;
/* custom marshaler type name */
if (minfo->marshaltype || minfo->marshaltyperef) {
if (minfo->marshaltyperef)
- str = type_get_fully_qualified_name (minfo->marshaltyperef->type);
+ str = type_get_fully_qualified_name (monotype_cast (minfo->marshaltyperef)->type);
else
str = mono_string_to_utf8 (minfo->marshaltype);
len = strlen (str);
sigbuffer_add_byte (&buf, 0x08);
sigbuffer_add_value (&buf, nparams);
if (mb) {
- encode_reflection_type (assembly, mb->rtype, &buf);
+ encode_reflection_type (assembly, monotype_cast (mb->rtype), &buf);
for (i = 0; i < nparams; ++i) {
- MonoReflectionType *pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
+ MonoReflectionType *pt = mono_type_array_get (mb->parameters, i);
encode_reflection_type (assembly, pt, &buf);
}
} else if (smb && smb->parameters) {
/* the property type is the last param */
- encode_reflection_type (assembly, mono_array_get (smb->parameters, MonoReflectionType*, nparams), &buf);
+ encode_reflection_type (assembly, mono_type_array_get (smb->parameters, nparams), &buf);
for (i = 0; i < nparams; ++i) {
- MonoReflectionType *pt = mono_array_get (smb->parameters, MonoReflectionType*, i);
+ MonoReflectionType *pt = mono_type_array_get (smb->parameters, i);
encode_reflection_type (assembly, pt, &buf);
}
} else {
- encode_reflection_type (assembly, fb->type, &buf);
+ encode_reflection_type (assembly, monotype_cast (fb->type), &buf);
}
idx = sigbuffer_add_to_blob_cached (assembly, &buf);
values [MONO_GENERICPARAM_OWNER] = entry->owner;
values [MONO_GENERICPARAM_FLAGS] = entry->gparam->attrs;
- values [MONO_GENERICPARAM_NUMBER] = param->num;
- values [MONO_GENERICPARAM_NAME] = string_heap_insert (&assembly->sheap, param->name);
+ values [MONO_GENERICPARAM_NUMBER] = mono_generic_param_num (param);
+ values [MONO_GENERICPARAM_NAME] = string_heap_insert (&assembly->sheap, mono_generic_param_info (param)->name);
mono_image_add_cattrs (assembly, table_idx, MONO_CUSTOM_ATTR_GENERICPAR, entry->gparam->cattrs);
token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typeref, type));
if (token)
return token;
- klass = my_mono_class_from_mono_type (type);
+ klass = mono_class_from_mono_type (type);
if (!klass)
klass = mono_class_from_mono_type (type);
return mono_image_typedef_or_ref_full (assembly, type, TRUE);
}
+#ifndef DISABLE_REFLECTION_EMIT
/*
* Insert a memberef row into the metadata: the token that point to the memberref
* is returned. Caching is done in the caller (mono_image_get_methodref_token() or
g_hash_table_insert (assembly->handleref, mb, GUINT_TO_POINTER(token));
return token;
}
+#endif
static gboolean
is_field_on_inst (MonoClassField *field)
return dgclass->field_generic_types [field_index];
}
+#ifndef DISABLE_REFLECTION_EMIT
static guint32
mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoReflectionField *f)
{
pos = 0;
if (modreq) {
for (i = 0; i < mono_array_length (modreq); ++i) {
- MonoReflectionType *mod = mono_array_get (modreq, MonoReflectionType*, i);
+ MonoReflectionType *mod = mono_type_array_get (modreq, i);
t->modifiers [pos].required = 1;
t->modifiers [pos].token = mono_image_typedef_or_ref (assembly, mod->type);
pos ++;
}
if (modopt) {
for (i = 0; i < mono_array_length (modopt); ++i) {
- MonoReflectionType *mod = mono_array_get (modopt, MonoReflectionType*, i);
+ MonoReflectionType *mod = mono_type_array_get (modopt, i);
t->modifiers [pos].required = 0;
t->modifiers [pos].token = mono_image_typedef_or_ref (assembly, mod->type);
pos ++;
/* 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, fb->type->type, fb->modreq, fb->modopt);
+ custom = add_custom_modifiers (assembly, monotype_cast (fb->type)->type, fb->modreq, fb->modopt);
sig = fieldref_encode_signature (assembly, custom);
g_free (custom);
} else {
- sig = fieldref_encode_signature (assembly, fb->type->type);
+ sig = fieldref_encode_signature (assembly, monotype_cast (fb->type)->type);
}
parent = create_generic_typespec (assembly, (MonoReflectionTypeBuilder *) fb->typeb);
modopts = mono_array_get (helper->modopts, MonoArray*, i);
encode_custom_modifiers (assembly, modreqs, modopts, &buf);
- pt = mono_array_get (helper->arguments, MonoReflectionType*, i);
+ pt = mono_type_array_get (helper->arguments, i);
encode_reflection_type (assembly, pt, &buf);
}
idx = sigbuffer_add_to_blob_cached (assembly, &buf);
return idx;
}
-
+
static guint32
mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper)
{
}
return 0;
}
+#endif /* !DISABLE_REFLECTION_EMIT */
typedef struct {
MonoType *parent;
guint32 token;
} ArrayMethod;
+#ifndef DISABLE_REFLECTION_EMIT
static guint32
mono_image_get_array_token (MonoDynamicImage *assembly, MonoReflectionArrayMethod *m)
{
sig->param_count = nparams;
sig->ret = m->ret? m->ret->type: &mono_defaults.void_class->byval_arg;
for (i = 0; i < nparams; ++i) {
- MonoReflectionType *t = mono_array_get (m->parameters, gpointer, i);
+ MonoReflectionType *t = mono_type_array_get (m->parameters, i);
sig->params [i] = t->type;
}
m->table_idx = am->token & 0xffffff;
return am->token;
}
+#endif
/*
* Insert into the metadata tables all the info about the TypeBuilder tb.
g_free (n);
if (tb->parent && !(is_system && is_object) &&
!(tb->attrs & TYPE_ATTRIBUTE_INTERFACE)) { /* interfaces don't have a parent */
- values [MONO_TYPEDEF_EXTENDS] = mono_image_typedef_or_ref (assembly, tb->parent->type);
+ values [MONO_TYPEDEF_EXTENDS] = mono_image_typedef_or_ref (assembly, monotype_cast (tb->parent)->type);
} else {
values [MONO_TYPEDEF_EXTENDS] = 0;
}
if (assemblyb->type_forwarders) {
for (i = 0; i < mono_array_length (assemblyb->type_forwarders); ++i) {
- MonoReflectionType *t = mono_array_get (assemblyb->type_forwarders, MonoReflectionType*, i);
+ MonoReflectionType *t = mono_type_array_get (assemblyb->type_forwarders, i);
if (!t)
continue;
if ((*b_entry)->owner == (*a_entry)->owner)
return
- (*a_entry)->gparam->type.type->data.generic_param->num -
- (*b_entry)->gparam->type.type->data.generic_param->num;
+ mono_type_get_generic_param_num ((*a_entry)->gparam->type.type) -
+ mono_type_get_generic_param_num ((*b_entry)->gparam->type.type);
else
return (*a_entry)->owner - (*b_entry)->owner;
}
#endif /* DISABLE_REFLECTION_EMIT_SAVE */
+
+typedef struct {
+ guint32 import_lookup_table;
+ guint32 timestamp;
+ guint32 forwarder;
+ guint32 name_rva;
+ guint32 import_address_table_rva;
+} MonoIDT;
+
+typedef struct {
+ guint32 name_rva;
+ guint32 flags;
+} MonoILT;
+
#ifndef DISABLE_REFLECTION_EMIT
/*
sig = method_builder_encode_signature (assembly, &rmb);
- parent = mono_image_create_token (assembly, obj, TRUE, TRUE) + 1; /*it returns the zero based indexing and metadata uses one based*/
+ parent = mono_image_create_token (assembly, obj, TRUE, TRUE);
g_assert (mono_metadata_token_table (parent) == MONO_TABLE_METHOD);
parent = mono_metadata_token_index (parent) << MONO_MEMBERREF_PARENT_BITS;
guint32 token = 0;
klass = obj->vtable->klass;
+
+ /* Check for user defined reflection objects */
+ /* TypeDelegator is the only corlib type which doesn't look like a MonoReflectionType */
+ if (klass->image != mono_defaults.corlib || (strcmp (klass->name, "TypeDelegator") == 0))
+ mono_raise_exception (mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported")); \
+
if (strcmp (klass->name, "MethodBuilder") == 0) {
MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type;
}
}
-#endif /* DISABLE_REFLECTION_EMIT */
-
-typedef struct {
- guint32 import_lookup_table;
- guint32 timestamp;
- guint32 forwarder;
- guint32 name_rva;
- guint32 import_address_table_rva;
-} MonoIDT;
-
-typedef struct {
- guint32 name_rva;
- guint32 flags;
-} MonoILT;
-
-static gpointer register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly);
-
static MonoDynamicImage*
create_dynamic_mono_image (MonoDynamicAssembly *assembly, char *assembly_name, char *module_name)
{
mono_image_init (&image->image);
- image->token_fixups = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_KEY_GC);
+ image->token_fixups = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC);
image->method_to_table_idx = g_hash_table_new (NULL, NULL);
image->field_to_table_idx = g_hash_table_new (NULL, NULL);
image->method_aux_hash = g_hash_table_new (NULL, NULL);
image->handleref = g_hash_table_new (NULL, NULL);
image->tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC);
image->generic_def_objects = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC);
- image->methodspec = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_KEY_GC);
+ image->methodspec = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC);
image->typespec = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
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);
return image;
}
+#endif
static void
free_blob_cache_entry (gpointer key, gpointer val, gpointer user_data)
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*)param->name);
+ g_free ((char*)mono_generic_param_info (param)->name);
g_free (param);
}
g_free (entry);
mono_assembly_invoke_load_hook ((MonoAssembly*)assembly);
}
-#endif /* DISABLE_REFLECTION_EMIT */
+#endif /* !DISABLE_REFLECTION_EMIT */
+
+#ifndef DISABLE_REFLECTION_EMIT_SAVE
static int
calc_section_size (MonoDynamicImage *assembly)
g_error ("WriteFile returned %d\n", GetLastError ());
}
-#ifndef DISABLE_REFLECTION_EMIT_SAVE
-
/*
* mono_image_create_pefile:
* @mb: a module builder object
} while (0)
#ifdef HAVE_BOEHM_GC
-#define ALLOC_REFENTRY mono_gc_alloc_fixed (sizeof (ReflectedEntry), NULL)
-#define FREE_REFENTRY(entry) mono_gc_free_fixed ((entry))
+/* ReflectedEntry doesn't need to be GC tracked */
+#define ALLOC_REFENTRY g_new0 (ReflectedEntry, 1)
+#define FREE_REFENTRY(entry) g_free ((entry))
+#define REFENTRY_REQUIRES_CLEANUP
#else
#define ALLOC_REFENTRY mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
/* FIXME: */
mono_domain_unlock (domain);
}
+#ifdef REFENTRY_REQUIRES_CLEANUP
+static void
+cleanup_refobject_hash (gpointer key, gpointer value, gpointer user_data)
+{
+ FREE_REFENTRY (key);
+}
+#endif
+
+void
+mono_reflection_cleanup_domain (MonoDomain *domain)
+{
+ if (domain->refobject_hash) {
+/*let's avoid scanning the whole hashtable if not needed*/
+#ifdef REFENTRY_REQUIRES_CLEANUP
+ mono_g_hash_table_foreach (domain->refobject_hash, cleanup_refobject_hash, NULL);
+#endif
+ mono_g_hash_table_destroy (domain->refobject_hash);
+ domain->refobject_hash = NULL;
+ }
+}
+
+#ifndef DISABLE_REFLECTION_EMIT
static gpointer
register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly)
{
CACHE_OBJECT (MonoReflectionModuleBuilder *, module, res, NULL);
}
-#ifndef DISABLE_REFLECTION_EMIT
-
void
mono_image_module_basic_init (MonoReflectionModuleBuilder *moduleb)
{
return vtable->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);
if ((res = mono_g_hash_table_lookup (domain->type_hash, type))) {
mono_domain_unlock (domain);
+ mono_loader_unlock ();
return res;
}
/* Create a MonoGenericClass object for instantiations of not finished TypeBuilders */
res = (MonoReflectionType *)mono_generic_class_get_object (domain, type);
mono_g_hash_table_insert (domain->type_hash, type, res);
mono_domain_unlock (domain);
+ mono_loader_unlock ();
return res;
}
if (!verify_safe_for_managed_space (type)) {
mono_domain_unlock (domain);
+ mono_loader_unlock ();
mono_raise_exception (mono_get_exception_invalid_operation ("This type cannot be propagated to managed space"));
}
/* should this be considered an error condition? */
if (!type->byref) {
mono_domain_unlock (domain);
+ mono_loader_unlock ();
return klass->reflection_info;
}
}
MONO_OBJECT_SETREF (domain, typeof_void, res);
mono_domain_unlock (domain);
+ mono_loader_unlock ();
return res;
}
mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
{
MonoReflectionEvent *res;
+ MonoReflectionMonoEvent *mono_event;
static MonoClass *monoevent_klass;
CHECK_OBJECT (MonoReflectionEvent *, event, klass);
if (!monoevent_klass)
monoevent_klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoEvent");
- res = (MonoReflectionEvent *)mono_object_new (domain, monoevent_klass);
- res->klass = klass;
- res->event = event;
+ mono_event = (MonoReflectionMonoEvent *)mono_object_new (domain, monoevent_klass);
+ mono_event->klass = klass;
+ mono_event->event = event;
+ res = (MonoReflectionEvent*)mono_event;
CACHE_OBJECT (MonoReflectionEvent *, event, res, klass);
}
* in the method @method.
*/
MonoArray*
-mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
+mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
{
static MonoClass *System_Reflection_ParameterInfo;
static MonoClass *System_Reflection_ParameterInfo_array;
/* Note: the cache is based on the address of the signature into the method
* since we already cache MethodInfos with the method as keys.
*/
- CHECK_OBJECT (MonoArray*, &(method->signature), NULL);
+ CHECK_OBJECT (MonoArray*, &(method->signature), refclass);
sig = mono_method_signature (method);
- member = mono_method_get_object (domain, method, NULL);
+ member = mono_method_get_object (domain, method, refclass);
names = g_new (char *, sig->param_count);
mono_method_get_param_names (method, (const char **) names);
mono_metadata_free_marshal_spec (mspecs [i]);
g_free (mspecs);
- CACHE_OBJECT (MonoArray *, &(method->signature), res, NULL);
+ CACHE_OBJECT (MonoArray *, &(method->signature), res, refclass);
+}
+
+MonoArray*
+mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
+{
+ return mono_param_get_objects_internal (domain, method, NULL);
}
/*
ret->init_locals = header->init_locals;
ret->max_stack = header->max_stack;
ret->local_var_sig_token = local_var_sig_token;
- MONO_OBJECT_SETREF (ret, il, mono_array_new (domain, mono_defaults.byte_class, header->code_size));
+ MONO_OBJECT_SETREF (ret, il, mono_array_new_cached (domain, mono_defaults.byte_class, header->code_size));
memcpy (mono_array_addr (ret->il, guint8, 0), header->code, header->code_size);
/* Locals */
- MONO_OBJECT_SETREF (ret, locals, mono_array_new (domain, System_Reflection_LocalVariableInfo, header->num_locals));
+ MONO_OBJECT_SETREF (ret, locals, mono_array_new_cached (domain, System_Reflection_LocalVariableInfo, header->num_locals));
for (i = 0; i < header->num_locals; ++i) {
MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new (domain, System_Reflection_LocalVariableInfo);
MONO_OBJECT_SETREF (info, local_type, mono_type_get_object (domain, header->locals [i]));
}
/* Exceptions */
- MONO_OBJECT_SETREF (ret, clauses, mono_array_new (domain, System_Reflection_ExceptionHandlingClause, header->num_clauses));
+ MONO_OBJECT_SETREF (ret, clauses, mono_array_new_cached (domain, System_Reflection_ExceptionHandlingClause, header->num_clauses));
for (i = 0; i < header->num_clauses; ++i) {
MonoReflectionExceptionHandlingClause *info = (MonoReflectionExceptionHandlingClause*)mono_object_new (domain, System_Reflection_ExceptionHandlingClause);
MonoExceptionClause *clause = &header->clauses [i];
token = mono_class_get_property_token (p->property);
} else if (strcmp (klass->name, "MonoEvent") == 0) {
- MonoReflectionEvent *p = (MonoReflectionEvent*)obj;
+ MonoReflectionMonoEvent *p = (MonoReflectionMonoEvent*)obj;
token = mono_class_get_event_token (p->event);
} else if (strcmp (klass->name, "ParameterInfo") == 0) {
const char *named;
guint32 i, j, num_named;
MonoObject *attr;
+ void *params_buf [32];
void **params;
+ MonoMethodSignature *sig;
mono_class_init (method->klass);
/*g_print ("got attr %s\n", method->klass->name);*/
- /* Allocate using alloca so it gets GC tracking */
- params = alloca (mono_method_signature (method)->param_count * sizeof (void*));
+ sig = mono_method_signature (method);
+ if (sig->param_count < 32)
+ params = params_buf;
+ else
+ /* Allocate using GC so it gets GC tracking */
+ params = mono_gc_alloc_fixed (sig->param_count * sizeof (void*), NULL);
/* skip prolog */
p += 2;
g_free (name);
}
+ if (params != params_buf)
+ mono_gc_free_fixed (params);
+
return attr;
}
MonoObject *attr;
int i;
- result = mono_array_new (mono_domain_get (), mono_defaults.attribute_class, cinfo->num_attrs);
+ 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 */
n ++;
}
- result = mono_array_new (mono_domain_get (), mono_defaults.attribute_class, 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)) {
if (method->dynamic || method->klass->image->dynamic)
return lookup_custom_attr (method->klass->image, method);
+ if (!method->token)
+ /* Synthetic methods */
+ return NULL;
+
idx = mono_method_get_index (method);
idx <<= MONO_CUSTOM_ATTR_BITS;
idx |= MONO_CUSTOM_ATTR_METHODDEF;
MonoClass *klass;
for (i = 0; i < ainfo->num_attrs; ++i) {
klass = ainfo->attrs [i].ctor->klass;
- if (mono_class_has_parent (klass, attr_klass))
+ if (mono_class_has_parent (klass, attr_klass) || (MONO_CLASS_IS_INTERFACE (attr_klass) && mono_class_is_assignable_from (attr_klass, klass)))
return TRUE;
}
return FALSE;
MonoReflectionProperty *rprop = (MonoReflectionProperty*)obj;
cinfo = mono_custom_attrs_from_property (rprop->property->parent, rprop->property);
} else if (strcmp ("MonoEvent", klass->name) == 0) {
- MonoReflectionEvent *revent = (MonoReflectionEvent*)obj;
+ MonoReflectionMonoEvent *revent = (MonoReflectionMonoEvent*)obj;
cinfo = mono_custom_attrs_from_event (revent->event->parent, revent->event);
} else if (strcmp ("MonoField", klass->name) == 0) {
MonoReflectionField *rfield = (MonoReflectionField*)obj;
} else {
if (mono_loader_get_last_error ())
return NULL;
- result = mono_array_new (mono_domain_get (), mono_defaults.attribute_class, 0);
+ result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, 0);
}
return result;
return (MonoReflectionType *) mono_runtime_invoke (method_get_underlying_system_type, t, NULL, NULL);
}
+#ifndef DISABLE_REFLECTION_EMIT
static MonoType*
mono_reflection_type_get_handle (MonoReflectionType* t)
{
sig->param_count = count;
sig->sentinelpos = -1; /* FIXME */
for (i = 0; i < count; ++i) {
- MonoReflectionType *pt = mono_array_get (parameters, MonoReflectionType*, i);
+ MonoReflectionType *pt = mono_type_array_get (parameters, i);
sig->params [i] = mono_reflection_type_get_handle (pt);
}
return sig;
sig = parameters_to_signature (image, method->parameters);
sig->hasthis = method->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
- sig->ret = method->rtype? method->rtype->type: &mono_defaults.void_class->byval_arg;
+ sig->ret = method->rtype? monotype_cast (method->rtype)->type: &mono_defaults.void_class->byval_arg;
sig->generic_param_count = method->generic_params ? mono_array_length (method->generic_params) : 0;
return sig;
}
if (strcmp (klass->name, "PropertyBuilder") == 0) {
MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *)prop;
*name = mono_string_to_utf8 (pb->name);
- *type = pb->type->type;
+ *type = monotype_cast (pb->type)->type;
} else {
MonoReflectionProperty *p = (MonoReflectionProperty *)prop;
*name = g_strdup (p->property->name);
if (strcmp (klass->name, "FieldBuilder") == 0) {
MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)field;
*name = mono_string_to_utf8 (fb->name);
- *type = fb->type->type;
+ *type = monotype_cast (fb->type)->type;
} else {
MonoReflectionField *f = (MonoReflectionField *)field;
*name = g_strdup (mono_field_get_name (f->field));
*type = f->field->type;
}
}
+#endif /* !DISABLE_REFLECTION_EMIT */
/*
* Encode a value in a custom attribute stream of bytes.
*retp = p;
}
+#ifndef DISABLE_REFLECTION_EMIT
static void
encode_named_val (MonoReflectionAssembly *assembly, char *buffer, char *p, char **retbuffer, char **retp, guint32 *buflen, MonoType *type, char *name, MonoObject *value)
{
*retbuffer = buffer;
}
-#ifndef DISABLE_REFLECTION_EMIT
-
/*
* mono_reflection_get_custom_attrs_blob:
* @ctor: custom attribute constructor
MONO_ARCH_SAVE_REGS;
+ CHECK_MONOTYPE (tb->parent);
+
mono_loader_lock ();
if (tb->parent) {
/* check so we can compile corlib correctly */
if (strcmp (mono_object_class (tb->parent)->name, "TypeBuilder") == 0) {
/* mono_class_setup_mono_type () guaranteess type->data.klass is valid */
- parent = tb->parent->type->data.klass;
+ parent = monotype_cast (tb->parent)->type->data.klass;
} else {
- parent = my_mono_class_from_mono_type (tb->parent->type);
+ parent = mono_class_from_mono_type (monotype_cast (tb->parent)->type);
}
} else {
parent = NULL;
MONO_ARCH_SAVE_REGS;
- klass = my_mono_class_from_mono_type (tb->type.type);
+ klass = mono_class_from_mono_type (tb->type.type);
count = tb->generic_params ? mono_array_length (tb->generic_params) : 0;
klass->generic_container->owner.klass = klass;
klass->generic_container->type_argc = count;
- klass->generic_container->type_params = mono_image_alloc0 (klass->image, sizeof (MonoGenericParam) * count);
+ klass->generic_container->type_params = mono_image_alloc0 (klass->image, sizeof (MonoGenericParamFull) * count);
klass->is_generic = 1;
for (i = 0; i < count; i++) {
MonoReflectionGenericParam *gparam = mono_array_get (tb->generic_params, gpointer, i);
- klass->generic_container->type_params [i] = *gparam->type.type->data.generic_param;
+ MonoGenericParamFull *param = (MonoGenericParamFull *) gparam->type.type->data.generic_param;
+ klass->generic_container->type_params [i] = *param;
/*Make sure we are a diferent type instance */
- klass->generic_container->type_params [i].owner = klass->generic_container;
- klass->generic_container->type_params [i].pklass = NULL;
+ klass->generic_container->type_params [i].param.owner = klass->generic_container;
+ klass->generic_container->type_params [i].info.pklass = NULL;
- g_assert (klass->generic_container->type_params [i].owner);
+ g_assert (klass->generic_container->type_params [i].param.owner);
}
klass->generic_container->context.class_inst = mono_get_shared_generic_inst (klass->generic_container);
MONO_ARCH_SAVE_REGS;
- klass = my_mono_class_from_mono_type (tb->type.type);
+ klass = mono_class_from_mono_type (tb->type.type);
mono_loader_lock ();
if (klass->enumtype && mono_class_enum_basetype (klass) == NULL) {
fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, 0);
- if (!mono_type_is_valid_enum_basetype (fb->type->type)) {
+ if (!mono_type_is_valid_enum_basetype (monotype_cast (fb->type)->type)) {
mono_loader_unlock ();
return;
}
- enum_basetype = fb->type->type;
- klass->element_class = my_mono_class_from_mono_type (enum_basetype);
+ enum_basetype = monotype_cast (fb->type)->type;
+ klass->element_class = mono_class_from_mono_type (enum_basetype);
if (!klass->element_class)
klass->element_class = mono_class_from_mono_type (enum_basetype);
mono_loader_unlock ();
}
-#endif /* DISABLE_REFLECTION_EMIT */
-
static MonoMarshalSpec*
mono_marshal_spec_from_builder (MonoImage *image, MonoAssembly *assembly,
MonoReflectionMarshal *minfo)
case MONO_NATIVE_CUSTOM:
if (minfo->marshaltyperef)
res->data.custom_data.custom_name =
- type_get_fully_qualified_name (minfo->marshaltyperef->type);
+ type_get_fully_qualified_name (monotype_cast (minfo->marshaltyperef)->type);
if (minfo->mcookie)
res->data.custom_data.cookie = mono_string_to_utf8 (minfo->mcookie);
break;
return res;
}
+#endif /* !DISABLE_REFLECTION_EMIT */
MonoReflectionMarshal*
mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
return minfo;
}
+#ifndef DISABLE_REFLECTION_EMIT
static MonoMethod*
reflection_methodbuilder_to_mono_method (MonoClass *klass,
ReflectionMethodBuilder *rmb,
mono_array_get (rmb->ilgen->locals, MonoReflectionLocalBuilder*, i);
header->locals [i] = image_g_new0 (image, MonoType, 1);
- memcpy (header->locals [i], lb->type->type, sizeof (MonoType));
+ memcpy (header->locals [i], monotype_cast (lb->type)->type, sizeof (MonoType));
}
header->num_clauses = num_clauses;
mono_method_set_generic_container (m, container);
}
container->type_argc = count;
- container->type_params = image_g_new0 (image, MonoGenericParam, count);
+ container->type_params = image_g_new0 (image, MonoGenericParamFull, count);
container->owner.method = m;
for (i = 0; i < count; i++) {
MonoReflectionGenericParam *gp =
mono_array_get (rmb->generic_params, MonoReflectionGenericParam*, i);
-
- container->type_params [i] = *gp->type.type->data.generic_param;
+ MonoGenericParamFull *param = (MonoGenericParamFull *) gp->type.type->data.generic_param;
+ container->type_params [i] = *param;
}
if (klass->generic_container) {
field->name = mono_string_to_utf8 (fb->name);
if (fb->attrs || fb->modreq || fb->modopt) {
- field->type = mono_metadata_type_dup (NULL, fb->type->type);
+ field->type = mono_metadata_type_dup (NULL, monotype_cast (fb->type)->type);
field->type->attrs = fb->attrs;
g_assert (klass->image->dynamic);
g_free (field->type);
field->type = custom;
} else {
- field->type = fb->type->type;
+ field->type = monotype_cast (fb->type)->type;
}
if (fb->offset != -1)
field->offset = fb->offset;
return field;
}
+#endif
MonoType*
mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types)
MonoClass *klass;
MonoMethod *method, *inflated;
MonoMethodInflated *imethod;
- MonoReflectionMethodBuilder *mb = NULL;
MonoGenericContext tmp_context;
MonoGenericInst *ginst;
MonoType **type_argv;
if (!strcmp (rmethod->object.vtable->klass->name, "MethodBuilder")) {
#ifndef DISABLE_REFLECTION_EMIT
+ MonoReflectionMethodBuilder *mb = NULL;
MonoReflectionTypeBuilder *tb;
MonoClass *klass;
if (eb->remove_method)
event->remove = inflate_method (type, (MonoObject *) eb->remove_method);
} else if (!strcmp (obj->vtable->klass->name, "MonoEvent")) {
- *event = *((MonoReflectionEvent *) obj)->event;
+ *event = *((MonoReflectionMonoEvent *) obj)->event;
event->name = g_strdup (event->name);
if (event->add)
klass->interface_count = mono_array_length (tb->interfaces);
klass->interfaces = mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
for (i = 0; i < klass->interface_count; ++i) {
- MonoReflectionType *iface = mono_array_get (tb->interfaces, gpointer, i);
+ MonoReflectionType *iface = mono_type_array_get (tb->interfaces, i);
klass->interfaces [i] = mono_class_from_mono_type (iface->type);
ensure_runtime_vtable (klass->interfaces [i]);
}
field = &klass->fields [i];
field->name = mono_string_to_utf8_image (image, fb->name);
if (fb->attrs) {
- field->type = mono_metadata_type_dup (klass->image, fb->type->type);
+ field->type = mono_metadata_type_dup (klass->image, monotype_cast (fb->type)->type);
field->type->attrs = fb->attrs;
} else {
- field->type = fb->type->type;
+ field->type = monotype_cast (fb->type)->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);
MonoClass *klass;
int j;
- klass = my_mono_class_from_mono_type (tb->type.type);
+ klass = mono_class_from_mono_type (tb->type.type);
event->parent = klass;
event->attrs = eb->attrs;
return FALSE;
}
+static void
+check_array_for_usertypes (MonoArray *arr)
+{
+ int i;
+
+ if (!arr)
+ return;
+
+ for (i = 0; i < mono_array_length (arr); ++i)
+ CHECK_MONOTYPE (mono_array_get (arr, gpointer, i));
+}
+
MonoReflectionType*
mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
{
MonoClass *klass;
MonoDomain* domain;
MonoReflectionType* res;
- int i;
+ int i, j;
MONO_ARCH_SAVE_REGS;
domain = mono_object_domain (tb);
- klass = my_mono_class_from_mono_type (tb->type.type);
+ klass = mono_class_from_mono_type (tb->type.type);
+
+ /*
+ * Check for user defined Type subclasses.
+ */
+ CHECK_MONOTYPE (tb->parent);
+ check_array_for_usertypes (tb->interfaces);
+ if (tb->fields) {
+ for (i = 0; i < mono_array_length (tb->fields); ++i) {
+ MonoReflectionFieldBuilder *fb = mono_array_get (tb->fields, gpointer, i);
+ if (fb) {
+ CHECK_MONOTYPE (fb->type);
+ check_array_for_usertypes (fb->modreq);
+ check_array_for_usertypes (fb->modopt);
+ if (fb->marshal_info && fb->marshal_info->marshaltyperef)
+ CHECK_MONOTYPE (fb->marshal_info->marshaltyperef);
+ }
+ }
+ }
+ if (tb->methods) {
+ for (i = 0; i < mono_array_length (tb->methods); ++i) {
+ MonoReflectionMethodBuilder *mb = mono_array_get (tb->methods, gpointer, i);
+ if (mb) {
+ CHECK_MONOTYPE (mb->rtype);
+ check_array_for_usertypes (mb->return_modreq);
+ check_array_for_usertypes (mb->return_modopt);
+ check_array_for_usertypes (mb->parameters);
+ if (mb->param_modreq)
+ for (j = 0; j < mono_array_length (mb->param_modreq); ++j)
+ check_array_for_usertypes (mono_array_get (mb->param_modreq, MonoArray*, j));
+ if (mb->param_modopt)
+ for (j = 0; j < mono_array_length (mb->param_modopt); ++j)
+ check_array_for_usertypes (mono_array_get (mb->param_modopt, MonoArray*, j));
+ }
+ }
+ }
+ if (tb->ctors) {
+ for (i = 0; i < mono_array_length (tb->ctors); ++i) {
+ MonoReflectionCtorBuilder *mb = mono_array_get (tb->ctors, gpointer, i);
+ if (mb) {
+ check_array_for_usertypes (mb->parameters);
+ if (mb->param_modreq)
+ for (j = 0; j < mono_array_length (mb->param_modreq); ++j)
+ check_array_for_usertypes (mono_array_get (mb->param_modreq, MonoArray*, j));
+ if (mb->param_modopt)
+ for (j = 0; j < mono_array_length (mb->param_modopt); ++j)
+ check_array_for_usertypes (mono_array_get (mb->param_modopt, MonoArray*, j));
+ }
+ }
+ }
mono_save_custom_attrs (klass->image, klass, tb->cattrs);
-
+
/*
* we need to lock the domain because the lock will be taken inside
* So, we need to keep the locking order correct.
*/
- mono_domain_lock (domain);
mono_loader_lock ();
+ mono_domain_lock (domain);
if (klass->wastypebuilder) {
- mono_loader_unlock ();
mono_domain_unlock (domain);
+ mono_loader_unlock ();
return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
}
/*
for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
MonoReflectionTypeBuilder *subtb = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
mono_class_alloc_ext (klass);
- klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, my_mono_class_from_mono_type (subtb->type.type));
+ klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, mono_class_from_mono_type (subtb->type.type));
}
}
if (domain->type_hash && klass->generic_container)
mono_g_hash_table_foreach_remove (domain->type_hash, remove_instantiations_of, klass);
- mono_loader_unlock ();
mono_domain_unlock (domain);
+ mono_loader_unlock ();
if (klass->enumtype && !mono_class_is_valid_enum (klass)) {
mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
void
mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam)
{
- MonoGenericParam *param;
+ MonoGenericParamFull *param;
MonoImage *image;
+ MonoClass *pklass;
MONO_ARCH_SAVE_REGS;
- param = g_new0 (MonoGenericParam, 1);
+ param = g_new0 (MonoGenericParamFull, 1);
if (gparam->mbuilder) {
if (!gparam->mbuilder->generic_container) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)gparam->mbuilder->type;
- MonoClass *klass = my_mono_class_from_mono_type (tb->type.type);
+ MonoClass *klass = mono_class_from_mono_type (tb->type.type);
gparam->mbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
gparam->mbuilder->generic_container->is_method = TRUE;
}
- param->owner = gparam->mbuilder->generic_container;
+ param->param.owner = gparam->mbuilder->generic_container;
} else if (gparam->tbuilder) {
if (!gparam->tbuilder->generic_container) {
- MonoClass *klass = my_mono_class_from_mono_type (gparam->tbuilder->type.type);
+ MonoClass *klass = mono_class_from_mono_type (gparam->tbuilder->type.type);
gparam->tbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
gparam->tbuilder->generic_container->owner.klass = klass;
}
- param->owner = gparam->tbuilder->generic_container;
+ param->param.owner = gparam->tbuilder->generic_container;
}
- param->name = mono_string_to_utf8 (gparam->name);
- param->num = gparam->index;
+ param->info.name = mono_string_to_utf8 (gparam->name);
+ param->param.num = gparam->index;
image = &gparam->tbuilder->module->dynamic_image->image;
- mono_class_from_generic_parameter (param, image, gparam->mbuilder != NULL);
+ pklass = mono_class_from_generic_parameter ((MonoGenericParam *) param, image, gparam->mbuilder != NULL);
- gparam->type.type = ¶m->pklass->byval_arg;
+ gparam->type.type = &pklass->byval_arg;
- MOVING_GC_REGISTER (¶m->pklass->reflection_info);
- param->pklass->reflection_info = gparam; /* FIXME: GC pin gparam */
+ MOVING_GC_REGISTER (&pklass->reflection_info);
+ pklass->reflection_info = gparam; /* FIXME: GC pin gparam */
}
MonoArray *
mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
{
MonoDynamicImage *assembly = sig->module->dynamic_image;
- guint32 na = mono_array_length (sig->arguments);
+ guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
guint32 buflen, i;
MonoArray *result;
SigBuffer buf;
+ check_array_for_usertypes (sig->arguments);
+
sigbuffer_init (&buf, 32);
sigbuffer_add_value (&buf, 0x07);
sigbuffer_add_value (&buf, na);
for (i = 0; i < na; ++i) {
- MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType *, i);
+ MonoReflectionType *type = mono_type_array_get (sig->arguments, i);
encode_reflection_type (assembly, type, &buf);
}
mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
{
MonoDynamicImage *assembly = sig->module->dynamic_image;
- guint32 na = mono_array_length (sig->arguments);
+ guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
guint32 buflen, i;
MonoArray *result;
SigBuffer buf;
+ check_array_for_usertypes (sig->arguments);
+
sigbuffer_init (&buf, 32);
sigbuffer_add_value (&buf, 0x06);
for (i = 0; i < na; ++i) {
- MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType *, i);
+ MonoReflectionType *type = mono_type_array_get (sig->arguments, i);
encode_reflection_type (assembly, type, &buf);
}
}
handle_class = mono_defaults.methodhandle_class;
} else {
+ MonoException *ex = NULL;
ref = resolve_object (mb->module->image, obj, &handle_class, NULL);
- if (!ref) {
+ if (!ref)
+ ex = mono_get_exception_type_load (NULL, NULL);
+ else if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
+ ex = mono_security_core_clr_ensure_dynamic_method_resolved_object (ref, handle_class);
+
+ if (ex) {
g_free (rmb.refs);
- mono_raise_exception (mono_get_exception_type_load (NULL, NULL));
+ mono_raise_exception (ex);
return;
}
}
return resolve_object (image, obj, handle_class, context);
}
+/*
+ * ensure_complete_type:
+ *
+ * Ensure that KLASS is completed if it is a dynamic type, or references
+ * dynamic types.
+ */
+static void
+ensure_complete_type (MonoClass *klass)
+{
+ if (klass->image->dynamic && !klass->wastypebuilder) {
+ MonoReflectionTypeBuilder *tb = klass->reflection_info;
+
+ mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
+
+ // Asserting here could break a lot of code
+ //g_assert (klass->wastypebuilder);
+ }
+
+ if (klass->generic_class) {
+ MonoGenericInst *inst = klass->generic_class->context.class_inst;
+ int i;
+
+ for (i = 0; i < inst->type_argc; ++i) {
+ ensure_complete_type (mono_class_from_mono_type (inst->type_argv [i]));
+ }
+ }
+}
+
static gpointer
resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context)
{
*handle_class = mono_defaults.methodhandle_class;
} else if (strcmp (obj->vtable->klass->name, "MonoField") == 0) {
MonoClassField *field = ((MonoReflectionField*)obj)->field;
+
+ ensure_complete_type (field->parent);
if (context) {
MonoType *inflated = mono_class_inflate_generic_type (&field->parent->byval_arg, context);
MonoClass *class = mono_class_from_mono_type (inflated);
/* TODO: Copy type ? */
sig->ret = helper->return_type->type;
for (i = 0; i < nargs; ++i) {
- MonoReflectionType *rt = mono_array_get (helper->arguments, MonoReflectionType*, i);
+ MonoReflectionType *rt = mono_type_array_get (helper->arguments, i);
sig->params [i] = rt->type;
}