#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;
#define MOVING_GC_REGISTER(addr)
#endif
-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));
-}
-
typedef struct {
char *p;
char *buf;
};
-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);
void
mono_reflection_init (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);
}
}
+#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)
return num_clauses;
}
+#ifndef DISABLE_REFLECTION_EMIT
static MonoExceptionClause*
method_encode_clauses (MonoImage *image, MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, guint32 num_clauses)
{
return clauses;
}
+#endif /* !DISABLE_REFLECTION_EMIT */
static guint32
method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
return ainfo;
}
+#ifndef DISABLE_REFLECTION_EMIT
/*
* LOCKING: Acquires the loader lock.
*/
mono_loader_unlock ();
}
+#endif
void
mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
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)
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)
{
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)
{
m->table_idx = am->token & 0xffffff;
return am->token;
}
+#endif
/*
* Insert into the metadata tables all the info about the TypeBuilder tb.
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
/*
}
}
-#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
/* 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)
{
* 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);
}
/*
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;
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)
{
*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_class_setup_mono_type () guaranteess type->data.klass is valid */
parent = monotype_cast (tb->parent)->type->data.klass;
} else {
- parent = my_mono_class_from_mono_type (monotype_cast (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) {
}
enum_basetype = monotype_cast (fb->type)->type;
- klass->element_class = my_mono_class_from_mono_type (enum_basetype);
+ 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)
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_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) {
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;
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)
{
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.
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));
}
}
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 *
}
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;
}
}