3 * System.Type icalls and related reflection queries.
6 * Paolo Molaro (lupus@ximian.com)
8 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
9 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
10 * Copyright 2011 Rodrigo Kumpera
11 * Copyright 2016 Microsoft
13 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
16 #include "mono/utils/mono-membar.h"
17 #include "mono/metadata/reflection-internals.h"
18 #include "mono/metadata/tabledefs.h"
19 #include "mono/metadata/metadata-internals.h"
20 #include <mono/metadata/profiler-private.h>
21 #include "mono/metadata/class-internals.h"
22 #include "mono/metadata/gc-internals.h"
23 #include "mono/metadata/domain-internals.h"
24 #include "mono/metadata/opcodes.h"
25 #include "mono/metadata/assembly.h"
26 #include "mono/metadata/object-internals.h"
27 #include <mono/metadata/exception.h>
28 #include <mono/metadata/marshal.h>
29 #include <mono/metadata/security-manager.h>
30 #include <mono/metadata/reflection-cache.h>
31 #include <mono/metadata/sre-internals.h>
40 #include "mono-endian.h"
41 #include <mono/metadata/gc-internals.h>
42 #include <mono/metadata/mempool-internals.h>
43 #include <mono/metadata/security-core-clr.h>
44 #include <mono/metadata/debug-helpers.h>
45 #include <mono/metadata/verify-internals.h>
46 #include <mono/metadata/mono-ptr-array.h>
47 #include <mono/utils/mono-string.h>
48 #include <mono/utils/mono-error-internals.h>
49 #include <mono/utils/checked-build.h>
50 #include <mono/utils/mono-counters.h>
52 static void get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types);
53 static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error);
55 /* Class lazy loading functions */
56 static GENERATE_GET_CLASS_WITH_CACHE (mono_assembly, "System.Reflection", "MonoAssembly")
57 static GENERATE_GET_CLASS_WITH_CACHE (mono_module, "System.Reflection", "MonoModule")
58 static GENERATE_GET_CLASS_WITH_CACHE (mono_method, "System.Reflection", "MonoMethod");
59 static GENERATE_GET_CLASS_WITH_CACHE (mono_cmethod, "System.Reflection", "MonoCMethod");
60 static GENERATE_GET_CLASS_WITH_CACHE (mono_field, "System.Reflection", "MonoField");
61 static GENERATE_GET_CLASS_WITH_CACHE (mono_event, "System.Reflection", "MonoEvent");
62 static GENERATE_GET_CLASS_WITH_CACHE (mono_property, "System.Reflection", "MonoProperty");
63 static GENERATE_GET_CLASS_WITH_CACHE (mono_parameter_info, "System.Reflection", "MonoParameterInfo");
64 static GENERATE_GET_CLASS_WITH_CACHE (missing, "System.Reflection", "Missing");
65 static GENERATE_GET_CLASS_WITH_CACHE (method_body, "System.Reflection", "MethodBody");
66 static GENERATE_GET_CLASS_WITH_CACHE (local_variable_info, "System.Reflection", "LocalVariableInfo");
67 static GENERATE_GET_CLASS_WITH_CACHE (exception_handling_clause, "System.Reflection", "ExceptionHandlingClause");
68 static GENERATE_GET_CLASS_WITH_CACHE (type_builder, "System.Reflection.Emit", "TypeBuilder");
69 static GENERATE_GET_CLASS_WITH_CACHE (dbnull, "System", "DBNull");
72 static int class_ref_info_handle_count;
75 mono_reflection_init (void)
77 mono_reflection_emit_init ();
79 mono_counters_register ("MonoClass::ref_info_handle count",
80 MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_ref_info_handle_count);
85 * mono_class_get_ref_info:
87 * Return the type builder/generic param builder corresponding to KLASS, if it exists.
90 mono_class_get_ref_info (MonoClass *klass)
92 MONO_REQ_GC_UNSAFE_MODE;
93 guint32 ref_info_handle = mono_class_get_ref_info_handle (klass);
95 if (ref_info_handle == 0)
96 return MONO_HANDLE_NEW (MonoObject, NULL);
98 return mono_gchandle_get_target_handle (ref_info_handle);
102 mono_class_has_ref_info (MonoClass *klass)
104 MONO_REQ_GC_UNSAFE_MODE;
105 return 0 != mono_class_get_ref_info_handle (klass);
109 mono_class_get_ref_info_raw (MonoClass *klass)
111 /* FIXME callers of mono_class_get_ref_info_raw should use handles */
112 MONO_REQ_GC_UNSAFE_MODE;
113 guint32 ref_info_handle = mono_class_get_ref_info_handle (klass);
115 if (ref_info_handle == 0)
118 return mono_gchandle_get_target (ref_info_handle);
122 mono_class_set_ref_info (MonoClass *klass, MonoObjectHandle obj)
124 MONO_REQ_GC_UNSAFE_MODE;
126 guint32 candidate = mono_gchandle_from_handle (obj, FALSE);
127 guint32 handle = mono_class_set_ref_info_handle (klass, candidate);
128 ++class_ref_info_handle_count;
130 if (handle != candidate)
131 mono_gchandle_free (candidate);
135 mono_class_free_ref_info (MonoClass *klass)
137 MONO_REQ_GC_NEUTRAL_MODE;
138 guint32 handle = mono_class_get_ref_info_handle (klass);
141 mono_gchandle_free (handle);
142 mono_class_set_ref_info_handle (klass, 0);
148 * mono_custom_attrs_free:
151 mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
153 MONO_REQ_GC_NEUTRAL_MODE;
155 if (ainfo && !ainfo->cached)
161 reflected_equal (gconstpointer a, gconstpointer b)
163 const ReflectedEntry *ea = (const ReflectedEntry *)a;
164 const ReflectedEntry *eb = (const ReflectedEntry *)b;
166 return (ea->item == eb->item) && (ea->refclass == eb->refclass);
170 reflected_hash (gconstpointer a) {
171 const ReflectedEntry *ea = (const ReflectedEntry *)a;
172 /* Combine hashes for item and refclass. Identical to boost's hash_combine */
173 guint seed = mono_aligned_addr_hash (ea->item) + 0x9e3779b9;
174 seed ^= mono_aligned_addr_hash (ea->refclass) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
180 clear_cached_object (MonoDomain *domain, gpointer o, MonoClass *klass)
182 mono_domain_lock (domain);
183 if (domain->refobject_hash) {
185 gpointer orig_pe, orig_value;
190 if (mono_conc_g_hash_table_lookup_extended (domain->refobject_hash, &pe, &orig_pe, &orig_value)) {
191 mono_conc_g_hash_table_remove (domain->refobject_hash, &pe);
192 FREE_REFENTRY (orig_pe);
195 mono_domain_unlock (domain);
198 #ifdef REFENTRY_REQUIRES_CLEANUP
200 cleanup_refobject_hash (gpointer key, gpointer value, gpointer user_data)
207 mono_reflection_cleanup_domain (MonoDomain *domain)
209 if (domain->refobject_hash) {
210 /*let's avoid scanning the whole hashtable if not needed*/
211 #ifdef REFENTRY_REQUIRES_CLEANUP
212 mono_conc_g_hash_table_foreach (domain->refobject_hash, cleanup_refobject_hash, NULL);
214 mono_conc_g_hash_table_destroy (domain->refobject_hash);
215 domain->refobject_hash = NULL;
221 * mono_assembly_get_object:
222 * \param domain an app domain
223 * \param assembly an assembly
224 * \returns a \c System.Reflection.Assembly object representing the \c MonoAssembly \p assembly.
226 MonoReflectionAssembly*
227 mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
229 HANDLE_FUNCTION_ENTER ();
231 MonoReflectionAssemblyHandle result = mono_assembly_get_object_handle (domain, assembly, &error);
232 mono_error_cleanup (&error); /* FIXME new API that doesn't swallow the error */
233 HANDLE_FUNCTION_RETURN_OBJ (result);
236 static MonoReflectionAssemblyHandle
237 assembly_object_construct (MonoDomain *domain, MonoClass *unused_klass, MonoAssembly *assembly, gpointer user_data, MonoError *error)
240 MonoReflectionAssemblyHandle res = MONO_HANDLE_NEW (MonoReflectionAssembly, mono_object_new_checked (domain, mono_class_get_mono_assembly_class (), error));
241 return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE));
242 MONO_HANDLE_SETVAL (res, assembly, MonoAssembly*, assembly);
247 * mono_assembly_get_object_handle:
248 * @domain: an app domain
249 * @assembly: an assembly
251 * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
253 MonoReflectionAssemblyHandle
254 mono_assembly_get_object_handle (MonoDomain *domain, MonoAssembly *assembly, MonoError *error)
257 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionAssemblyHandle, assembly, NULL, assembly_object_construct, NULL);
261 * mono_module_get_object:
263 MonoReflectionModule*
264 mono_module_get_object (MonoDomain *domain, MonoImage *image)
266 HANDLE_FUNCTION_ENTER ();
268 MonoReflectionModuleHandle result = mono_module_get_object_handle (domain, image, &error);
269 mono_error_cleanup (&error);
270 HANDLE_FUNCTION_RETURN_OBJ (result);
273 static MonoReflectionModuleHandle
274 module_object_construct (MonoDomain *domain, MonoClass *unused_klass, MonoImage *image, gpointer user_data, MonoError *error)
279 MonoReflectionModuleHandle res = MONO_HANDLE_NEW (MonoReflectionModule, mono_object_new_checked (domain, mono_class_get_mono_module_class (), error));
283 MONO_HANDLE_SETVAL (res, image, MonoImage *, image);
284 MonoReflectionAssemblyHandle assm_obj = mono_assembly_get_object_handle (domain, image->assembly, error);
287 MONO_HANDLE_SET (res, assembly, assm_obj);
289 MONO_HANDLE_SET (res, fqname, mono_string_new_handle (domain, image->name, error));
292 basename = g_path_get_basename (image->name);
293 MONO_HANDLE_SET (res, name, mono_string_new_handle (domain, basename, error));
296 MONO_HANDLE_SET (res, scopename, mono_string_new_handle (domain, image->module_name, error));
303 if (image->assembly->image == image) {
304 token = mono_metadata_make_token (MONO_TABLE_MODULE, 1);
307 if (image->assembly->image->modules) {
308 for (i = 0; i < image->assembly->image->module_count; i++) {
309 if (image->assembly->image->modules [i] == image)
310 token = mono_metadata_make_token (MONO_TABLE_MODULEREF, i + 1);
312 g_assert (token != 0);
315 MONO_HANDLE_SETVAL (res, token, guint32, token);
319 return MONO_HANDLE_CAST (MonoReflectionModule, NULL_HANDLE);
322 MonoReflectionModuleHandle
323 mono_module_get_object_handle (MonoDomain *domain, MonoImage *image, MonoError *error)
326 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionModuleHandle, image, NULL, module_object_construct, NULL);
330 * mono_module_file_get_object:
332 MonoReflectionModule*
333 mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index)
335 HANDLE_FUNCTION_ENTER ();
337 MonoReflectionModuleHandle result = mono_module_file_get_object_handle (domain, image, table_index, &error);
338 mono_error_cleanup (&error);
339 HANDLE_FUNCTION_RETURN_OBJ (result);
342 MonoReflectionModuleHandle
343 mono_module_file_get_object_handle (MonoDomain *domain, MonoImage *image, int table_index, MonoError *error)
345 MonoTableInfo *table;
346 guint32 cols [MONO_FILE_SIZE];
353 MonoReflectionModuleHandle res = MONO_HANDLE_NEW (MonoReflectionModule, mono_object_new_checked (domain, mono_class_get_mono_module_class (), error));
357 table = &image->tables [MONO_TABLE_FILE];
358 g_assert (table_index < table->rows);
359 mono_metadata_decode_row (table, table_index, cols, MONO_FILE_SIZE);
361 MONO_HANDLE_SETVAL (res, image, MonoImage*, NULL);
362 MonoReflectionAssemblyHandle assm_obj = mono_assembly_get_object_handle (domain, image->assembly, error);
365 MONO_HANDLE_SET (res, assembly, assm_obj);
366 name = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]);
368 /* Check whenever the row has a corresponding row in the moduleref table */
369 table = &image->tables [MONO_TABLE_MODULEREF];
370 for (i = 0; i < table->rows; ++i) {
371 name_idx = mono_metadata_decode_row_col (table, i, MONO_MODULEREF_NAME);
372 val = mono_metadata_string_heap (image, name_idx);
373 if (strcmp (val, name) == 0)
374 MONO_HANDLE_SETVAL (res, image, MonoImage*, image->modules [i]);
377 MONO_HANDLE_SET (res, fqname, mono_string_new_handle (domain, name, error));
380 MONO_HANDLE_SET (res, name, mono_string_new_handle (domain, name, error));
383 MONO_HANDLE_SET (res, scopename, mono_string_new_handle (domain, name, error));
386 MONO_HANDLE_SETVAL (res, is_resource, MonoBoolean, cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA);
387 MONO_HANDLE_SETVAL (res, token, guint32, mono_metadata_make_token (MONO_TABLE_FILE, table_index + 1));
391 return MONO_HANDLE_CAST (MonoReflectionModule, NULL_HANDLE);
395 mono_type_normalize (MonoType *type)
398 MonoGenericClass *gclass;
399 MonoGenericInst *ginst;
401 MonoGenericContainer *gcontainer;
402 MonoType **argv = NULL;
403 gboolean is_denorm_gtd = TRUE, requires_rebind = FALSE;
405 if (type->type != MONO_TYPE_GENERICINST)
408 gclass = type->data.generic_class;
409 ginst = gclass->context.class_inst;
413 gtd = gclass->container_class;
414 gcontainer = mono_class_get_generic_container (gtd);
415 argv = g_newa (MonoType*, ginst->type_argc);
417 for (i = 0; i < ginst->type_argc; ++i) {
418 MonoType *t = ginst->type_argv [i], *norm;
419 if (t->type != MONO_TYPE_VAR || t->data.generic_param->num != i || t->data.generic_param->owner != gcontainer)
420 is_denorm_gtd = FALSE;
421 norm = mono_type_normalize (t);
424 requires_rebind = TRUE;
428 return type->byref == gtd->byval_arg.byref ? >d->byval_arg : >d->this_arg;
430 if (requires_rebind) {
431 MonoClass *klass = mono_class_bind_generic_parameters (gtd, ginst->type_argc, argv, gclass->is_dynamic);
432 return type->byref == klass->byval_arg.byref ? &klass->byval_arg : &klass->this_arg;
439 * mono_type_get_object:
440 * \param domain an app domain
442 * \returns A \c System.MonoType object representing the type \p type.
445 mono_type_get_object (MonoDomain *domain, MonoType *type)
448 MonoReflectionType *ret = mono_type_get_object_checked (domain, type, &error);
449 mono_error_cleanup (&error);
455 mono_type_get_object_checked (MonoDomain *domain, MonoType *type, MonoError *error)
458 MonoReflectionType *res;
463 g_assert (type != NULL);
464 klass = mono_class_from_mono_type (type);
466 /*we must avoid using @type as it might have come
467 * from a mono_metadata_type_dup and the caller
468 * expects that is can be freed.
469 * Using the right type from
471 type = klass->byval_arg.byref == type->byref ? &klass->byval_arg : &klass->this_arg;
473 /* void is very common */
474 if (type->type == MONO_TYPE_VOID && domain->typeof_void)
475 return (MonoReflectionType*)domain->typeof_void;
478 * If the vtable of the given class was already created, we can use
479 * the MonoType from there and avoid all locking and hash table lookups.
481 * We cannot do this for TypeBuilders as mono_reflection_create_runtime_class expects
482 * that the resulting object is different.
484 if (type == &klass->byval_arg && !image_is_dynamic (klass->image)) {
485 MonoVTable *vtable = mono_class_try_get_vtable (domain, klass);
486 if (vtable && vtable->type)
487 return (MonoReflectionType *)vtable->type;
490 mono_loader_lock (); /*FIXME mono_class_init and mono_class_vtable acquire it*/
491 mono_domain_lock (domain);
492 if (!domain->type_hash)
493 domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
494 (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection types table");
495 if ((res = (MonoReflectionType *)mono_g_hash_table_lookup (domain->type_hash, type))) {
496 mono_domain_unlock (domain);
497 mono_loader_unlock ();
501 /*Types must be normalized so a generic instance of the GTD get's the same inner type.
502 * For example in: Foo<A,B>; Bar<A> : Foo<A, Bar<A>>
503 * The second Bar will be encoded a generic instance of Bar with <A> as parameter.
504 * On all other places, Bar<A> will be encoded as the GTD itself. This is an implementation
505 * artifact of how generics are encoded and should be transparent to managed code so we
506 * need to weed out this diference when retrieving managed System.Type objects.
508 norm_type = mono_type_normalize (type);
509 if (norm_type != type) {
510 res = mono_type_get_object_checked (domain, norm_type, error);
511 if (!mono_error_ok (error))
513 mono_g_hash_table_insert (domain->type_hash, type, res);
514 mono_domain_unlock (domain);
515 mono_loader_unlock ();
519 if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_class->is_dynamic && !type->data.generic_class->container_class->wastypebuilder) {
520 /* This can happen if a TypeBuilder for a generic class K<T,U>
521 * had reflection_create_generic_class) called on it, but not
522 * ves_icall_TypeBuilder_create_runtime_class. This can happen
523 * if the K`2 is refernced from a generic instantiation
524 * (e.g. K<int,string>) that appears as type argument
525 * (e.g. Dict<string,K<int,string>>), field (e.g. K<int,string>
526 * Foo) or method signature, parent class or any of the above
527 * in a nested class of some other TypeBuilder. Such an
528 * occurrence caused mono_reflection_type_get_handle to be
529 * called on the sre generic instance (K<int,string>) which
530 * required the container_class for the generic class K`2 to be
531 * set up, but the remainder of class construction for K`2 has
533 char * full_name = mono_type_get_full_name (klass);
534 /* I would have expected ReflectionTypeLoadException, but evidently .NET throws TLE in this case. */
535 mono_error_set_type_load_class (error, klass, "TypeBuilder.CreateType() not called for generic class %s", full_name);
537 mono_domain_unlock (domain);
538 mono_loader_unlock ();
542 if (mono_class_has_ref_info (klass) && !klass->wastypebuilder && !type->byref) {
543 mono_domain_unlock (domain);
544 mono_loader_unlock ();
545 return (MonoReflectionType *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
547 /* This is stored in vtables/JITted code so it has to be pinned */
548 res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.runtimetype_class, error);
549 if (!mono_error_ok (error))
553 mono_g_hash_table_insert (domain->type_hash, type, res);
555 if (type->type == MONO_TYPE_VOID)
556 domain->typeof_void = (MonoObject*)res;
558 mono_domain_unlock (domain);
559 mono_loader_unlock ();
563 MonoReflectionTypeHandle
564 mono_type_get_object_handle (MonoDomain *domain, MonoType *type, MonoError *error)
566 /* NOTE: We happen to know that mono_type_get_object_checked returns
567 * pinned objects, so we can just wrap its return value in a handle for
568 * uniformity. If it ever starts returning unpinned, objects, this
569 * implementation would need to change!
571 return MONO_HANDLE_NEW (MonoReflectionType, mono_type_get_object_checked (domain, type, error));
575 * mono_method_get_object:
576 * \param domain an app domain
577 * \param method a method
578 * \param refclass the reflected type (can be NULL)
579 * \returns A \c System.Reflection.MonoMethod object representing the method \p method.
581 MonoReflectionMethod*
582 mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
584 HANDLE_FUNCTION_ENTER ();
586 MonoReflectionMethodHandle ret = mono_method_get_object_handle (domain, method, refclass, &error);
587 mono_error_cleanup (&error);
588 HANDLE_FUNCTION_RETURN_OBJ (ret);
591 static MonoReflectionMethodHandle
592 method_object_construct (MonoDomain *domain, MonoClass *refclass, MonoMethod *method, gpointer user_data, MonoError *error)
595 g_assert (refclass != NULL);
597 * We use the same C representation for methods and constructors, but the type
598 * name in C# is different.
604 if (*method->name == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0)) {
605 klass = mono_class_get_mono_cmethod_class ();
608 klass = mono_class_get_mono_method_class ();
610 MonoReflectionMethodHandle ret = MONO_HANDLE_NEW (MonoReflectionMethod, mono_object_new_checked (domain, klass, error));
613 MONO_HANDLE_SETVAL (ret, method, MonoMethod*, method);
615 MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &refclass->byval_arg, error);
619 MONO_HANDLE_SET (ret, reftype, rt);
624 return MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE);
628 * mono_method_get_object_handle:
629 * @domain: an app domain
631 * @refclass: the reflected type (can be NULL)
632 * @error: set on error.
634 * Return an System.Reflection.MonoMethod object representing the method @method.
635 * Returns NULL and sets @error on error.
637 MonoReflectionMethodHandle
638 mono_method_get_object_handle (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
642 refclass = method->klass;
644 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionMethodHandle, method, refclass, method_object_construct, NULL);
647 * mono_method_get_object_checked:
648 * @domain: an app domain
650 * @refclass: the reflected type (can be NULL)
651 * @error: set on error.
653 * Return an System.Reflection.MonoMethod object representing the method @method.
654 * Returns NULL and sets @error on error.
656 MonoReflectionMethod*
657 mono_method_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
659 HANDLE_FUNCTION_ENTER ();
660 MonoReflectionMethodHandle result = mono_method_get_object_handle (domain, method, refclass, error);
661 HANDLE_FUNCTION_RETURN_OBJ (result);
665 * mono_method_clear_object:
667 * Clear the cached reflection objects for the dynamic method METHOD.
670 mono_method_clear_object (MonoDomain *domain, MonoMethod *method)
673 g_assert (method_is_dynamic (method));
675 klass = method->klass;
677 clear_cached_object (domain, method, klass);
678 klass = klass->parent;
680 /* Added by mono_param_get_objects () */
681 clear_cached_object (domain, &(method->signature), NULL);
682 klass = method->klass;
684 clear_cached_object (domain, &(method->signature), klass);
685 klass = klass->parent;
690 * mono_field_get_object:
691 * \param domain an app domain
692 * \param klass a type
693 * \param field a field
694 * \returns A \c System.Reflection.MonoField object representing the field \p field
698 mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field)
700 HANDLE_FUNCTION_ENTER ();
702 MonoReflectionFieldHandle result = mono_field_get_object_handle (domain, klass, field, &error);
703 mono_error_cleanup (&error);
704 HANDLE_FUNCTION_RETURN_OBJ (result);
707 static MonoReflectionFieldHandle
708 field_object_construct (MonoDomain *domain, MonoClass *klass, MonoClassField *field, gpointer user_data, MonoError *error)
712 MonoReflectionFieldHandle res = MONO_HANDLE_NEW (MonoReflectionField, mono_object_new_checked (domain, mono_class_get_mono_field_class (), error));
715 MONO_HANDLE_SETVAL (res, klass, MonoClass *, klass);
716 MONO_HANDLE_SETVAL (res, field, MonoClassField *, field);
717 MonoStringHandle name = mono_string_new_handle (domain, mono_field_get_name (field), error);
720 MONO_HANDLE_SET (res, name, name);
723 MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, field->type, error);
727 MONO_HANDLE_SET (res, type, rt);
729 MONO_HANDLE_SETVAL (res, attrs, guint32, mono_field_get_flags (field));
732 return MONO_HANDLE_CAST (MonoReflectionField, NULL_HANDLE);
736 * mono_field_get_object_handle:
737 * @domain: an app domain
740 * @error: set on error
742 * Return an System.Reflection.MonoField object representing the field @field
743 * in class @klass. On error, returns NULL and sets @error.
745 MonoReflectionFieldHandle
746 mono_field_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
749 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionFieldHandle, field, klass, field_object_construct, NULL);
754 * mono_field_get_object_checked:
755 * @domain: an app domain
758 * @error: set on error
760 * Return an System.Reflection.MonoField object representing the field @field
761 * in class @klass. On error, returns NULL and sets @error.
764 mono_field_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
766 HANDLE_FUNCTION_ENTER ();
767 MonoReflectionFieldHandle result = mono_field_get_object_handle (domain, klass, field, error);
768 HANDLE_FUNCTION_RETURN_OBJ (result);
772 * mono_property_get_object:
773 * @domain: an app domain
775 * @property: a property
777 * Return an System.Reflection.MonoProperty object representing the property @property
780 MonoReflectionProperty*
781 mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property)
783 HANDLE_FUNCTION_ENTER ();
785 MonoReflectionPropertyHandle result = mono_property_get_object_handle (domain, klass, property, &error);
786 mono_error_cleanup (&error);
787 HANDLE_FUNCTION_RETURN_OBJ (result);
790 static MonoReflectionPropertyHandle
791 property_object_construct (MonoDomain *domain, MonoClass *klass, MonoProperty *property, gpointer user_data, MonoError *error)
795 MonoReflectionPropertyHandle res = MONO_HANDLE_NEW (MonoReflectionProperty, mono_object_new_checked (domain, mono_class_get_mono_property_class (), error));
798 MONO_HANDLE_SETVAL (res, klass, MonoClass *, klass);
799 MONO_HANDLE_SETVAL (res, property, MonoProperty *, property);
802 return MONO_HANDLE_CAST (MonoReflectionProperty, NULL_HANDLE);
806 * mono_property_get_object_handle:
807 * \param domain an app domain
808 * \param klass a type
809 * \param property a property
810 * \param error set on error
812 * \returns A \c System.Reflection.MonoProperty object representing the property \p property
813 * in class \p klass. On error returns NULL and sets \p error.
815 MonoReflectionPropertyHandle
816 mono_property_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error)
818 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionPropertyHandle, property, klass, property_object_construct, NULL);
822 * mono_property_get_object:
823 * \param domain an app domain
824 * \param klass a type
825 * \param property a property
826 * \param error set on error
827 * \returns a \c System.Reflection.MonoProperty object representing the property \p property
828 * in class \p klass. On error returns NULL and sets \p error.
830 MonoReflectionProperty*
831 mono_property_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error)
833 HANDLE_FUNCTION_ENTER ();
834 MonoReflectionPropertyHandle res = mono_property_get_object_handle (domain, klass, property, error);
835 HANDLE_FUNCTION_RETURN_OBJ (res);
839 * mono_event_get_object:
840 * \param domain an app domain
841 * \param klass a type
842 * \param event a event
843 * \returns A \c System.Reflection.MonoEvent object representing the event \p event
847 mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
849 HANDLE_FUNCTION_ENTER ();
851 MonoReflectionEventHandle result = mono_event_get_object_handle (domain, klass, event, &error);
852 mono_error_cleanup (&error);
853 HANDLE_FUNCTION_RETURN_OBJ (result);
856 static MonoReflectionEventHandle
857 event_object_construct (MonoDomain *domain, MonoClass *klass, MonoEvent *event, gpointer user_data, MonoError *error)
861 MonoReflectionMonoEventHandle mono_event = MONO_HANDLE_NEW (MonoReflectionMonoEvent, mono_object_new_checked (domain, mono_class_get_mono_event_class (), error));
863 return MONO_HANDLE_CAST (MonoReflectionEvent, NULL_HANDLE);
864 MONO_HANDLE_SETVAL (mono_event, klass, MonoClass* , klass);
865 MONO_HANDLE_SETVAL (mono_event, event, MonoEvent* , event);
866 return MONO_HANDLE_CAST (MonoReflectionEvent, mono_event);
870 * mono_event_get_object_handle:
871 * \param domain an app domain
872 * \param klass a type
873 * \param event a event
874 * \param error set on error
875 * \returns a \c System.Reflection.MonoEvent object representing the event \p event
876 * in class \p klass. On failure sets \p error and returns NULL
878 MonoReflectionEventHandle
879 mono_event_get_object_handle (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error)
882 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionEventHandle, event, klass, event_object_construct, NULL);
887 * mono_get_reflection_missing_object:
888 * \param domain Domain where the object lives
890 * \returns the \c System.Reflection.Missing.Value singleton object
891 * (of type \c System.Reflection.Missing).
893 * Used as the value for \c ParameterInfo.DefaultValue when Optional
896 static MonoObjectHandle
897 mono_get_reflection_missing_object (MonoDomain *domain)
900 static MonoClassField *missing_value_field = NULL;
902 if (!missing_value_field) {
903 MonoClass *missing_klass;
904 missing_klass = mono_class_get_missing_class ();
905 mono_class_init (missing_klass);
906 missing_value_field = mono_class_get_field_from_name (missing_klass, "Value");
907 g_assert (missing_value_field);
909 /* FIXME change mono_field_get_value_object_checked to return a handle */
910 MonoObjectHandle obj = MONO_HANDLE_NEW (MonoObject, mono_field_get_value_object_checked (domain, missing_value_field, NULL, &error));
911 mono_error_assert_ok (&error);
915 static MonoObjectHandle
916 get_dbnull_object (MonoDomain *domain, MonoError *error)
918 static MonoClassField *dbnull_value_field = NULL;
922 if (!dbnull_value_field) {
923 MonoClass *dbnull_klass;
924 dbnull_klass = mono_class_get_dbnull_class ();
925 dbnull_value_field = mono_class_get_field_from_name (dbnull_klass, "Value");
926 g_assert (dbnull_value_field);
928 /* FIXME change mono_field_get_value_object_checked to return a handle */
929 MonoObjectHandle obj = MONO_HANDLE_NEW (MonoObject, mono_field_get_value_object_checked (domain, dbnull_value_field, NULL, error));
933 static MonoObjectHandle
934 get_dbnull (MonoDomain *domain, MonoObjectHandle dbnull, MonoError *error)
937 if (MONO_HANDLE_IS_NULL (dbnull))
938 MONO_HANDLE_ASSIGN (dbnull, get_dbnull_object (domain, error));
942 static MonoObjectHandle
943 get_reflection_missing (MonoDomain *domain, MonoObjectHandleOut reflection_missing)
945 if (MONO_HANDLE_IS_NULL (reflection_missing))
946 MONO_HANDLE_ASSIGN (reflection_missing, mono_get_reflection_missing_object (domain));
947 return reflection_missing;
951 add_parameter_object_to_array (MonoDomain *domain, MonoMethod *method, MonoObjectHandle member, int idx, const char *name, MonoType *sig_param, guint32 blob_type_enum, const char *blob, MonoMarshalSpec *mspec, MonoObjectHandle missing, MonoObjectHandle dbnull, MonoArrayHandle dest, MonoError *error)
953 HANDLE_FUNCTION_ENTER ();
955 MonoReflectionParameterHandle param = MONO_HANDLE_NEW (MonoReflectionParameter, mono_object_new_checked (domain, mono_class_get_mono_parameter_info_class (), error));
959 MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, sig_param, error);
963 MONO_HANDLE_SET (param, ClassImpl, rt);
965 MONO_HANDLE_SET (param, MemberImpl, member);
967 MonoStringHandle name_str = mono_string_new_handle (domain, name, error);
971 MONO_HANDLE_SET (param, NameImpl, name_str);
973 MONO_HANDLE_SETVAL (param, PositionImpl, gint32, idx);
975 MONO_HANDLE_SETVAL (param, AttrsImpl, guint32, sig_param->attrs);
977 if (!(sig_param->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT)) {
978 if (sig_param->attrs & PARAM_ATTRIBUTE_OPTIONAL)
979 MONO_HANDLE_SET (param, DefaultValueImpl, get_reflection_missing (domain, missing));
981 MONO_HANDLE_SET (param, DefaultValueImpl, get_dbnull (domain, dbnull, error));
988 blob_type.type = (MonoTypeEnum)blob_type_enum;
989 blob_type.data.klass = NULL;
990 if (blob_type_enum == MONO_TYPE_CLASS)
991 blob_type.data.klass = mono_defaults.object_class;
992 else if ((sig_param->type == MONO_TYPE_VALUETYPE) && sig_param->data.klass->enumtype) {
993 /* For enums, types [i] contains the base type */
995 blob_type.type = MONO_TYPE_VALUETYPE;
996 blob_type.data.klass = mono_class_from_mono_type (sig_param);
998 blob_type.data.klass = mono_class_from_mono_type (&blob_type);
1000 MonoObjectHandle default_val_obj = MONO_HANDLE_NEW (MonoObject, mono_get_object_from_blob (domain, &blob_type, blob, error)); /* FIXME make mono_get_object_from_blob return a handle */
1003 MONO_HANDLE_SET (param, DefaultValueImpl, default_val_obj);
1005 /* Type in the Constant table is MONO_TYPE_CLASS for nulls */
1006 if (blob_type_enum != MONO_TYPE_CLASS && MONO_HANDLE_IS_NULL(default_val_obj)) {
1007 if (sig_param->attrs & PARAM_ATTRIBUTE_OPTIONAL)
1008 MONO_HANDLE_SET (param, DefaultValueImpl, get_reflection_missing (domain, missing));
1010 MONO_HANDLE_SET (param, DefaultValueImpl, get_dbnull (domain, dbnull, error));
1017 MonoReflectionMarshalAsAttributeHandle mobj = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspec, error);
1020 MONO_HANDLE_SET (param, MarshalAsImpl, mobj);
1023 MONO_HANDLE_ARRAY_SETREF (dest, idx, param);
1026 HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
1029 static MonoArrayHandle
1030 param_objects_construct (MonoDomain *domain, MonoClass *refclass, MonoMethodSignature **addr_of_sig, gpointer user_data, MonoError *error)
1032 MonoMethod *method = (MonoMethod*)user_data;
1033 MonoMethodSignature *sig = *addr_of_sig; /* see note in mono_param_get_objects_internal */
1035 MonoArrayHandle res = MONO_HANDLE_NEW (MonoArray, NULL);
1036 char **names = NULL, **blobs = NULL;
1037 guint32 *types = NULL;
1038 MonoMarshalSpec **mspecs = NULL;
1043 MonoReflectionMethodHandle member = mono_method_get_object_handle (domain, method, refclass, error);
1046 names = g_new (char *, sig->param_count);
1047 mono_method_get_param_names (method, (const char **) names);
1049 mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
1050 mono_method_get_marshal_info (method, mspecs);
1052 res = mono_array_new_handle (domain, mono_class_get_mono_parameter_info_class (), sig->param_count, error);
1056 gboolean any_default_value = FALSE;
1057 for (i = 0; i < sig->param_count; ++i) {
1058 if ((sig->params [i]->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) != 0) {
1059 any_default_value = TRUE;
1063 if (any_default_value) {
1064 blobs = g_new0 (char *, sig->param_count);
1065 types = g_new0 (guint32, sig->param_count);
1066 get_default_param_value_blobs (method, blobs, types);
1069 /* Handles missing and dbnull are assigned in add_parameter_object_to_array when needed */
1070 MonoObjectHandle missing = MONO_HANDLE_NEW (MonoObject, NULL);
1071 MonoObjectHandle dbnull = MONO_HANDLE_NEW (MonoObject, NULL);
1072 for (i = 0; i < sig->param_count; ++i) {
1073 if (!add_parameter_object_to_array (domain, method, MONO_HANDLE_CAST(MonoObject, member), i, names[i], sig->params[i], types ? types[i] : 0, blobs ? blobs[i] : NULL, mspecs [i + 1], missing, dbnull, res, error))
1082 if (sig && mspecs) {
1083 for (i = sig->param_count; i >= 0; i--) {
1085 mono_metadata_free_marshal_spec (mspecs [i]);
1097 * mono_param_get_objects:
1098 * @domain: an app domain
1101 * Return an System.Reflection.ParameterInfo array object representing the parameters
1102 * in the method @method.
1105 mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
1109 /* side-effect: sets method->signature non-NULL on success */
1110 MonoMethodSignature *sig = mono_method_signature_checked (method, error);
1114 if (!sig->param_count) {
1115 MonoArrayHandle res = mono_array_new_handle (domain, mono_class_get_mono_parameter_info_class (), 0, error);
1122 /* Note: the cache is based on the address of the signature into the method
1123 * since we already cache MethodInfos with the method as keys.
1125 return CHECK_OR_CONSTRUCT_HANDLE (MonoArrayHandle, &method->signature, refclass, param_objects_construct, method);
1127 return MONO_HANDLE_NEW (MonoArray, NULL_HANDLE);
1131 * mono_param_get_objects:
1134 mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
1136 HANDLE_FUNCTION_ENTER ();
1138 MonoArrayHandle result = mono_param_get_objects_internal (domain, method, NULL, &error);
1139 mono_error_assert_ok (&error);
1140 HANDLE_FUNCTION_RETURN_OBJ (result);
1144 add_local_var_info_to_array (MonoDomain *domain, MonoMethodHeader *header, int idx, MonoArrayHandle dest, MonoError *error)
1146 HANDLE_FUNCTION_ENTER ();
1148 MonoReflectionLocalVariableInfoHandle info = MONO_HANDLE_NEW (MonoReflectionLocalVariableInfo, mono_object_new_checked (domain, mono_class_get_local_variable_info_class (), error));
1152 MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, header->locals [idx], error);
1156 MONO_HANDLE_SET (info, local_type, rt);
1158 MONO_HANDLE_SETVAL (info, is_pinned, MonoBoolean, header->locals [idx]->pinned);
1159 MONO_HANDLE_SETVAL (info, local_index, guint16, idx);
1161 MONO_HANDLE_ARRAY_SETREF (dest, idx, info);
1164 HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
1168 add_exception_handling_clause_to_array (MonoDomain *domain, MonoMethodHeader *header, int idx, MonoArrayHandle dest, MonoError *error)
1170 HANDLE_FUNCTION_ENTER ();
1172 MonoReflectionExceptionHandlingClauseHandle info = MONO_HANDLE_NEW (MonoReflectionExceptionHandlingClause, mono_object_new_checked (domain, mono_class_get_exception_handling_clause_class (), error));
1175 MonoExceptionClause *clause = &header->clauses [idx];
1177 MONO_HANDLE_SETVAL (info, flags, gint32, clause->flags);
1178 MONO_HANDLE_SETVAL (info, try_offset, gint32, clause->try_offset);
1179 MONO_HANDLE_SETVAL (info, try_length, gint32, clause->try_len);
1180 MONO_HANDLE_SETVAL (info, handler_offset, gint32, clause->handler_offset);
1181 MONO_HANDLE_SETVAL (info, handler_length, gint32, clause->handler_len);
1182 if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER)
1183 MONO_HANDLE_SETVAL (info, filter_offset, gint32, clause->data.filter_offset);
1184 else if (clause->data.catch_class) {
1185 MonoReflectionTypeHandle rt = mono_type_get_object_handle (mono_domain_get (), &clause->data.catch_class->byval_arg, error);
1189 MONO_HANDLE_SET (info, catch_type, rt);
1192 MONO_HANDLE_ARRAY_SETREF (dest, idx, info);
1194 HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
1198 * mono_method_body_get_object:
1199 * \param domain an app domain
1200 * \param method a method
1201 * \return A \c System.Reflection.MethodBody object representing the method \p method.
1203 MonoReflectionMethodBody*
1204 mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
1206 HANDLE_FUNCTION_ENTER ();
1208 MonoReflectionMethodBodyHandle result = mono_method_body_get_object_handle (domain, method, &error);
1209 mono_error_cleanup (&error);
1210 HANDLE_FUNCTION_RETURN_OBJ (result);
1213 static MonoReflectionMethodBodyHandle
1214 method_body_object_construct (MonoDomain *domain, MonoClass *unused_class, MonoMethod *method, gpointer user_data, MonoError *error)
1216 MonoMethodHeader *header = NULL;
1218 guint32 method_rva, local_var_sig_token;
1220 unsigned char format, flags;
1225 /* for compatibility with .net */
1226 if (method_is_dynamic (method)) {
1227 mono_error_set_generic_error (error, "System", "InvalidOperationException", "");
1231 if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
1232 (method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
1233 (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
1234 (method->klass->image->raw_data && method->klass->image->raw_data [1] != 'Z') ||
1235 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME))
1236 return MONO_HANDLE_CAST (MonoReflectionMethodBody, NULL_HANDLE);
1238 image = method->klass->image;
1239 header = mono_method_get_header_checked (method, error);
1243 if (!image_is_dynamic (image)) {
1244 /* Obtain local vars signature token */
1245 method_rva = mono_metadata_decode_row_col (&image->tables [MONO_TABLE_METHOD], mono_metadata_token_index (method->token) - 1, MONO_METHOD_RVA);
1246 ptr = mono_image_rva_map (image, method_rva);
1247 flags = *(const unsigned char *) ptr;
1248 format = flags & METHOD_HEADER_FORMAT_MASK;
1250 case METHOD_HEADER_TINY_FORMAT:
1251 local_var_sig_token = 0;
1253 case METHOD_HEADER_FAT_FORMAT:
1257 local_var_sig_token = read32 (ptr);
1260 g_assert_not_reached ();
1263 local_var_sig_token = 0; //FIXME
1265 MonoReflectionMethodBodyHandle ret = MONO_HANDLE_NEW (MonoReflectionMethodBody, mono_object_new_checked (domain, mono_class_get_method_body_class (), error));
1269 MONO_HANDLE_SETVAL (ret, init_locals, MonoBoolean, header->init_locals);
1270 MONO_HANDLE_SETVAL (ret, max_stack, guint32, header->max_stack);
1271 MONO_HANDLE_SETVAL (ret, local_var_sig_token, guint32, local_var_sig_token);
1272 MonoArrayHandle il_arr = mono_array_new_handle (domain, mono_defaults.byte_class, header->code_size, error);
1275 MONO_HANDLE_SET (ret, il, il_arr);
1276 uint32_t il_gchandle;
1277 guint8* il_data = MONO_ARRAY_HANDLE_PIN (il_arr, guint8, 0, &il_gchandle);
1278 memcpy (il_data, header->code, header->code_size);
1279 mono_gchandle_free (il_gchandle);
1282 MonoArrayHandle locals_arr = mono_array_new_handle (domain, mono_class_get_local_variable_info_class (), header->num_locals, error);
1285 MONO_HANDLE_SET (ret, locals, locals_arr);
1286 for (i = 0; i < header->num_locals; ++i) {
1287 if (!add_local_var_info_to_array (domain, header, i, locals_arr, error))
1292 MonoArrayHandle exn_clauses = mono_array_new_handle (domain, mono_class_get_exception_handling_clause_class (), header->num_clauses, error);
1295 MONO_HANDLE_SET (ret, clauses, exn_clauses);
1296 for (i = 0; i < header->num_clauses; ++i) {
1297 if (!add_exception_handling_clause_to_array (domain, header, i, exn_clauses, error))
1301 mono_metadata_free_mh (header);
1305 mono_metadata_free_mh (header);
1310 * mono_method_body_get_object_handle:
1311 * \param domain an app domain
1312 * \param method a method
1313 * \param error set on error
1314 * \returns a \c System.Reflection.MethodBody object representing the
1315 * method \p method. On failure, returns NULL and sets \p error.
1317 MonoReflectionMethodBodyHandle
1318 mono_method_body_get_object_handle (MonoDomain *domain, MonoMethod *method, MonoError *error)
1321 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionMethodBodyHandle, method, NULL, method_body_object_construct, NULL);
1326 * mono_get_dbnull_object:
1327 * \param domain Domain where the object lives
1328 * Used as the value for \c ParameterInfo.DefaultValue
1329 * \returns the \c System.DBNull.Value singleton object
1332 mono_get_dbnull_object (MonoDomain *domain)
1334 HANDLE_FUNCTION_ENTER ();
1336 MonoObjectHandle obj = get_dbnull_object (domain, &error);
1337 mono_error_assert_ok (&error);
1338 HANDLE_FUNCTION_RETURN_OBJ (obj);
1342 get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types)
1344 guint32 param_index, i, lastp, crow = 0;
1345 guint32 param_cols [MONO_PARAM_SIZE], const_cols [MONO_CONSTANT_SIZE];
1348 MonoClass *klass = method->klass;
1349 MonoImage *image = klass->image;
1350 MonoMethodSignature *methodsig = mono_method_signature (method);
1352 MonoTableInfo *constt;
1353 MonoTableInfo *methodt;
1354 MonoTableInfo *paramt;
1356 if (!methodsig->param_count)
1359 mono_class_init (klass);
1361 if (image_is_dynamic (klass->image)) {
1362 MonoReflectionMethodAux *aux;
1363 if (method->is_inflated)
1364 method = ((MonoMethodInflated*)method)->declaring;
1365 aux = (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
1366 if (aux && aux->param_defaults) {
1367 memcpy (blobs, &(aux->param_defaults [1]), methodsig->param_count * sizeof (char*));
1368 memcpy (types, &(aux->param_default_types [1]), methodsig->param_count * sizeof (guint32));
1373 methodt = &klass->image->tables [MONO_TABLE_METHOD];
1374 paramt = &klass->image->tables [MONO_TABLE_PARAM];
1375 constt = &image->tables [MONO_TABLE_CONSTANT];
1377 idx = mono_method_get_index (method) - 1;
1378 g_assert (idx != -1);
1380 param_index = mono_metadata_decode_row_col (methodt, idx, MONO_METHOD_PARAMLIST);
1381 if (idx + 1 < methodt->rows)
1382 lastp = mono_metadata_decode_row_col (methodt, idx + 1, MONO_METHOD_PARAMLIST);
1384 lastp = paramt->rows + 1;
1386 for (i = param_index; i < lastp; ++i) {
1389 mono_metadata_decode_row (paramt, i - 1, param_cols, MONO_PARAM_SIZE);
1390 paramseq = param_cols [MONO_PARAM_SEQUENCE];
1392 if (!(param_cols [MONO_PARAM_FLAGS] & PARAM_ATTRIBUTE_HAS_DEFAULT))
1395 crow = mono_metadata_get_constant_index (image, MONO_TOKEN_PARAM_DEF | i, crow + 1);
1400 mono_metadata_decode_row (constt, crow - 1, const_cols, MONO_CONSTANT_SIZE);
1401 blobs [paramseq - 1] = (char *)mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
1402 types [paramseq - 1] = const_cols [MONO_CONSTANT_TYPE];
1409 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob, MonoError *error)
1414 MonoType *basetype = type;
1421 klass = mono_class_from_mono_type (type);
1422 if (klass->valuetype) {
1423 object = mono_object_new_checked (domain, klass, error);
1424 return_val_if_nok (error, NULL);
1425 retval = ((gchar *) object + sizeof (MonoObject));
1426 if (klass->enumtype)
1427 basetype = mono_class_enum_basetype (klass);
1432 if (!mono_get_constant_value_from_blob (domain, basetype->type, blob, retval, error))
1439 assembly_name_to_aname (MonoAssemblyName *assembly, char *p) {
1442 gboolean quoted = FALSE;
1444 memset (assembly, 0, sizeof (MonoAssemblyName));
1445 assembly->culture = "";
1446 memset (assembly->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
1453 while (*p && (isalnum (*p) || *p == '.' || *p == '-' || *p == '_' || *p == '$' || *p == '@' || g_ascii_isspace (*p)))
1464 /* Remove trailing whitespace */
1466 while (*s && g_ascii_isspace (*s))
1469 while (g_ascii_isspace (*p))
1472 if (*p == 'V' && g_ascii_strncasecmp (p, "Version=", 8) == 0) {
1474 assembly->major = strtoul (p, &s, 10);
1475 if (s == p || *s != '.')
1478 assembly->minor = strtoul (p, &s, 10);
1479 if (s == p || *s != '.')
1482 assembly->build = strtoul (p, &s, 10);
1483 if (s == p || *s != '.')
1486 assembly->revision = strtoul (p, &s, 10);
1490 } else if (*p == 'C' && g_ascii_strncasecmp (p, "Culture=", 8) == 0) {
1492 if (g_ascii_strncasecmp (p, "neutral", 7) == 0) {
1493 assembly->culture = "";
1496 assembly->culture = p;
1497 while (*p && *p != ',') {
1501 } else if (*p == 'P' && g_ascii_strncasecmp (p, "PublicKeyToken=", 15) == 0) {
1503 if (strncmp (p, "null", 4) == 0) {
1508 while (*p && *p != ',') {
1511 len = (p - start + 1);
1512 if (len > MONO_PUBLIC_KEY_TOKEN_LENGTH)
1513 len = MONO_PUBLIC_KEY_TOKEN_LENGTH;
1514 g_strlcpy ((char*)assembly->public_key_token, start, len);
1517 while (*p && *p != ',')
1521 while (g_ascii_isspace (*p) || *p == ',') {
1535 * mono_reflection_parse_type:
1538 * Parse a type name as accepted by the GetType () method and output the info
1539 * extracted in the info structure.
1540 * the name param will be mangled, so, make a copy before passing it to this function.
1541 * The fields in info will be valid until the memory pointed to by name is valid.
1543 * See also mono_type_get_name () below.
1545 * Returns: 0 on parse error.
1548 _mono_reflection_parse_type (char *name, char **endptr, gboolean is_recursed,
1549 MonoTypeNameParse *info)
1551 char *start, *p, *w, *last_point, *startn;
1552 int in_modifiers = 0;
1553 int isbyref = 0, rank = 0, isptr = 0;
1555 start = p = w = name;
1557 //FIXME could we just zero the whole struct? memset (&info, 0, sizeof (MonoTypeNameParse))
1558 memset (&info->assembly, 0, sizeof (MonoAssemblyName));
1559 info->name = info->name_space = NULL;
1560 info->nested = NULL;
1561 info->modifiers = NULL;
1562 info->type_arguments = NULL;
1564 /* last_point separates the namespace from the name */
1567 while (*p == ' ') p++, start++, w++, name++;
1572 *p = 0; /* NULL terminate the name */
1574 info->nested = g_list_append (info->nested, startn);
1575 /* we have parsed the nesting namespace + name */
1579 info->name_space = start;
1581 info->name = last_point + 1;
1583 info->name_space = (char *)"";
1611 info->name_space = start;
1613 info->name = last_point + 1;
1615 info->name_space = (char *)"";
1622 if (isbyref) /* only one level allowed by the spec */
1626 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (0));
1630 if (isbyref) /* pointer to ref not okay */
1632 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-1));
1637 if (isbyref) /* array of ref and generic ref are not okay */
1639 //Decide if it's an array of a generic argument list
1644 if (*p == ',' || *p == '*' || *p == ']') { //array
1652 else if (*p == '*') /* '*' means unknown lower bound */
1653 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-2));
1660 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (rank));
1662 if (rank || isptr) /* generic args after array spec or ptr*/ //XXX test
1665 info->type_arguments = g_ptr_array_new ();
1667 MonoTypeNameParse *subinfo = g_new0 (MonoTypeNameParse, 1);
1668 gboolean fqname = FALSE;
1670 g_ptr_array_add (info->type_arguments, subinfo);
1672 while (*p == ' ') p++;
1678 if (!_mono_reflection_parse_type (p, &p, TRUE, subinfo))
1681 /*MS is lenient on [] delimited parameters that aren't fqn - and F# uses them.*/
1682 if (fqname && (*p != ']')) {
1690 while (*p && (*p != ']'))
1698 if (g_ascii_isspace (*aname)) {
1705 !assembly_name_to_aname (&subinfo->assembly, aname))
1707 } else if (fqname && (*p == ']')) {
1729 if (g_ascii_isspace (*p)) {
1736 return 0; /* missing assembly name */
1737 if (!assembly_name_to_aname (&info->assembly, p))
1743 if (info->assembly.name)
1746 // *w = 0; /* terminate class name */
1748 if (!info->name || !*info->name)
1752 /* add other consistency checks */
1758 * mono_identifier_unescape_type_name_chars:
1759 * \param identifier the display name of a mono type
1761 * \returns The name in internal form, that is without escaping backslashes.
1763 * The string is modified in place!
1766 mono_identifier_unescape_type_name_chars(char* identifier)
1771 for (w = r = identifier; *r != 0; r++)
1789 mono_identifier_unescape_info (MonoTypeNameParse* info);
1792 unescape_each_type_argument(void* data, void* user_data)
1794 MonoTypeNameParse* info = (MonoTypeNameParse*)data;
1795 mono_identifier_unescape_info (info);
1799 unescape_each_nested_name (void* data, void* user_data)
1801 char* nested_name = (char*) data;
1802 mono_identifier_unescape_type_name_chars(nested_name);
1806 * mono_identifier_unescape_info:
1808 * \param info a parsed display form of an (optionally assembly qualified) full type name.
1810 * Destructively updates the info by unescaping the identifiers that
1811 * comprise the type namespace, name, nested types (if any) and
1812 * generic type arguments (if any).
1814 * The resulting info has the names in internal form.
1818 mono_identifier_unescape_info (MonoTypeNameParse *info)
1822 mono_identifier_unescape_type_name_chars(info->name_space);
1823 mono_identifier_unescape_type_name_chars(info->name);
1824 // but don't escape info->assembly
1825 if (info->type_arguments)
1826 g_ptr_array_foreach(info->type_arguments, &unescape_each_type_argument, NULL);
1828 g_list_foreach(info->nested, &unescape_each_nested_name, NULL);
1832 * mono_reflection_parse_type:
1835 mono_reflection_parse_type (char *name, MonoTypeNameParse *info)
1837 int ok = _mono_reflection_parse_type (name, NULL, FALSE, info);
1839 mono_identifier_unescape_info (info);
1845 _mono_reflection_get_type_from_info (MonoTypeNameParse *info, MonoImage *image, gboolean ignorecase, MonoError *error)
1847 gboolean type_resolve = FALSE;
1849 MonoImage *rootimage = image;
1853 if (info->assembly.name) {
1854 MonoAssembly *assembly = mono_assembly_loaded (&info->assembly);
1855 if (!assembly && image && image->assembly && mono_assembly_names_equal (&info->assembly, &image->assembly->aname))
1857 * This could happen in the AOT compiler case when the search hook is not
1860 assembly = image->assembly;
1862 /* then we must load the assembly ourselve - see #60439 */
1863 assembly = mono_assembly_load (&info->assembly, image->assembly->basedir, NULL);
1867 image = assembly->image;
1868 } else if (!image) {
1869 image = mono_defaults.corlib;
1872 type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
1873 if (type == NULL && !info->assembly.name && image != mono_defaults.corlib) {
1874 /* ignore the error and try again */
1875 mono_error_cleanup (error);
1877 image = mono_defaults.corlib;
1878 type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
1885 * mono_reflection_get_type_internal:
1887 * Returns: may return NULL on success, sets error on failure.
1890 mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
1892 HANDLE_FUNCTION_ENTER ();
1896 gboolean bounded = FALSE;
1897 MonoType* type = NULL;
1901 image = mono_defaults.corlib;
1904 rootimage = mono_defaults.corlib;
1907 klass = mono_class_from_name_case_checked (image, info->name_space, info->name, error);
1909 klass = mono_class_from_name_checked (image, info->name_space, info->name, error);
1914 for (mod = info->nested; mod; mod = mod->next) {
1915 gpointer iter = NULL;
1919 mono_class_init (parent);
1921 while ((klass = mono_class_get_nested_types (parent, &iter))) {
1923 char *nested_name, *nested_nspace;
1924 gboolean match = TRUE;
1926 lastp = strrchr ((const char *)mod->data, '.');
1928 /* Nested classes can have namespaces */
1931 nested_name = g_strdup (lastp + 1);
1932 nspace_len = lastp - (char*)mod->data;
1933 nested_nspace = (char *)g_malloc (nspace_len + 1);
1934 memcpy (nested_nspace, mod->data, nspace_len);
1935 nested_nspace [nspace_len] = '\0';
1938 nested_name = (char *)mod->data;
1939 nested_nspace = NULL;
1942 if (nested_nspace) {
1944 if (!(klass->name_space && mono_utf8_strcasecmp (klass->name_space, nested_nspace) == 0))
1947 if (!(klass->name_space && strcmp (klass->name_space, nested_nspace) == 0))
1953 if (mono_utf8_strcasecmp (klass->name, nested_name) != 0)
1956 if (strcmp (klass->name, nested_name) != 0)
1961 g_free (nested_name);
1962 g_free (nested_nspace);
1974 if (info->type_arguments) {
1975 MonoType **type_args = g_new0 (MonoType *, info->type_arguments->len);
1976 MonoReflectionTypeHandle the_type;
1980 for (i = 0; i < info->type_arguments->len; i++) {
1981 MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
1983 type_args [i] = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase, error);
1984 if (!type_args [i]) {
1990 the_type = mono_type_get_object_handle (mono_domain_get (), &klass->byval_arg, error);
1991 if (!is_ok (error) || MONO_HANDLE_IS_NULL (the_type))
1994 instance = mono_reflection_bind_generic_parameters (
1995 the_type, info->type_arguments->len, type_args, error);
2001 klass = mono_class_from_mono_type (instance);
2004 for (mod = info->modifiers; mod; mod = mod->next) {
2005 modval = GPOINTER_TO_UINT (mod->data);
2006 if (!modval) { /* byref: must be last modifier */
2007 type = &klass->this_arg;
2009 } else if (modval == -1) {
2010 klass = mono_ptr_class_get (&klass->byval_arg);
2011 } else if (modval == -2) {
2013 } else { /* array rank */
2014 klass = mono_bounded_array_class_get (klass, modval, bounded);
2018 type = &klass->byval_arg;
2021 HANDLE_FUNCTION_RETURN_VAL (type);
2025 * mono_reflection_get_type:
2026 * \param image a metadata context
2027 * \param info type description structure
2028 * \param ignorecase flag for case-insensitive string compares
2029 * \param type_resolve whenever type resolve was already tried
2031 * Build a MonoType from the type description in \p info.
2035 mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve) {
2037 MonoType *result = mono_reflection_get_type_with_rootimage (image, image, info, ignorecase, type_resolve, &error);
2038 mono_error_cleanup (&error);
2043 * mono_reflection_get_type_checked:
2044 * \param rootimage the image of the currently active managed caller
2045 * \param image a metadata context
2046 * \param info type description structure
2047 * \param ignorecase flag for case-insensitive string compares
2048 * \param type_resolve whenever type resolve was already tried
2049 * \param error set on error.
2050 * Build a \c MonoType from the type description in \p info. On failure returns NULL and sets \p error.
2053 mono_reflection_get_type_checked (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error) {
2055 return mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, type_resolve, error);
2060 module_builder_array_get_type (MonoArrayHandle module_builders, int i, MonoImage *rootimage, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
2062 HANDLE_FUNCTION_ENTER ();
2064 MonoType *type = NULL;
2065 MonoReflectionModuleBuilderHandle mb = MONO_HANDLE_NEW (MonoReflectionModuleBuilder, NULL);
2066 MONO_HANDLE_ARRAY_GETREF (mb, module_builders, i);
2067 MonoDynamicImage *dynamic_image = MONO_HANDLE_GETVAL (mb, dynamic_image);
2068 type = mono_reflection_get_type_internal (rootimage, &dynamic_image->image, info, ignorecase, error);
2069 HANDLE_FUNCTION_RETURN_VAL (type);
2073 module_array_get_type (MonoArrayHandle modules, int i, MonoImage *rootimage, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
2075 HANDLE_FUNCTION_ENTER ();
2077 MonoType *type = NULL;
2078 MonoReflectionModuleHandle mod = MONO_HANDLE_NEW (MonoReflectionModule, NULL);
2079 MONO_HANDLE_ARRAY_GETREF (mod, modules, i);
2080 MonoImage *image = MONO_HANDLE_GETVAL (mod, image);
2081 type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase, error);
2082 HANDLE_FUNCTION_RETURN_VAL (type);
2086 mono_reflection_get_type_internal_dynamic (MonoImage *rootimage, MonoAssembly *assembly, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
2088 HANDLE_FUNCTION_ENTER ();
2089 MonoType *type = NULL;
2093 g_assert (assembly_is_dynamic (assembly));
2094 MonoReflectionAssemblyBuilderHandle abuilder = MONO_HANDLE_CAST (MonoReflectionAssemblyBuilder, mono_assembly_get_object_handle (((MonoDynamicAssembly*)assembly)->domain, assembly, error));
2098 /* Enumerate all modules */
2100 MonoArrayHandle modules = MONO_HANDLE_NEW (MonoArray, NULL);
2101 MONO_HANDLE_GET (modules, abuilder, modules);
2102 if (!MONO_HANDLE_IS_NULL (modules)) {
2103 int n = mono_array_handle_length (modules);
2104 for (i = 0; i < n; ++i) {
2105 type = module_builder_array_get_type (modules, i, rootimage, info, ignorecase, error);
2113 MonoArrayHandle loaded_modules = MONO_HANDLE_NEW (MonoArray, NULL);
2114 MONO_HANDLE_GET (loaded_modules, abuilder, loaded_modules);
2115 if (!type && !MONO_HANDLE_IS_NULL(loaded_modules)) {
2116 int n = mono_array_handle_length (loaded_modules);
2117 for (i = 0; i < n; ++i) {
2118 type = module_array_get_type (loaded_modules, i, rootimage, info, ignorecase, error);
2127 HANDLE_FUNCTION_RETURN_VAL (type);
2131 mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error)
2134 MonoReflectionAssembly *assembly;
2140 if (image && image_is_dynamic (image))
2141 type = mono_reflection_get_type_internal_dynamic (rootimage, image->assembly, info, ignorecase, error);
2143 type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase, error);
2145 return_val_if_nok (error, NULL);
2149 if (!mono_domain_has_type_resolve (mono_domain_get ()))
2156 *type_resolve = TRUE;
2159 /* Reconstruct the type name */
2160 fullName = g_string_new ("");
2161 if (info->name_space && (info->name_space [0] != '\0'))
2162 g_string_printf (fullName, "%s.%s", info->name_space, info->name);
2164 g_string_printf (fullName, "%s", info->name);
2165 for (mod = info->nested; mod; mod = mod->next)
2166 g_string_append_printf (fullName, "+%s", (char*)mod->data);
2168 assembly = mono_domain_try_type_resolve_checked ( mono_domain_get (), fullName->str, NULL, error);
2169 if (!is_ok (error)) {
2170 g_string_free (fullName, TRUE);
2175 if (assembly_is_dynamic (assembly->assembly))
2176 type = mono_reflection_get_type_internal_dynamic (rootimage, assembly->assembly,
2177 info, ignorecase, error);
2179 type = mono_reflection_get_type_internal (rootimage, assembly->assembly->image,
2180 info, ignorecase, error);
2182 g_string_free (fullName, TRUE);
2183 return_val_if_nok (error, NULL);
2188 * mono_reflection_free_type_info:
2191 mono_reflection_free_type_info (MonoTypeNameParse *info)
2193 g_list_free (info->modifiers);
2194 g_list_free (info->nested);
2196 if (info->type_arguments) {
2199 for (i = 0; i < info->type_arguments->len; i++) {
2200 MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
2202 mono_reflection_free_type_info (subinfo);
2203 /*We free the subinfo since it is allocated by _mono_reflection_parse_type*/
2207 g_ptr_array_free (info->type_arguments, TRUE);
2212 * mono_reflection_type_from_name:
2213 * \param name type name.
2214 * \param image a metadata context (can be NULL).
2216 * Retrieves a \c MonoType from its \p name. If the name is not fully qualified,
2217 * it defaults to get the type from \p image or, if \p image is NULL or loading
2218 * from it fails, uses corlib.
2222 mono_reflection_type_from_name (char *name, MonoImage *image)
2225 MonoType *result = mono_reflection_type_from_name_checked (name, image, &error);
2226 mono_error_cleanup (&error);
2231 * mono_reflection_type_from_name_checked:
2232 * \param name type name.
2233 * \param image a metadata context (can be NULL).
2234 * \param error set on errror.
2235 * Retrieves a MonoType from its \p name. If the name is not fully qualified,
2236 * it defaults to get the type from \p image or, if \p image is NULL or loading
2237 * from it fails, uses corlib. On failure returns NULL and sets \p error.
2240 mono_reflection_type_from_name_checked (char *name, MonoImage *image, MonoError *error)
2242 MonoType *type = NULL;
2243 MonoTypeNameParse info;
2247 /* Make a copy since parse_type modifies its argument */
2248 tmp = g_strdup (name);
2250 /*g_print ("requested type %s\n", str);*/
2251 if (mono_reflection_parse_type (tmp, &info)) {
2252 type = _mono_reflection_get_type_from_info (&info, image, FALSE, error);
2253 if (!is_ok (error)) {
2255 mono_reflection_free_type_info (&info);
2261 mono_reflection_free_type_info (&info);
2266 * mono_reflection_get_token:
2267 * \returns the metadata token of \p obj which should be an object
2268 * representing a metadata element.
2271 mono_reflection_get_token (MonoObject *obj_raw)
2273 HANDLE_FUNCTION_ENTER ();
2274 MONO_HANDLE_DCL (MonoObject, obj);
2276 guint32 result = mono_reflection_get_token_checked (obj, &error);
2277 mono_error_assert_ok (&error);
2278 HANDLE_FUNCTION_RETURN_VAL (result);
2282 * mono_reflection_get_token_checked:
2283 * \param obj the object
2284 * \param error set on error
2285 * \returns the metadata token of \p obj which should be an object
2286 * representing a metadata element. On failure sets \p error.
2289 mono_reflection_get_token_checked (MonoObjectHandle obj, MonoError *error)
2295 MonoClass *klass = mono_handle_class (obj);
2297 if (strcmp (klass->name, "MethodBuilder") == 0) {
2298 MonoReflectionMethodBuilderHandle mb = MONO_HANDLE_CAST (MonoReflectionMethodBuilder, obj);
2300 token = MONO_HANDLE_GETVAL (mb, table_idx) | MONO_TOKEN_METHOD_DEF;
2301 } else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
2302 MonoReflectionCtorBuilderHandle mb = MONO_HANDLE_CAST (MonoReflectionCtorBuilder, obj);
2304 token = MONO_HANDLE_GETVAL (mb, table_idx) | MONO_TOKEN_METHOD_DEF;
2305 } else if (strcmp (klass->name, "FieldBuilder") == 0) {
2306 MonoReflectionFieldBuilderHandle fb = MONO_HANDLE_CAST (MonoReflectionFieldBuilder, obj);
2308 token = MONO_HANDLE_GETVAL (fb, table_idx) | MONO_TOKEN_FIELD_DEF;
2309 } else if (strcmp (klass->name, "TypeBuilder") == 0) {
2310 MonoReflectionTypeBuilderHandle tb = MONO_HANDLE_CAST (MonoReflectionTypeBuilder, obj);
2311 token = MONO_HANDLE_GETVAL (tb, table_idx) | MONO_TOKEN_TYPE_DEF;
2312 } else if (strcmp (klass->name, "RuntimeType") == 0) {
2313 MonoType *type = mono_reflection_type_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionType, obj), error);
2314 return_val_if_nok (error, 0);
2315 MonoClass *mc = mono_class_from_mono_type (type);
2316 if (!mono_class_init (mc)) {
2317 mono_error_set_for_class_failure (error, mc);
2321 token = mc->type_token;
2322 } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
2323 strcmp (klass->name, "MonoMethod") == 0) {
2324 MonoReflectionMethodHandle m = MONO_HANDLE_CAST (MonoReflectionMethod, obj);
2325 MonoMethod *method = MONO_HANDLE_GETVAL (m, method);
2326 if (method->is_inflated) {
2327 MonoMethodInflated *inflated = (MonoMethodInflated *) method;
2328 return inflated->declaring->token;
2330 token = method->token;
2332 } else if (strcmp (klass->name, "MonoField") == 0) {
2333 MonoReflectionFieldHandle f = MONO_HANDLE_CAST (MonoReflectionField, obj);
2335 token = mono_class_get_field_token (MONO_HANDLE_GETVAL (f, field));
2336 } else if (strcmp (klass->name, "MonoProperty") == 0) {
2337 MonoReflectionPropertyHandle p = MONO_HANDLE_CAST (MonoReflectionProperty, obj);
2339 token = mono_class_get_property_token (MONO_HANDLE_GETVAL (p, property));
2340 } else if (strcmp (klass->name, "MonoEvent") == 0) {
2341 MonoReflectionMonoEventHandle p = MONO_HANDLE_CAST (MonoReflectionMonoEvent, obj);
2343 token = mono_class_get_event_token (MONO_HANDLE_GETVAL (p, event));
2344 } else if (strcmp (klass->name, "ParameterInfo") == 0 || strcmp (klass->name, "MonoParameterInfo") == 0) {
2345 MonoReflectionParameterHandle p = MONO_HANDLE_CAST (MonoReflectionParameter, obj);
2346 MonoObjectHandle member_impl = MONO_HANDLE_NEW (MonoObject, NULL);
2347 MONO_HANDLE_GET (member_impl, p, MemberImpl);
2348 MonoClass *member_class = mono_handle_class (member_impl);
2349 g_assert (mono_class_is_reflection_method_or_constructor (member_class));
2350 MonoMethod *method = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionMethod, member_impl), method);
2352 token = mono_method_get_param_token (method, MONO_HANDLE_GETVAL (p, PositionImpl));
2353 } else if (strcmp (klass->name, "Module") == 0 || strcmp (klass->name, "MonoModule") == 0) {
2354 MonoReflectionModuleHandle m = MONO_HANDLE_CAST (MonoReflectionModule, obj);
2356 token = MONO_HANDLE_GETVAL (m, token);
2357 } else if (strcmp (klass->name, "Assembly") == 0 || strcmp (klass->name, "MonoAssembly") == 0) {
2358 token = mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1);
2360 mono_error_set_not_implemented (error, "MetadataToken is not supported for type '%s.%s'",
2361 klass->name_space, klass->name);
2370 mono_reflection_is_usertype (MonoReflectionTypeHandle ref)
2372 MonoClass *klass = mono_handle_class (ref);
2373 return klass->image != mono_defaults.corlib || strcmp ("TypeDelegator", klass->name) == 0;
2377 * mono_reflection_bind_generic_parameters:
2378 * \param type a managed type object (which should be some kind of generic (instance? definition?))
2379 * \param type_args the number of type arguments to bind
2380 * \param types array of type arguments
2381 * \param error set on error
2382 * Given a managed type object for a generic type instance, binds each of its arguments to the specified types.
2383 * \returns the \c MonoType* for the resulting type instantiation. On failure returns NULL and sets \p error.
2386 mono_reflection_bind_generic_parameters (MonoReflectionTypeHandle reftype, int type_argc, MonoType **types, MonoError *error)
2388 gboolean is_dynamic = FALSE;
2393 mono_loader_lock ();
2395 MonoClass *klass = mono_handle_class (reftype);
2396 if (mono_is_sre_type_builder (klass)) {
2398 } else if (mono_is_sre_generic_instance (klass)) {
2399 /* Does this ever make sense? what does instantiating a generic instance even mean? */
2400 g_assert_not_reached ();
2401 MonoReflectionGenericClassHandle rgi = MONO_HANDLE_CAST (MonoReflectionGenericClass, reftype);
2402 MonoReflectionTypeHandle gtd = MONO_HANDLE_NEW_GET (MonoReflectionType, rgi, generic_type);
2404 if (mono_is_sre_type_builder (mono_handle_class (gtd)))
2408 MonoType *t = mono_reflection_type_handle_mono_type (reftype, error);
2409 if (!is_ok (error)) {
2410 mono_loader_unlock ();
2414 klass = mono_class_from_mono_type (t);
2415 if (!mono_class_is_gtd (klass)) {
2416 mono_loader_unlock ();
2417 mono_error_set_type_load_class (error, klass, "Cannot bind generic parameters of a non-generic type");
2421 guint gtd_type_argc = mono_class_get_generic_container (klass)->type_argc;
2422 if (gtd_type_argc != type_argc) {
2423 mono_loader_unlock ();
2424 mono_error_set_argument (error, "types", "The generic type definition needs %d type arguments, but was instantiated with %d ", gtd_type_argc, type_argc);
2429 if (klass->wastypebuilder)
2432 mono_loader_unlock ();
2434 geninst = mono_class_bind_generic_parameters (klass, type_argc, types, is_dynamic);
2436 return &geninst->byval_arg;
2440 mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic)
2442 MonoGenericClass *gclass;
2443 MonoGenericInst *inst;
2445 g_assert (mono_class_is_gtd (klass));
2447 inst = mono_metadata_get_generic_inst (type_argc, types);
2448 gclass = mono_metadata_lookup_generic_class (klass, inst, is_dynamic);
2450 return mono_generic_class_get_class (gclass);
2453 static MonoGenericInst*
2454 generic_inst_from_type_array_handle (MonoArrayHandle types, MonoError *error)
2456 HANDLE_FUNCTION_ENTER ();
2458 MonoGenericInst *ginst = NULL;
2459 int count = mono_array_handle_length (types);
2460 MonoType **type_argv = g_new0 (MonoType *, count);
2461 MonoReflectionTypeHandle garg = MONO_HANDLE_NEW (MonoReflectionType, NULL);
2462 for (int i = 0; i < count; i++) {
2463 MONO_HANDLE_ARRAY_GETREF (garg, types, i);
2464 type_argv [i] = mono_reflection_type_handle_mono_type (garg, error);
2469 ginst = mono_metadata_get_generic_inst (count, type_argv);
2472 HANDLE_FUNCTION_RETURN_VAL (ginst);
2476 reflection_bind_generic_method_parameters (MonoMethod *method, MonoArrayHandle types, MonoError *error)
2479 MonoMethod *inflated;
2480 MonoGenericContext tmp_context;
2484 klass = method->klass;
2486 if (method->is_inflated)
2487 method = ((MonoMethodInflated *) method)->declaring;
2489 int count = mono_method_signature (method)->generic_param_count;
2490 if (count != mono_array_handle_length (types)) {
2491 mono_error_set_argument (error, "typeArguments", "Incorrect number of generic arguments");
2495 MonoGenericInst *ginst = generic_inst_from_type_array_handle (types, error);
2496 return_val_if_nok (error, NULL);
2498 tmp_context.class_inst = mono_class_is_ginst (klass) ? mono_class_get_generic_class (klass)->context.class_inst : NULL;
2499 tmp_context.method_inst = ginst;
2501 inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, error);
2502 mono_error_assert_ok (error);
2504 if (!mono_verifier_is_method_valid_generic_instantiation (inflated)) {
2505 mono_error_set_argument (error, "typeArguments", "Invalid generic arguments");
2512 MonoReflectionMethodHandle
2513 ves_icall_MonoMethod_MakeGenericMethod_impl (MonoReflectionMethodHandle rmethod, MonoArrayHandle types, MonoError *error)
2516 g_assert (0 != strcmp (mono_handle_class (rmethod)->name, "MethodBuilder"));
2518 MonoMethod *method = MONO_HANDLE_GETVAL (rmethod, method);
2519 MonoMethod *imethod = reflection_bind_generic_method_parameters (method, types, error);
2520 return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionMethod, NULL_HANDLE));
2522 /*FIXME but I think this is no longer necessary*/
2523 if (image_is_dynamic (method->klass->image)) {
2524 MonoDynamicImage *image = (MonoDynamicImage*)method->klass->image;
2526 * This table maps metadata structures representing inflated methods/fields
2527 * to the reflection objects representing their generic definitions.
2529 mono_image_lock ((MonoImage*)image);
2530 mono_g_hash_table_insert (image->generic_def_objects, imethod, MONO_HANDLE_RAW (rmethod));
2531 mono_image_unlock ((MonoImage*)image);
2534 return mono_method_get_object_handle (MONO_HANDLE_DOMAIN (rmethod), imethod, NULL, error);
2538 /* SECURITY_ACTION_* are defined in mono/metadata/tabledefs.h */
2539 const static guint32 declsec_flags_map[] = {
2540 0x00000000, /* empty */
2541 MONO_DECLSEC_FLAG_REQUEST, /* SECURITY_ACTION_REQUEST (x01) */
2542 MONO_DECLSEC_FLAG_DEMAND, /* SECURITY_ACTION_DEMAND (x02) */
2543 MONO_DECLSEC_FLAG_ASSERT, /* SECURITY_ACTION_ASSERT (x03) */
2544 MONO_DECLSEC_FLAG_DENY, /* SECURITY_ACTION_DENY (x04) */
2545 MONO_DECLSEC_FLAG_PERMITONLY, /* SECURITY_ACTION_PERMITONLY (x05) */
2546 MONO_DECLSEC_FLAG_LINKDEMAND, /* SECURITY_ACTION_LINKDEMAND (x06) */
2547 MONO_DECLSEC_FLAG_INHERITANCEDEMAND, /* SECURITY_ACTION_INHERITANCEDEMAND (x07) */
2548 MONO_DECLSEC_FLAG_REQUEST_MINIMUM, /* SECURITY_ACTION_REQUEST_MINIMUM (x08) */
2549 MONO_DECLSEC_FLAG_REQUEST_OPTIONAL, /* SECURITY_ACTION_REQUEST_OPTIONAL (x09) */
2550 MONO_DECLSEC_FLAG_REQUEST_REFUSE, /* SECURITY_ACTION_REQUEST_REFUSE (x0A) */
2551 MONO_DECLSEC_FLAG_PREJIT_GRANT, /* SECURITY_ACTION_PREJIT_GRANT (x0B) */
2552 MONO_DECLSEC_FLAG_PREJIT_DENY, /* SECURITY_ACTION_PREJIT_DENY (x0C) */
2553 MONO_DECLSEC_FLAG_NONCAS_DEMAND, /* SECURITY_ACTION_NONCAS_DEMAND (x0D) */
2554 MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND, /* SECURITY_ACTION_NONCAS_LINKDEMAND (x0E) */
2555 MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND, /* SECURITY_ACTION_NONCAS_INHERITANCEDEMAND (x0F) */
2556 MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE, /* SECURITY_ACTION_LINKDEMAND_CHOICE (x10) */
2557 MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE, /* SECURITY_ACTION_INHERITANCEDEMAND_CHOICE (x11) */
2558 MONO_DECLSEC_FLAG_DEMAND_CHOICE, /* SECURITY_ACTION_DEMAND_CHOICE (x12) */
2562 * Returns flags that includes all available security action associated to the handle.
2563 * @token: metadata token (either for a class or a method)
2564 * @image: image where resides the metadata.
2567 mono_declsec_get_flags (MonoImage *image, guint32 token)
2569 int index = mono_metadata_declsec_from_index (image, token);
2570 MonoTableInfo *t = &image->tables [MONO_TABLE_DECLSECURITY];
2575 /* HasSecurity can be present for other, not specially encoded, attributes,
2576 e.g. SuppressUnmanagedCodeSecurityAttribute */
2580 for (i = index; i < t->rows; i++) {
2581 guint32 cols [MONO_DECL_SECURITY_SIZE];
2583 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
2584 if (cols [MONO_DECL_SECURITY_PARENT] != token)
2587 action = cols [MONO_DECL_SECURITY_ACTION];
2588 if ((action >= MONO_DECLSEC_ACTION_MIN) && (action <= MONO_DECLSEC_ACTION_MAX)) {
2589 result |= declsec_flags_map [action];
2591 g_assert_not_reached ();
2598 * mono_declsec_flags_from_method:
2599 * \param method The method for which we want the declarative security flags.
2600 * Get the security actions (in the form of flags) associated with the specified method.
2601 * To keep \c MonoMethod size down we do not cache the declarative security flags
2602 * (except for the stack modifiers which are kept in the MonoJitInfo structure)
2603 * \returns the declarative security flags for the method (only).
2606 mono_declsec_flags_from_method (MonoMethod *method)
2608 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2609 /* FIXME: No cache (for the moment) */
2610 guint32 idx = mono_method_get_index (method);
2611 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2612 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
2613 return mono_declsec_get_flags (method->klass->image, idx);
2619 * mono_declsec_flags_from_class:
2620 * \param klass The class for which we want the declarative security flags.
2621 * Get the security actions (in the form of flags) associated with the specified class.
2622 * We cache the flags inside the \c MonoClass structure as this will get
2623 * called very often (at least for each method).
2624 * \returns the declarative security flags for the class.
2627 mono_declsec_flags_from_class (MonoClass *klass)
2629 if (mono_class_get_flags (klass) & TYPE_ATTRIBUTE_HAS_SECURITY) {
2630 guint32 flags = mono_class_get_declsec_flags (klass);
2635 idx = mono_metadata_token_index (klass->type_token);
2636 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2637 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
2638 flags = mono_declsec_get_flags (klass->image, idx);
2639 /* we cache the flags on classes */
2640 mono_class_set_declsec_flags (klass, flags);
2648 * mono_declsec_flags_from_assembly:
2649 * \param assembly The assembly for which we want the declarative security flags.
2650 * Get the security actions (in the form of flags) associated with the specified assembly.
2651 * \returns the declarative security flags for the assembly.
2654 mono_declsec_flags_from_assembly (MonoAssembly *assembly)
2656 guint32 idx = 1; /* there is only one assembly */
2657 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2658 idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
2659 return mono_declsec_get_flags (assembly->image, idx);
2664 * Fill actions for the specific index (which may either be an encoded class token or
2665 * an encoded method token) from the metadata image.
2666 * Returns TRUE if some actions requiring code generation are present, FALSE otherwise.
2669 fill_actions_from_index (MonoImage *image, guint32 token, MonoDeclSecurityActions* actions,
2670 guint32 id_std, guint32 id_noncas, guint32 id_choice)
2672 MonoBoolean result = FALSE;
2674 guint32 cols [MONO_DECL_SECURITY_SIZE];
2675 int index = mono_metadata_declsec_from_index (image, token);
2678 t = &image->tables [MONO_TABLE_DECLSECURITY];
2679 for (i = index; i < t->rows; i++) {
2680 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
2682 if (cols [MONO_DECL_SECURITY_PARENT] != token)
2685 /* if present only replace (class) permissions with method permissions */
2686 /* if empty accept either class or method permissions */
2687 if (cols [MONO_DECL_SECURITY_ACTION] == id_std) {
2688 if (!actions->demand.blob) {
2689 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2690 actions->demand.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
2691 actions->demand.blob = (char*) (blob + 2);
2692 actions->demand.size = mono_metadata_decode_blob_size (blob, &blob);
2695 } else if (cols [MONO_DECL_SECURITY_ACTION] == id_noncas) {
2696 if (!actions->noncasdemand.blob) {
2697 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2698 actions->noncasdemand.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
2699 actions->noncasdemand.blob = (char*) (blob + 2);
2700 actions->noncasdemand.size = mono_metadata_decode_blob_size (blob, &blob);
2703 } else if (cols [MONO_DECL_SECURITY_ACTION] == id_choice) {
2704 if (!actions->demandchoice.blob) {
2705 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2706 actions->demandchoice.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
2707 actions->demandchoice.blob = (char*) (blob + 2);
2708 actions->demandchoice.size = mono_metadata_decode_blob_size (blob, &blob);
2718 mono_declsec_get_class_demands_params (MonoClass *klass, MonoDeclSecurityActions* demands,
2719 guint32 id_std, guint32 id_noncas, guint32 id_choice)
2721 guint32 idx = mono_metadata_token_index (klass->type_token);
2722 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2723 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
2724 return fill_actions_from_index (klass->image, idx, demands, id_std, id_noncas, id_choice);
2728 mono_declsec_get_method_demands_params (MonoMethod *method, MonoDeclSecurityActions* demands,
2729 guint32 id_std, guint32 id_noncas, guint32 id_choice)
2731 guint32 idx = mono_method_get_index (method);
2732 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2733 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
2734 return fill_actions_from_index (method->klass->image, idx, demands, id_std, id_noncas, id_choice);
2738 * mono_declsec_get_demands:
2739 * Collect all actions (that requires to generate code in mini) assigned for
2740 * the specified method.
2741 * Don't use the content of actions if the function return FALSE.
2744 mono_declsec_get_demands (MonoMethod *method, MonoDeclSecurityActions* demands)
2746 guint32 mask = MONO_DECLSEC_FLAG_DEMAND | MONO_DECLSEC_FLAG_NONCAS_DEMAND |
2747 MONO_DECLSEC_FLAG_DEMAND_CHOICE;
2748 MonoBoolean result = FALSE;
2751 /* quick exit if no declarative security is present in the metadata */
2752 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
2755 /* we want the original as the wrapper is "free" of the security informations */
2756 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
2757 method = mono_marshal_method_from_wrapper (method);
2762 /* First we look for method-level attributes */
2763 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2764 mono_class_init (method->klass);
2765 memset (demands, 0, sizeof (MonoDeclSecurityActions));
2767 result = mono_declsec_get_method_demands_params (method, demands,
2768 SECURITY_ACTION_DEMAND, SECURITY_ACTION_NONCASDEMAND, SECURITY_ACTION_DEMANDCHOICE);
2771 /* Here we use (or create) the class declarative cache to look for demands */
2772 flags = mono_declsec_flags_from_class (method->klass);
2775 mono_class_init (method->klass);
2776 memset (demands, 0, sizeof (MonoDeclSecurityActions));
2778 result |= mono_declsec_get_class_demands_params (method->klass, demands,
2779 SECURITY_ACTION_DEMAND, SECURITY_ACTION_NONCASDEMAND, SECURITY_ACTION_DEMANDCHOICE);
2782 /* The boolean return value is used as a shortcut in case nothing needs to
2783 be generated (e.g. LinkDemand[Choice] and InheritanceDemand[Choice]) */
2789 * mono_declsec_get_linkdemands:
2790 * Collect all Link actions: \c LinkDemand, \c NonCasLinkDemand and \c LinkDemandChoice (2.0).
2791 * Don't use the content of actions if the function return FALSE.
2794 mono_declsec_get_linkdemands (MonoMethod *method, MonoDeclSecurityActions* klass, MonoDeclSecurityActions *cmethod)
2796 MonoBoolean result = FALSE;
2799 /* quick exit if no declarative security is present in the metadata */
2800 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
2803 /* we want the original as the wrapper is "free" of the security informations */
2804 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
2805 method = mono_marshal_method_from_wrapper (method);
2810 /* results are independant - zeroize both */
2811 memset (cmethod, 0, sizeof (MonoDeclSecurityActions));
2812 memset (klass, 0, sizeof (MonoDeclSecurityActions));
2814 /* First we look for method-level attributes */
2815 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2816 mono_class_init (method->klass);
2818 result = mono_declsec_get_method_demands_params (method, cmethod,
2819 SECURITY_ACTION_LINKDEMAND, SECURITY_ACTION_NONCASLINKDEMAND, SECURITY_ACTION_LINKDEMANDCHOICE);
2822 /* Here we use (or create) the class declarative cache to look for demands */
2823 flags = mono_declsec_flags_from_class (method->klass);
2824 if (flags & (MONO_DECLSEC_FLAG_LINKDEMAND | MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND | MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE)) {
2825 mono_class_init (method->klass);
2827 result |= mono_declsec_get_class_demands_params (method->klass, klass,
2828 SECURITY_ACTION_LINKDEMAND, SECURITY_ACTION_NONCASLINKDEMAND, SECURITY_ACTION_LINKDEMANDCHOICE);
2835 * mono_declsec_get_inheritdemands_class:
2836 * \param klass The inherited class - this is the class that provides the security check (attributes)
2838 * Collect all Inherit actions - \c InheritanceDemand, \c NonCasInheritanceDemand and \c InheritanceDemandChoice (2.0).
2839 * Don't use the content of actions if the function return FALSE.
2840 * \returns TRUE if inheritance demands (any kind) are present, FALSE otherwise.
2843 mono_declsec_get_inheritdemands_class (MonoClass *klass, MonoDeclSecurityActions* demands)
2845 MonoBoolean result = FALSE;
2848 /* quick exit if no declarative security is present in the metadata */
2849 if (!klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
2852 /* Here we use (or create) the class declarative cache to look for demands */
2853 flags = mono_declsec_flags_from_class (klass);
2854 if (flags & (MONO_DECLSEC_FLAG_INHERITANCEDEMAND | MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND | MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE)) {
2855 mono_class_init (klass);
2856 memset (demands, 0, sizeof (MonoDeclSecurityActions));
2858 result |= mono_declsec_get_class_demands_params (klass, demands,
2859 SECURITY_ACTION_INHERITDEMAND, SECURITY_ACTION_NONCASINHERITANCE, SECURITY_ACTION_INHERITDEMANDCHOICE);
2866 * mono_declsec_get_inheritdemands_method:
2867 * Collect all Inherit actions: \c InheritanceDemand, \c NonCasInheritanceDemand and \c InheritanceDemandChoice (2.0).
2868 * Don't use the content of actions if the function return FALSE.
2871 mono_declsec_get_inheritdemands_method (MonoMethod *method, MonoDeclSecurityActions* demands)
2873 /* quick exit if no declarative security is present in the metadata */
2874 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
2877 /* we want the original as the wrapper is "free" of the security informations */
2878 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
2879 method = mono_marshal_method_from_wrapper (method);
2884 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2885 mono_class_init (method->klass);
2886 memset (demands, 0, sizeof (MonoDeclSecurityActions));
2888 return mono_declsec_get_method_demands_params (method, demands,
2889 SECURITY_ACTION_INHERITDEMAND, SECURITY_ACTION_NONCASINHERITANCE, SECURITY_ACTION_INHERITDEMANDCHOICE);
2896 get_declsec_action (MonoImage *image, guint32 token, guint32 action, MonoDeclSecurityEntry *entry)
2898 guint32 cols [MONO_DECL_SECURITY_SIZE];
2902 int index = mono_metadata_declsec_from_index (image, token);
2906 t = &image->tables [MONO_TABLE_DECLSECURITY];
2907 for (i = index; i < t->rows; i++) {
2908 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
2910 /* shortcut - index are ordered */
2911 if (token != cols [MONO_DECL_SECURITY_PARENT])
2914 if (cols [MONO_DECL_SECURITY_ACTION] == action) {
2915 const char *metadata = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2916 entry->blob = (char*) (metadata + 2);
2917 entry->size = mono_metadata_decode_blob_size (metadata, &metadata);
2926 mono_declsec_get_method_action (MonoMethod *method, guint32 action, MonoDeclSecurityEntry *entry)
2928 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2929 guint32 idx = mono_method_get_index (method);
2930 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2931 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
2932 return get_declsec_action (method->klass->image, idx, action, entry);
2938 * mono_declsec_get_class_action:
2941 mono_declsec_get_class_action (MonoClass *klass, guint32 action, MonoDeclSecurityEntry *entry)
2944 guint32 flags = mono_declsec_flags_from_class (klass);
2945 if (declsec_flags_map [action] & flags) {
2946 guint32 idx = mono_metadata_token_index (klass->type_token);
2947 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2948 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
2949 return get_declsec_action (klass->image, idx, action, entry);
2955 * mono_declsec_get_assembly_action:
2958 mono_declsec_get_assembly_action (MonoAssembly *assembly, guint32 action, MonoDeclSecurityEntry *entry)
2960 guint32 idx = 1; /* there is only one assembly */
2961 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2962 idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
2964 return get_declsec_action (assembly->image, idx, action, entry);
2968 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass, MonoError *error)
2970 MonoObject *res, *exc;
2972 static MonoMethod *method = NULL;
2976 if (method == NULL) {
2977 method = mono_class_get_method_from_name (mono_class_get_type_builder_class (), "IsAssignableTo", 1);
2982 * The result of mono_type_get_object_checked () might be a System.MonoType but we
2983 * need a TypeBuilder so use mono_class_get_ref_info (klass).
2985 g_assert (mono_class_has_ref_info (klass));
2986 g_assert (!strcmp (mono_object_class (mono_class_get_ref_info_raw (klass))->name, "TypeBuilder")); /* FIXME use handles */
2988 params [0] = mono_type_get_object_checked (mono_domain_get (), &oklass->byval_arg, error);
2989 return_val_if_nok (error, FALSE);
2991 MonoError inner_error;
2992 res = mono_runtime_try_invoke (method, mono_class_get_ref_info_raw (klass), params, &exc, &inner_error); /* FIXME use handles */
2994 if (exc || !is_ok (&inner_error)) {
2995 mono_error_cleanup (&inner_error);
2998 return *(MonoBoolean*)mono_object_unbox (res);
3002 * mono_reflection_type_get_type:
3003 * \param reftype the \c System.Type object
3004 * \returns the \c MonoType* associated with the C# \c System.Type object \p reftype.
3007 mono_reflection_type_get_type (MonoReflectionType *reftype)
3012 MonoType *result = mono_reflection_type_get_handle (reftype, &error);
3013 mono_error_assert_ok (&error);
3018 * mono_reflection_assembly_get_assembly:
3019 * \param refassembly the \c System.Reflection.Assembly object
3020 * \returns the \c MonoAssembly* associated with the C# \c System.Reflection.Assembly object \p refassembly.
3023 mono_reflection_assembly_get_assembly (MonoReflectionAssembly *refassembly)
3025 g_assert (refassembly);
3027 return refassembly->assembly;
3031 * mono_class_from_mono_type_handle:
3032 * \param reftype the \c System.Type handle
3033 * \returns the \c MonoClass* corresponding to the given type.
3036 mono_class_from_mono_type_handle (MonoReflectionTypeHandle reftype)
3038 return mono_class_from_mono_type (MONO_HANDLE_RAW (reftype)->type);