?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix roslyn install with AOT disabled.
[mono-project.git] / mono / metadata / reflection.c
blob45b5a54274bf8791c97c327ad79630dee20c6ea5
1 /*
2 * reflection.c: System.Type icalls and related reflection queries.
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 *
7 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
8 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
9 * Copyright 2011 Rodrigo Kumpera
10 * Copyright 2016 Microsoft
11 *
12 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
13 */
14 #include <config.h>
15 #include "mono/utils/mono-membar.h"
16 #include "mono/metadata/reflection-internals.h"
17 #include "mono/metadata/tabledefs.h"
18 #include "mono/metadata/metadata-internals.h"
19 #include <mono/metadata/profiler-private.h>
20 #include "mono/metadata/class-internals.h"
21 #include "mono/metadata/gc-internals.h"
22 #include "mono/metadata/domain-internals.h"
23 #include "mono/metadata/opcodes.h"
24 #include "mono/metadata/assembly.h"
25 #include "mono/metadata/object-internals.h"
26 #include <mono/metadata/exception.h>
27 #include <mono/metadata/marshal.h>
28 #include <mono/metadata/security-manager.h>
29 #include <mono/metadata/reflection-cache.h>
30 #include <mono/metadata/sre-internals.h>
31 #include <stdio.h>
32 #include <glib.h>
33 #include <errno.h>
34 #include <time.h>
35 #include <string.h>
36 #include <ctype.h>
37 #include "image.h"
38 #include "cil-coff.h"
39 #include "mono-endian.h"
40 #include <mono/metadata/gc-internals.h>
41 #include <mono/metadata/mempool-internals.h>
42 #include <mono/metadata/security-core-clr.h>
43 #include <mono/metadata/debug-helpers.h>
44 #include <mono/metadata/verify-internals.h>
45 #include <mono/metadata/mono-ptr-array.h>
46 #include <mono/utils/mono-string.h>
47 #include <mono/utils/mono-error-internals.h>
48 #include <mono/utils/checked-build.h>
49 #include <mono/utils/mono-counters.h>
50
51 static void get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types);
52 static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error);
53
54 /* Class lazy loading functions */
55 static GENERATE_GET_CLASS_WITH_CACHE (mono_assembly, System.Reflection, MonoAssembly)
56 static GENERATE_GET_CLASS_WITH_CACHE (mono_module, System.Reflection, MonoModule)
57 static GENERATE_GET_CLASS_WITH_CACHE (mono_method, System.Reflection, MonoMethod);
58 static GENERATE_GET_CLASS_WITH_CACHE (mono_cmethod, System.Reflection, MonoCMethod);
59 static GENERATE_GET_CLASS_WITH_CACHE (mono_field, System.Reflection, MonoField);
60 static GENERATE_GET_CLASS_WITH_CACHE (mono_event, System.Reflection, MonoEvent);
61 static GENERATE_GET_CLASS_WITH_CACHE (mono_property, System.Reflection, MonoProperty);
62 static GENERATE_GET_CLASS_WITH_CACHE (mono_parameter_info, System.Reflection, MonoParameterInfo);
63 static GENERATE_GET_CLASS_WITH_CACHE (missing, System.Reflection, Missing);
64 static GENERATE_GET_CLASS_WITH_CACHE (method_body, System.Reflection, MethodBody);
65 static GENERATE_GET_CLASS_WITH_CACHE (local_variable_info, System.Reflection, LocalVariableInfo);
66 static GENERATE_GET_CLASS_WITH_CACHE (exception_handling_clause, System.Reflection, ExceptionHandlingClause);
67 static GENERATE_GET_CLASS_WITH_CACHE (type_builder, System.Reflection.Emit, TypeBuilder);
68 static GENERATE_GET_CLASS_WITH_CACHE (dbnull, System, DBNull);
69
70
71 static int class_ref_info_handle_count;
72
73 void
74 mono_reflection_init (void)
75 {
76 mono_reflection_emit_init ();
77
78 mono_counters_register ("MonoClass::ref_info_handle count",
79 MONO_COUNTER_METADATA | MONO_COUNTER_INT, &class_ref_info_handle_count);
80
81 }
82
83 /*
84 * mono_class_get_ref_info:
85 *
86 * Return the type builder/generic param builder corresponding to KLASS, if it exists.
87 */
88 gpointer
89 mono_class_get_ref_info (MonoClass *klass)
90 {
91 MONO_REQ_GC_UNSAFE_MODE;
92 guint32 ref_info_handle = mono_class_get_ref_info_handle (klass);
93
94 if (ref_info_handle == 0)
95 return NULL;
96 else
97 return mono_gchandle_get_target (ref_info_handle);
98 }
99
100 void
101 mono_class_set_ref_info (MonoClass *klass, gpointer obj)
102 {
103 MONO_REQ_GC_UNSAFE_MODE;
104
105 guint32 candidate = mono_gchandle_new ((MonoObject*)obj, FALSE);
106 guint32 handle = mono_class_set_ref_info_handle (klass, candidate);
107 ++class_ref_info_handle_count;
108
109 if (handle != candidate)
110 mono_gchandle_free (candidate);
111 }
112
113 void
114 mono_class_free_ref_info (MonoClass *klass)
115 {
116 MONO_REQ_GC_NEUTRAL_MODE;
117 guint32 handle = mono_class_get_ref_info_handle (klass);
118
119 if (handle) {
120 mono_gchandle_free (handle);
121 mono_class_set_ref_info_handle (klass, 0);
122 }
123 }
124
125
126 void
127 mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
128 {
129 MONO_REQ_GC_NEUTRAL_MODE;
130
131 if (ainfo && !ainfo->cached)
132 g_free (ainfo);
133 }
134
135
136 gboolean
137 reflected_equal (gconstpointer a, gconstpointer b)
138 {
139 const ReflectedEntry *ea = (const ReflectedEntry *)a;
140 const ReflectedEntry *eb = (const ReflectedEntry *)b;
141
142 return (ea->item == eb->item) && (ea->refclass == eb->refclass);
143 }
144
145 guint
146 reflected_hash (gconstpointer a) {
147 const ReflectedEntry *ea = (const ReflectedEntry *)a;
148 return mono_aligned_addr_hash (ea->item);
149 }
150
151
152 static void
153 clear_cached_object (MonoDomain *domain, gpointer o, MonoClass *klass)
154 {
155 mono_domain_lock (domain);
156 if (domain->refobject_hash) {
157 ReflectedEntry pe;
158 gpointer orig_pe, orig_value;
159
160 pe.item = o;
161 pe.refclass = klass;
162 if (mono_g_hash_table_lookup_extended (domain->refobject_hash, &pe, &orig_pe, &orig_value)) {
163 mono_g_hash_table_remove (domain->refobject_hash, &pe);
164 FREE_REFENTRY (orig_pe);
165 }
166 }
167 mono_domain_unlock (domain);
168 }
169
170 #ifdef REFENTRY_REQUIRES_CLEANUP
171 static void
172 cleanup_refobject_hash (gpointer key, gpointer value, gpointer user_data)
173 {
174 FREE_REFENTRY (key);
175 }
176 #endif
177
178 void
179 mono_reflection_cleanup_domain (MonoDomain *domain)
180 {
181 if (domain->refobject_hash) {
182 /*let's avoid scanning the whole hashtable if not needed*/
183 #ifdef REFENTRY_REQUIRES_CLEANUP
184 mono_g_hash_table_foreach (domain->refobject_hash, cleanup_refobject_hash, NULL);
185 #endif
186 mono_g_hash_table_destroy (domain->refobject_hash);
187 domain->refobject_hash = NULL;
188 }
189 }
190
191
192 /*
193 * mono_assembly_get_object:
194 * @domain: an app domain
195 * @assembly: an assembly
196 *
197 * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
198 */
199 MonoReflectionAssembly*
200 mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
201 {
202 HANDLE_FUNCTION_ENTER ();
203 MonoError error;
204 MonoReflectionAssemblyHandle result = mono_assembly_get_object_handle (domain, assembly, &error);
205 mono_error_cleanup (&error); /* FIXME new API that doesn't swallow the error */
206 HANDLE_FUNCTION_RETURN_OBJ (result);
207 }
208
209 static MonoReflectionAssemblyHandle
210 assembly_object_construct (MonoDomain *domain, MonoClass *unused_klass, MonoAssembly *assembly, gpointer user_data, MonoError *error)
211 {
212 mono_error_init (error);
213 MonoReflectionAssemblyHandle res = MONO_HANDLE_NEW (MonoReflectionAssembly, mono_object_new_checked (domain, mono_class_get_mono_assembly_class (), error));
214 return_val_if_nok (error, MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE));
215 MONO_HANDLE_SETVAL (res, assembly, MonoAssembly*, assembly);
216 return res;
217 }
218
219 /*
220 * mono_assembly_get_object_handle:
221 * @domain: an app domain
222 * @assembly: an assembly
223 *
224 * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
225 */
226 MonoReflectionAssemblyHandle
227 mono_assembly_get_object_handle (MonoDomain *domain, MonoAssembly *assembly, MonoError *error)
228 {
229 mono_error_init (error);
230 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionAssemblyHandle, assembly, NULL, assembly_object_construct, NULL);
231 }
232
233 MonoReflectionModule*
234 mono_module_get_object (MonoDomain *domain, MonoImage *image)
235 {
236 HANDLE_FUNCTION_ENTER ();
237 MonoError error;
238 MonoReflectionModuleHandle result = mono_module_get_object_handle (domain, image, &error);
239 mono_error_cleanup (&error);
240 HANDLE_FUNCTION_RETURN_OBJ (result);
241 }
242
243 static MonoReflectionModuleHandle
244 module_object_construct (MonoDomain *domain, MonoClass *unused_klass, MonoImage *image, gpointer user_data, MonoError *error)
245 {
246 char* basename;
247
248 mono_error_init (error);
249 MonoReflectionModuleHandle res = MONO_HANDLE_NEW (MonoReflectionModule, mono_object_new_checked (domain, mono_class_get_mono_module_class (), error));
250 if (!is_ok (error))
251 goto fail;
252
253 MONO_HANDLE_SETVAL (res, image, MonoImage *, image);
254 MonoReflectionAssemblyHandle assm_obj = mono_assembly_get_object_handle (domain, image->assembly, error);
255 if (!is_ok (error))
256 goto fail;
257 MONO_HANDLE_SET (res, assembly, assm_obj);
258
259 MONO_HANDLE_SET (res, fqname, mono_string_new_handle (domain, image->name, error));
260 if (!is_ok (error))
261 goto fail;
262 basename = g_path_get_basename (image->name);
263 MONO_HANDLE_SET (res, name, mono_string_new_handle (domain, basename, error));
264 if (!is_ok (error))
265 goto fail;
266 MONO_HANDLE_SET (res, scopename, mono_string_new_handle (domain, image->module_name, error));
267 if (!is_ok (error))
268 goto fail;
269
270 g_free (basename);
271
272 guint32 token = 0;
273 if (image->assembly->image == image) {
274 token = mono_metadata_make_token (MONO_TABLE_MODULE, 1);
275 } else {
276 int i;
277 if (image->assembly->image->modules) {
278 for (i = 0; i < image->assembly->image->module_count; i++) {
279 if (image->assembly->image->modules [i] == image)
280 token = mono_metadata_make_token (MONO_TABLE_MODULEREF, i + 1);
281 }
282 g_assert (token != 0);
283 }
284 }
285 MONO_HANDLE_SETVAL (res, token, guint32, token);
286
287 return res;
288 fail:
289 return MONO_HANDLE_CAST (MonoReflectionModule, NULL_HANDLE);
290 }
291
292 MonoReflectionModuleHandle
293 mono_module_get_object_handle (MonoDomain *domain, MonoImage *image, MonoError *error)
294 {
295 mono_error_init (error);
296 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionModuleHandle, image, NULL, module_object_construct, NULL);
297 }
298
299 MonoReflectionModule*
300 mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index)
301 {
302 HANDLE_FUNCTION_ENTER ();
303 MonoError error;
304 MonoReflectionModuleHandle result = mono_module_file_get_object_handle (domain, image, table_index, &error);
305 mono_error_cleanup (&error);
306 HANDLE_FUNCTION_RETURN_OBJ (result);
307 }
308
309 MonoReflectionModuleHandle
310 mono_module_file_get_object_handle (MonoDomain *domain, MonoImage *image, int table_index, MonoError *error)
311 {
312 MonoTableInfo *table;
313 guint32 cols [MONO_FILE_SIZE];
314 const char *name;
315 guint32 i, name_idx;
316 const char *val;
317
318 mono_error_init (error);
319
320 MonoReflectionModuleHandle res = MONO_HANDLE_NEW (MonoReflectionModule, mono_object_new_checked (domain, mono_class_get_mono_module_class (), error));
321 if (!is_ok (error))
322 goto fail;
323
324 table = &image->tables [MONO_TABLE_FILE];
325 g_assert (table_index < table->rows);
326 mono_metadata_decode_row (table, table_index, cols, MONO_FILE_SIZE);
327
328 MONO_HANDLE_SETVAL (res, image, MonoImage*, NULL);
329 MonoReflectionAssemblyHandle assm_obj = mono_assembly_get_object_handle (domain, image->assembly, error);
330 if (!is_ok (error))
331 goto fail;
332 MONO_HANDLE_SET (res, assembly, assm_obj);
333 name = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]);
334
335 /* Check whenever the row has a corresponding row in the moduleref table */
336 table = &image->tables [MONO_TABLE_MODULEREF];
337 for (i = 0; i < table->rows; ++i) {
338 name_idx = mono_metadata_decode_row_col (table, i, MONO_MODULEREF_NAME);
339 val = mono_metadata_string_heap (image, name_idx);
340 if (strcmp (val, name) == 0)
341 MONO_HANDLE_SETVAL (res, image, MonoImage*, image->modules [i]);
342 }
343
344 MONO_HANDLE_SET (res, fqname, mono_string_new_handle (domain, name, error));
345 if (!is_ok (error))
346 goto fail;
347 MONO_HANDLE_SET (res, name, mono_string_new_handle (domain, name, error));
348 if (!is_ok (error))
349 goto fail;
350 MONO_HANDLE_SET (res, scopename, mono_string_new_handle (domain, name, error));
351 if (!is_ok (error))
352 goto fail;
353 MONO_HANDLE_SETVAL (res, is_resource, MonoBoolean, cols [MONO_FILE_FLAGS] & FILE_CONTAINS_NO_METADATA);
354 MONO_HANDLE_SETVAL (res, token, guint32, mono_metadata_make_token (MONO_TABLE_FILE, table_index + 1));
355
356 return res;
357 fail:
358 return MONO_HANDLE_CAST (MonoReflectionModule, NULL_HANDLE);
359 }
360
361 static MonoType*
362 mono_type_normalize (MonoType *type)
363 {
364 int i;
365 MonoGenericClass *gclass;
366 MonoGenericInst *ginst;
367 MonoClass *gtd;
368 MonoGenericContainer *gcontainer;
369 MonoType **argv = NULL;
370 gboolean is_denorm_gtd = TRUE, requires_rebind = FALSE;
371
372 if (type->type != MONO_TYPE_GENERICINST)
373 return type;
374
375 gclass = type->data.generic_class;
376 ginst = gclass->context.class_inst;
377 if (!ginst->is_open)
378 return type;
379
380 gtd = gclass->container_class;
381 gcontainer = mono_class_get_generic_container (gtd);
382 argv = g_newa (MonoType*, ginst->type_argc);
383
384 for (i = 0; i < ginst->type_argc; ++i) {
385 MonoType *t = ginst->type_argv [i], *norm;
386 if (t->type != MONO_TYPE_VAR || t->data.generic_param->num != i || t->data.generic_param->owner != gcontainer)
387 is_denorm_gtd = FALSE;
388 norm = mono_type_normalize (t);
389 argv [i] = norm;
390 if (norm != t)
391 requires_rebind = TRUE;
392 }
393
394 if (is_denorm_gtd)
395 return type->byref == gtd->byval_arg.byref ? &gtd->byval_arg : &gtd->this_arg;
396
397 if (requires_rebind) {
398 MonoClass *klass = mono_class_bind_generic_parameters (gtd, ginst->type_argc, argv, gclass->is_dynamic);
399 return type->byref == klass->byval_arg.byref ? &klass->byval_arg : &klass->this_arg;
400 }
401
402 return type;
403 }
404 /*
405 * mono_type_get_object:
406 * @domain: an app domain
407 * @type: a type
408 *
409 * Return an System.MonoType object representing the type @type.
410 */
411 MonoReflectionType*
412 mono_type_get_object (MonoDomain *domain, MonoType *type)
413 {
414 MonoError error;
415 MonoReflectionType *ret = mono_type_get_object_checked (domain, type, &error);
416 mono_error_cleanup (&error);
417
418 return ret;
419 }
420
421 MonoReflectionType*
422 mono_type_get_object_checked (MonoDomain *domain, MonoType *type, MonoError *error)
423 {
424 MonoType *norm_type;
425 MonoReflectionType *res;
426 MonoClass *klass;
427
428 mono_error_init (error);
429
430 g_assert (type != NULL);
431 klass = mono_class_from_mono_type (type);
432
433 /*we must avoid using @type as it might have come
434 * from a mono_metadata_type_dup and the caller
435 * expects that is can be freed.
436 * Using the right type from
437 */
438 type = klass->byval_arg.byref == type->byref ? &klass->byval_arg : &klass->this_arg;
439
440 /* void is very common */
441 if (type->type == MONO_TYPE_VOID && domain->typeof_void)
442 return (MonoReflectionType*)domain->typeof_void;
443
444 /*
445 * If the vtable of the given class was already created, we can use
446 * the MonoType from there and avoid all locking and hash table lookups.
447 *
448 * We cannot do this for TypeBuilders as mono_reflection_create_runtime_class expects
449 * that the resulting object is different.
450 */
451 if (type == &klass->byval_arg && !image_is_dynamic (klass->image)) {
452 MonoVTable *vtable = mono_class_try_get_vtable (domain, klass);
453 if (vtable && vtable->type)
454 return (MonoReflectionType *)vtable->type;
455 }
456
457 mono_loader_lock (); /*FIXME mono_class_init and mono_class_vtable acquire it*/
458 mono_domain_lock (domain);
459 if (!domain->type_hash)
460 domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
461 (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection types table");
462 if ((res = (MonoReflectionType *)mono_g_hash_table_lookup (domain->type_hash, type))) {
463 mono_domain_unlock (domain);
464 mono_loader_unlock ();
465 return res;
466 }
467
468 /*Types must be normalized so a generic instance of the GTD get's the same inner type.
469 * For example in: Foo<A,B>; Bar<A> : Foo<A, Bar<A>>
470 * The second Bar will be encoded a generic instance of Bar with <A> as parameter.
471 * On all other places, Bar<A> will be encoded as the GTD itself. This is an implementation
472 * artifact of how generics are encoded and should be transparent to managed code so we
473 * need to weed out this diference when retrieving managed System.Type objects.
474 */
475 norm_type = mono_type_normalize (type);
476 if (norm_type != type) {
477 res = mono_type_get_object_checked (domain, norm_type, error);
478 if (!mono_error_ok (error))
479 return NULL;
480 mono_g_hash_table_insert (domain->type_hash, type, res);
481 mono_domain_unlock (domain);
482 mono_loader_unlock ();
483 return res;
484 }
485
486 if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_class->is_dynamic && !type->data.generic_class->container_class->wastypebuilder) {
487 /* This can happen if a TypeBuilder for a generic class K<T,U>
488 * had reflection_create_generic_class) called on it, but not
489 * ves_icall_TypeBuilder_create_runtime_class. This can happen
490 * if the K`2 is refernced from a generic instantiation
491 * (e.g. K<int,string>) that appears as type argument
492 * (e.g. Dict<string,K<int,string>>), field (e.g. K<int,string>
493 * Foo) or method signature, parent class or any of the above
494 * in a nested class of some other TypeBuilder. Such an
495 * occurrence caused mono_reflection_type_get_handle to be
496 * called on the sre generic instance (K<int,string>) which
497 * required the container_class for the generic class K`2 to be
498 * set up, but the remainder of class construction for K`2 has
499 * not been done. */
500 char * full_name = mono_type_get_full_name (klass);
501 /* I would have expected ReflectionTypeLoadException, but evidently .NET throws TLE in this case. */
502 mono_error_set_type_load_class (error, klass, "TypeBuilder.CreateType() not called for generic class %s", full_name);
503 g_free (full_name);
504 mono_domain_unlock (domain);
505 mono_loader_unlock ();
506 return NULL;
507 }
508
509 if (mono_class_get_ref_info (klass) && !klass->wastypebuilder && !type->byref) {
510 mono_domain_unlock (domain);
511 mono_loader_unlock ();
512 return (MonoReflectionType *)mono_class_get_ref_info (klass);
513 }
514 /* This is stored in vtables/JITted code so it has to be pinned */
515 res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.runtimetype_class, error);
516 if (!mono_error_ok (error))
517 return NULL;
518
519 res->type = type;
520 mono_g_hash_table_insert (domain->type_hash, type, res);
521
522 if (type->type == MONO_TYPE_VOID)
523 domain->typeof_void = (MonoObject*)res;
524
525 mono_domain_unlock (domain);
526 mono_loader_unlock ();
527 return res;
528 }
529
530 MonoReflectionTypeHandle
531 mono_type_get_object_handle (MonoDomain *domain, MonoType *type, MonoError *error)
532 {
533 /* NOTE: We happen to know that mono_type_get_object_checked returns
534 * pinned objects, so we can just wrap its return value in a handle for
535 * uniformity. If it ever starts returning unpinned, objects, this
536 * implementation would need to change!
537 */
538 return MONO_HANDLE_NEW (MonoReflectionType, mono_type_get_object_checked (domain, type, error));
539 }
540
541 /*
542 * mono_method_get_object:
543 * @domain: an app domain
544 * @method: a method
545 * @refclass: the reflected type (can be NULL)
546 *
547 * Return an System.Reflection.MonoMethod object representing the method @method.
548 */
549 MonoReflectionMethod*
550 mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
551 {
552 HANDLE_FUNCTION_ENTER ();
553 MonoError error;
554 MonoReflectionMethodHandle ret = mono_method_get_object_handle (domain, method, refclass, &error);
555 mono_error_cleanup (&error);
556 HANDLE_FUNCTION_RETURN_OBJ (ret);
557 }
558
559 static MonoReflectionMethodHandle
560 method_object_construct (MonoDomain *domain, MonoClass *refclass, MonoMethod *method, gpointer user_data, MonoError *error)
561 {
562 mono_error_init (error);
563 g_assert (refclass != NULL);
564 /*
565 * We use the same C representation for methods and constructors, but the type
566 * name in C# is different.
567 */
568 MonoClass *klass;
569
570 mono_error_init (error);
571
572 if (*method->name == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0)) {
573 klass = mono_class_get_mono_cmethod_class ();
574 }
575 else {
576 klass = mono_class_get_mono_method_class ();
577 }
578 MonoReflectionMethodHandle ret = MONO_HANDLE_NEW (MonoReflectionMethod, mono_object_new_checked (domain, klass, error));
579 if (!mono_error_ok (error))
580 goto leave;
581 MONO_HANDLE_SETVAL (ret, method, MonoMethod*, method);
582
583 MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, &refclass->byval_arg, error);
584 if (!mono_error_ok (error))
585 goto leave;
586
587 MONO_HANDLE_SET (ret, reftype, rt);
588
589 leave:
590 return ret;
591 }
592
593 /*
594 * mono_method_get_object_handle:
595 * @domain: an app domain
596 * @method: a method
597 * @refclass: the reflected type (can be NULL)
598 * @error: set on error.
599 *
600 * Return an System.Reflection.MonoMethod object representing the method @method.
601 * Returns NULL and sets @error on error.
602 */
603 MonoReflectionMethodHandle
604 mono_method_get_object_handle (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
605 {
606 mono_error_init (error);
607 if (!refclass)
608 refclass = method->klass;
609
610 return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionMethodHandle, method, refclass, method_object_construct, NULL);
611 }
612 /*
613 * mono_method_get_object_checked:
614 * @domain: an app domain
615 * @method: a method
616 * @refclass: the reflected type (can be NULL)
617 * @error: set on error.
618 *
619 * Return an System.Reflection.MonoMethod object representing the method @method.
620 * Returns NULL and sets @error on error.
621 */
622 MonoReflectionMethod*
623 mono_method_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
624 {
625 HANDLE_FUNCTION_ENTER ();
626 mono_error_init (error);
627 MonoReflectionMethodHandle result = mono_method_get_object_handle (domain, method, refclass, error);
628 HANDLE_FUNCTION_RETURN_OBJ (result);
629 }
630
631 /*
632 * mono_method_clear_object:
633 *
634 * Clear the cached reflection objects for the dynamic method METHOD.
635 */
636 void
637 mono_method_clear_object (MonoDomain *domain, MonoMethod *method)
638 {
639 MonoClass *klass;
640 g_assert (method_is_dynamic (method));
641
642 klass = method->klass;
643 while (klass) {
644 clear_cached_object (domain, method, klass);
645 klass = klass->parent;
646 }
647 /* Added by mono_param_get_objects () */
648 clear_cached_object (domain, &(method->signature), NULL);
649 klass = method->klass;
650 while (klass) {
651 clear_cached_object (domain, &(method->signature), klass);
652 klass = klass->parent;
653 }
654 }
655
656 /*
657 * mono_field_get_object:
658 * @domain: an app domain
659 * @klass: a type
660 * @field: a field
661 *
662 * Return an System.Reflection.MonoField object representing the field @field
663 * in class @klass.
664 */
665 MonoReflectionField*
666 mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field)
667 {
668 MonoError error;
669 MonoReflectionField *result;
670 result = mono_field_get_object_checked (domain, klass, field, &error);
671 mono_error_cleanup (&error);
672 return result;
673 }
674
675 static MonoReflectionField*
676 field_object_construct (MonoDomain *domain, MonoClass *klass, MonoClassField *field, gpointer user_data, MonoError *error)
677 {
678 MonoReflectionType *rt;
679 MonoReflectionField *res;
680
681 mono_error_init (error);
682
683 res = (MonoReflectionField *)mono_object_new_checked (domain, mono_class_get_mono_field_class (), error);
684 if (!res)
685 return NULL;
686 res->klass = klass;
687 res->field = field;
688 MONO_OBJECT_SETREF (res, name, mono_string_new (domain, mono_field_get_name (field)));
689
690 if (field->type) {
691 rt = mono_type_get_object_checked (domain, field->type, error);
692 if (!mono_error_ok (error))
693 return NULL;
694
695 MONO_OBJECT_SETREF (res, type, rt);
696 }
697 res->attrs = mono_field_get_flags (field);
698 return res;
699 }
700
701 /*
702 * mono_field_get_object_checked:
703 * @domain: an app domain
704 * @klass: a type
705 * @field: a field
706 * @error: set on error
707 *
708 * Return an System.Reflection.MonoField object representing the field @field
709 * in class @klass. On error, returns NULL and sets @error.
710 */
711 MonoReflectionField*
712 mono_field_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
713 {
714 mono_error_init (error);
715 return CHECK_OR_CONSTRUCT (MonoReflectionField*, field, klass, field_object_construct, NULL);
716 }
717
718 /*
719 * mono_property_get_object:
720 * @domain: an app domain
721 * @klass: a type
722 * @property: a property
723 *
724 * Return an System.Reflection.MonoProperty object representing the property @property
725 * in class @klass.
726 */
727 MonoReflectionProperty*
728 mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property)
729 {
730 MonoError error;
731 MonoReflectionProperty *result;
732 result = mono_property_get_object_checked (domain, klass, property, &error);
733 mono_error_cleanup (&error);
734 return result;
735 }
736
737 static MonoReflectionProperty*
738 property_object_construct (MonoDomain *domain, MonoClass *klass, MonoProperty *property, gpointer user_data, MonoError *error)
739 {
740 MonoReflectionProperty *res;
741
742 mono_error_init (error);
743
744 res = (MonoReflectionProperty *)mono_object_new_checked (domain, mono_class_get_mono_property_class (), error);
745 if (!res)
746 return NULL;
747 res->klass = klass;
748 res->property = property;
749 return res;
750 }
751
752 /**
753 * mono_property_get_object:
754 * @domain: an app domain
755 * @klass: a type
756 * @property: a property
757 * @error: set on error
758 *
759 * Return an System.Reflection.MonoProperty object representing the property @property
760 * in class @klass. On error returns NULL and sets @error.
761 */
762 MonoReflectionProperty*
763 mono_property_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error)
764 {
765 mono_error_init (error);
766 return CHECK_OR_CONSTRUCT (MonoReflectionProperty*, property, klass, property_object_construct, NULL);
767 }
768
769 /*
770 * mono_event_get_object:
771 * @domain: an app domain
772 * @klass: a type
773 * @event: a event
774 *
775 * Return an System.Reflection.MonoEvent object representing the event @event
776 * in class @klass.
777 */
778 MonoReflectionEvent*
779 mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
780 {
781 MonoError error;
782 MonoReflectionEvent *result;
783 result = mono_event_get_object_checked (domain, klass, event, &error);
784 mono_error_cleanup (&error);
785 return result;
786 }
787
788 static MonoReflectionEvent*
789 event_object_construct (MonoDomain *domain, MonoClass *klass, MonoEvent *event, gpointer user_data, MonoError *error)
790 {
791 MonoReflectionMonoEvent *mono_event;
792
793 mono_error_init (error);
794 mono_event = (MonoReflectionMonoEvent *)mono_object_new_checked (domain, mono_class_get_mono_event_class (), error);
795 if (!mono_event)
796 return NULL;
797 mono_event->klass = klass;
798 mono_event->event = event;
799 return &mono_event->object;
800 }
801
802 /**
803 * mono_event_get_object_checked:
804 * @domain: an app domain
805 * @klass: a type
806 * @event: a event
807 * @error: set on error
808 *
809 * Return an System.Reflection.MonoEvent object representing the event @event
810 * in class @klass. On failure sets @error and returns NULL
811 */
812 MonoReflectionEvent*
813 mono_event_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error)
814 {
815 mono_error_init (error);
816 return CHECK_OR_CONSTRUCT (MonoReflectionEvent*, event, klass, event_object_construct, NULL);
817 }
818
819 /**
820 * mono_get_reflection_missing_object:
821 * @domain: Domain where the object lives
822 *
823 * Returns the System.Reflection.Missing.Value singleton object
824 * (of type System.Reflection.Missing).
825 *
826 * Used as the value for ParameterInfo.DefaultValue when Optional
827 * is present
828 */
829 static MonoObject *
830 mono_get_reflection_missing_object (MonoDomain *domain)
831 {
832 MonoError error;
833 MonoObject *obj;
834 static MonoClassField *missing_value_field = NULL;
835
836 if (!missing_value_field) {
837 MonoClass *missing_klass;
838 missing_klass = mono_class_get_missing_class ();
839 mono_class_init (missing_klass);
840 missing_value_field = mono_class_get_field_from_name (missing_klass, "Value");
841 g_assert (missing_value_field);
842 }
843 obj = mono_field_get_value_object_checked (domain, missing_value_field, NULL, &error);
844 mono_error_assert_ok (&error);
845 return obj;
846 }
847
848 static MonoObject*
849 get_dbnull_object (MonoDomain *domain, MonoError *error)
850 {
851 MonoObject *obj;
852 static MonoClassField *dbnull_value_field = NULL;
853
854 mono_error_init (error);
855
856 if (!dbnull_value_field) {
857 MonoClass *dbnull_klass;
858 dbnull_klass = mono_class_get_dbnull_class ();
859 dbnull_value_field = mono_class_get_field_from_name (dbnull_klass, "Value");
860 g_assert (dbnull_value_field);
861 }
862 obj = mono_field_get_value_object_checked (domain, dbnull_value_field, NULL, error);
863 return obj;
864 }
865
866 static MonoObject*
867 get_dbnull (MonoDomain *domain, MonoObject **dbnull, MonoError *error)
868 {
869 mono_error_init (error);
870 if (!*dbnull)
871 *dbnull = get_dbnull_object (domain, error);
872 return *dbnull;
873 }
874
875 static MonoObject*
876 get_reflection_missing (MonoDomain *domain, MonoObject **reflection_missing)
877 {
878 if (!*reflection_missing)
879 *reflection_missing = mono_get_reflection_missing_object (domain);
880 return *reflection_missing;
881 }
882
883 static MonoArray*
884 param_objects_construct (MonoDomain *domain, MonoClass *refclass, MonoMethodSignature **addr_of_sig, gpointer user_data, MonoError *error)
885 {
886 static MonoClass *System_Reflection_ParameterInfo;
887 static MonoClass *System_Reflection_ParameterInfo_array;
888
889 MonoMethod *method = (MonoMethod*)user_data;
890 MonoMethodSignature *sig = *addr_of_sig; /* see note in mono_param_get_objects_internal */
891
892 MonoArray *res = NULL;
893 MonoReflectionMethod *member = NULL;
894 MonoReflectionParameter *param = NULL;
895 char **names = NULL, **blobs = NULL;
896 guint32 *types = NULL;
897 MonoType *type = NULL;
898 MonoObject *dbnull = NULL;
899 MonoObject *missing = NULL;
900 MonoMarshalSpec **mspecs = NULL;
901 MonoVTable *pinfo_vtable;
902 MonoReflectionType *rt;
903 int i;
904
905 mono_error_init (error);
906
907 if (!System_Reflection_ParameterInfo_array) {
908 MonoClass *klass;
909 klass = mono_class_get_mono_parameter_info_class ();
910 System_Reflection_ParameterInfo = klass;
911 klass = mono_array_class_get (klass, 1);
912 System_Reflection_ParameterInfo_array = klass;
913 }
914
915 member = mono_method_get_object_checked (domain, method, refclass, error);
916 if (!member)
917 goto leave;
918 names = g_new (char *, sig->param_count);
919 mono_method_get_param_names (method, (const char **) names);
920
921 mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
922 mono_method_get_marshal_info (method, mspecs);
923
924 res = mono_array_new_specific_checked (mono_class_vtable (domain, System_Reflection_ParameterInfo_array), sig->param_count, error);
925 if (!res)
926 goto leave;
927
928 pinfo_vtable = mono_class_vtable (domain, System_Reflection_ParameterInfo);
929 for (i = 0; i < sig->param_count; ++i) {
930 param = (MonoReflectionParameter *) mono_object_new_specific_checked (pinfo_vtable, error);
931 if (!param)
932 goto leave;
933
934 rt = mono_type_get_object_checked (domain, sig->params [i], error);
935 if (!rt)
936 goto leave;
937
938 MONO_OBJECT_SETREF (param, ClassImpl, rt);
939
940 MONO_OBJECT_SETREF (param, MemberImpl, (MonoObject*)member);
941
942 MONO_OBJECT_SETREF (param, NameImpl, mono_string_new (domain, names [i]));
943
944 param->PositionImpl = i;
945 param->AttrsImpl = sig->params [i]->attrs;
946
947 if (!(param->AttrsImpl & PARAM_ATTRIBUTE_HAS_DEFAULT)) {
948 if (param->AttrsImpl & PARAM_ATTRIBUTE_OPTIONAL)
949 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_reflection_missing (domain, &missing));
950 else
951 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_dbnull (domain, &dbnull, error));
952 if (!is_ok (error))
953 goto leave;
954 } else {
955
956 if (!blobs) {
957 blobs = g_new0 (char *, sig->param_count);
958 types = g_new0 (guint32, sig->param_count);
959 get_default_param_value_blobs (method, blobs, types);
960 }
961
962 /* Build MonoType for the type from the Constant Table */
963 if (!type)
964 type = g_new0 (MonoType, 1);
965 type->type = (MonoTypeEnum)types [i];
966 type->data.klass = NULL;
967 if (types [i] == MONO_TYPE_CLASS)
968 type->data.klass = mono_defaults.object_class;
969 else if ((sig->params [i]->type == MONO_TYPE_VALUETYPE) && sig->params [i]->data.klass->enumtype) {
970 /* For enums, types [i] contains the base type */
971
972 type->type = MONO_TYPE_VALUETYPE;
973 type->data.klass = mono_class_from_mono_type (sig->params [i]);
974 } else
975 type->data.klass = mono_class_from_mono_type (type);
976
977 MonoObject *default_val_obj = mono_get_object_from_blob (domain, type, blobs [i], error);
978 if (!is_ok (error))
979 goto leave;
980 MONO_OBJECT_SETREF (param, DefaultValueImpl, default_val_obj);
981
982 /* Type in the Constant table is MONO_TYPE_CLASS for nulls */
983 if (types [i] != MONO_TYPE_CLASS && !param->DefaultValueImpl) {
984 if (param->AttrsImpl & PARAM_ATTRIBUTE_OPTIONAL)
985 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_reflection_missing (domain, &missing));
986 else
987 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_dbnull (domain, &dbnull, error));
988 if (!is_ok (error))
989 goto leave;
990 }
991 }
992
993 if (mspecs [i + 1]) {
994 MonoReflectionMarshalAsAttribute* mobj;
995 mobj = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [i + 1], error);
996 if (!mobj)
997 goto leave;
998 MONO_OBJECT_SETREF (param, MarshalAsImpl, (MonoObject*)mobj);
999 }
1000
1001 mono_array_setref (res, i, param);
1002 }
1003
1004 leave:
1005 g_free (names);
1006 g_free (blobs);
1007 g_free (types);
1008 g_free (type);
1009
1010 if (sig) {
1011 for (i = sig->param_count; i >= 0; i--) {
1012 if (mspecs [i])
1013 mono_metadata_free_marshal_spec (mspecs [i]);
1014 }
1015 }
1016 g_free (mspecs);
1017
1018 if (!is_ok (error))
1019 return NULL;
1020
1021 return res;
1022 }
1023
1024 /*
1025 * mono_param_get_objects:
1026 * @domain: an app domain
1027 * @method: a method
1028 *
1029 * Return an System.Reflection.ParameterInfo array object representing the parameters
1030 * in the method @method.
1031 */
1032 MonoArray*
1033 mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
1034 {
1035 mono_error_init (error);
1036
1037 MonoMethodSignature *sig = mono_method_signature_checked (method, error);
1038 if (!mono_error_ok (error))
1039 goto leave;
1040
1041 if (!sig->param_count) {
1042 MonoArray *res = mono_array_new_checked (domain, mono_class_get_mono_parameter_info_class (), 0, error);
1043 if (!res)
1044 goto leave;
1045
1046 return res;
1047 }
1048
1049 /* Note: the cache is based on the address of the signature into the method
1050 * since we already cache MethodInfos with the method as keys.
1051 */
1052 return CHECK_OR_CONSTRUCT (MonoArray*, &method->signature, refclass, param_objects_construct, method);
1053 leave:
1054 return NULL;
1055 }
1056
1057 MonoArray*
1058 mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
1059 {
1060 MonoError error;
1061 MonoArray *result = mono_param_get_objects_internal (domain, method, NULL, &error);
1062 mono_error_assert_ok (&error);
1063 return result;
1064 }
1065
1066 /*
1067 * mono_method_body_get_object:
1068 * @domain: an app domain
1069 * @method: a method
1070 *
1071 * Return an System.Reflection.MethodBody object representing the method @method.
1072 */
1073 MonoReflectionMethodBody*
1074 mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
1075 {
1076 MonoError error;
1077 MonoReflectionMethodBody *result = mono_method_body_get_object_checked (domain, method, &error);
1078 mono_error_cleanup (&error);
1079 return result;
1080 }
1081
1082 static MonoReflectionMethodBody*
1083 method_body_object_construct (MonoDomain *domain, MonoClass *unused_class, MonoMethod *method, gpointer user_data, MonoError *error)
1084 {
1085 MonoReflectionMethodBody *ret;
1086 MonoMethodHeader *header;
1087 MonoImage *image;
1088 MonoReflectionType *rt;
1089 guint32 method_rva, local_var_sig_token;
1090 char *ptr;
1091 unsigned char format, flags;
1092 int i;
1093
1094 mono_error_init (error);
1095
1096 /* for compatibility with .net */
1097 if (method_is_dynamic (method)) {
1098 mono_error_set_generic_error (error, "System", "InvalidOperationException", "");
1099 return NULL;
1100 }
1101
1102 if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
1103 (method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
1104 (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
1105 (method->klass->image->raw_data && method->klass->image->raw_data [1] != 'Z') ||
1106 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME))
1107 return NULL;
1108
1109 image = method->klass->image;
1110 header = mono_method_get_header_checked (method, error);
1111 return_val_if_nok (error, NULL);
1112
1113 if (!image_is_dynamic (image)) {
1114 /* Obtain local vars signature token */
1115 method_rva = mono_metadata_decode_row_col (&image->tables [MONO_TABLE_METHOD], mono_metadata_token_index (method->token) - 1, MONO_METHOD_RVA);
1116 ptr = mono_image_rva_map (image, method_rva);
1117 flags = *(const unsigned char *) ptr;
1118 format = flags & METHOD_HEADER_FORMAT_MASK;
1119 switch (format){
1120 case METHOD_HEADER_TINY_FORMAT:
1121 local_var_sig_token = 0;
1122 break;
1123 case METHOD_HEADER_FAT_FORMAT:
1124 ptr += 2;
1125 ptr += 2;
1126 ptr += 4;
1127 local_var_sig_token = read32 (ptr);
1128 break;
1129 default:
1130 g_assert_not_reached ();
1131 }
1132 } else
1133 local_var_sig_token = 0; //FIXME
1134
1135 ret = (MonoReflectionMethodBody*)mono_object_new_checked (domain, mono_class_get_method_body_class (), error);
1136 if (!is_ok (error))
1137 goto fail;
1138
1139 ret->init_locals = header->init_locals;
1140 ret->max_stack = header->max_stack;
1141 ret->local_var_sig_token = local_var_sig_token;
1142 MonoArray *il_arr = mono_array_new_cached (domain, mono_defaults.byte_class, header->code_size, error);
1143 if (!is_ok (error))
1144 goto fail;
1145 MONO_OBJECT_SETREF (ret, il, il_arr);
1146 memcpy (mono_array_addr (ret->il, guint8, 0), header->code, header->code_size);
1147
1148 /* Locals */
1149 MonoArray *locals_arr = mono_array_new_cached (domain, mono_class_get_local_variable_info_class (), header->num_locals, error);
1150 if (!is_ok (error))
1151 goto fail;
1152 MONO_OBJECT_SETREF (ret, locals, locals_arr);
1153 for (i = 0; i < header->num_locals; ++i) {
1154 MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new_checked (domain, mono_class_get_local_variable_info_class (), error);
1155 if (!is_ok (error))
1156 goto fail;
1157
1158 rt = mono_type_get_object_checked (domain, header->locals [i], error);
1159 if (!is_ok (error))
1160 goto fail;
1161
1162 MONO_OBJECT_SETREF (info, local_type, rt);
1163
1164 info->is_pinned = header->locals [i]->pinned;
1165 info->local_index = i;
1166 mono_array_setref (ret->locals, i, info);
1167 }
1168
1169 /* Exceptions */
1170 MonoArray *exn_clauses = mono_array_new_cached (domain, mono_class_get_exception_handling_clause_class (), header->num_clauses, error);
1171 if (!is_ok (error))
1172 goto fail;
1173 MONO_OBJECT_SETREF (ret, clauses, exn_clauses);
1174 for (i = 0; i < header->num_clauses; ++i) {
1175 MonoReflectionExceptionHandlingClause *info = (MonoReflectionExceptionHandlingClause*)mono_object_new_checked (domain, mono_class_get_exception_handling_clause_class (), error);
1176 if (!is_ok (error))
1177 goto fail;
1178 MonoExceptionClause *clause = &header->clauses [i];
1179
1180 info->flags = clause->flags;
1181 info->try_offset = clause->try_offset;
1182 info->try_length = clause->try_len;
1183 info->handler_offset = clause->handler_offset;
1184 info->handler_length = clause->handler_len;
1185 if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER)
1186 info->filter_offset = clause->data.filter_offset;
1187 else if (clause->data.catch_class) {
1188 rt = mono_type_get_object_checked (mono_domain_get (), &clause->data.catch_class->byval_arg, error);
1189 if (!is_ok (error))
1190 goto fail;
1191
1192 MONO_OBJECT_SETREF (info, catch_type, rt);
1193 }
1194
1195 mono_array_setref (ret->clauses, i, info);
1196 }
1197
1198 mono_metadata_free_mh (header);
1199 return ret;
1200 fail:
1201 mono_metadata_free_mh (header);
1202 return NULL;
1203 }
1204
1205 /**
1206 * mono_method_body_get_object_checked:
1207 * @domain: an app domain
1208 * @method: a method
1209 * @error: set on error
1210 *
1211 * Return an System.Reflection.MethodBody object representing the
1212 * method @method. On failure, returns NULL and sets @error.
1213 */
1214 MonoReflectionMethodBody*
1215 mono_method_body_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoError *error)
1216 {
1217 mono_error_init (error);
1218 return CHECK_OR_CONSTRUCT (MonoReflectionMethodBody *, method, NULL, method_body_object_construct, NULL);
1219 }
1220
1221 /**
1222 * mono_get_dbnull_object:
1223 * @domain: Domain where the object lives
1224 *
1225 * Returns the System.DBNull.Value singleton object
1226 *
1227 * Used as the value for ParameterInfo.DefaultValue
1228 */
1229 MonoObject *
1230 mono_get_dbnull_object (MonoDomain *domain)
1231 {
1232 MonoError error;
1233 MonoObject *obj;
1234
1235 obj = get_dbnull_object (domain, &error);
1236 mono_error_assert_ok (&error);
1237 return obj;
1238 }
1239
1240 static void
1241 get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types)
1242 {
1243 guint32 param_index, i, lastp, crow = 0;
1244 guint32 param_cols [MONO_PARAM_SIZE], const_cols [MONO_CONSTANT_SIZE];
1245 gint32 idx;
1246
1247 MonoClass *klass = method->klass;
1248 MonoImage *image = klass->image;
1249 MonoMethodSignature *methodsig = mono_method_signature (method);
1250
1251 MonoTableInfo *constt;
1252 MonoTableInfo *methodt;
1253 MonoTableInfo *paramt;
1254
1255 if (!methodsig->param_count)
1256 return;
1257
1258 mono_class_init (klass);
1259
1260 if (image_is_dynamic (klass->image)) {
1261 MonoReflectionMethodAux *aux;
1262 if (method->is_inflated)
1263 method = ((MonoMethodInflated*)method)->declaring;
1264 aux = (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
1265 if (aux && aux->param_defaults) {
1266 memcpy (blobs, &(aux->param_defaults [1]), methodsig->param_count * sizeof (char*));
1267 memcpy (types, &(aux->param_default_types [1]), methodsig->param_count * sizeof (guint32));
1268 }
1269 return;
1270 }
1271
1272 methodt = &klass->image->tables [MONO_TABLE_METHOD];
1273 paramt = &klass->image->tables [MONO_TABLE_PARAM];
1274 constt = &image->tables [MONO_TABLE_CONSTANT];
1275
1276 idx = mono_method_get_index (method) - 1;
1277 g_assert (idx != -1);
1278
1279 param_index = mono_metadata_decode_row_col (methodt, idx, MONO_METHOD_PARAMLIST);
1280 if (idx + 1 < methodt->rows)
1281 lastp = mono_metadata_decode_row_col (methodt, idx + 1, MONO_METHOD_PARAMLIST);
1282 else
1283 lastp = paramt->rows + 1;
1284
1285 for (i = param_index; i < lastp; ++i) {
1286 guint32 paramseq;
1287
1288 mono_metadata_decode_row (paramt, i - 1, param_cols, MONO_PARAM_SIZE);
1289 paramseq = param_cols [MONO_PARAM_SEQUENCE];
1290
1291 if (!(param_cols [MONO_PARAM_FLAGS] & PARAM_ATTRIBUTE_HAS_DEFAULT))
1292 continue;
1293
1294 crow = mono_metadata_get_constant_index (image, MONO_TOKEN_PARAM_DEF | i, crow + 1);
1295 if (!crow) {
1296 continue;
1297 }
1298
1299 mono_metadata_decode_row (constt, crow - 1, const_cols, MONO_CONSTANT_SIZE);
1300 blobs [paramseq - 1] = (char *)mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
1301 types [paramseq - 1] = const_cols [MONO_CONSTANT_TYPE];
1302 }
1303
1304 return;
1305 }
1306
1307 MonoObject *
1308 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob, MonoError *error)
1309 {
1310 void *retval;
1311 MonoClass *klass;
1312 MonoObject *object;
1313 MonoType *basetype = type;
1314
1315 mono_error_init (error);
1316
1317 if (!blob)
1318 return NULL;
1319
1320 klass = mono_class_from_mono_type (type);
1321 if (klass->valuetype) {
1322 object = mono_object_new_checked (domain, klass, error);
1323 return_val_if_nok (error, NULL);
1324 retval = ((gchar *) object + sizeof (MonoObject));
1325 if (klass->enumtype)
1326 basetype = mono_class_enum_basetype (klass);
1327 } else {
1328 retval = &object;
1329 }
1330
1331 if (!mono_get_constant_value_from_blob (domain, basetype->type, blob, retval, error))
1332 return object;
1333 else
1334 return NULL;
1335 }
1336
1337 static int
1338 assembly_name_to_aname (MonoAssemblyName *assembly, char *p) {
1339 int found_sep;
1340 char *s;
1341 gboolean quoted = FALSE;
1342
1343 memset (assembly, 0, sizeof (MonoAssemblyName));
1344 assembly->culture = "";
1345 memset (assembly->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
1346
1347 if (*p == '"') {
1348 quoted = TRUE;
1349 p++;
1350 }
1351 assembly->name = p;
1352 while (*p && (isalnum (*p) || *p == '.' || *p == '-' || *p == '_' || *p == '$' || *p == '@' || g_ascii_isspace (*p)))
1353 p++;
1354 if (quoted) {
1355 if (*p != '"')
1356 return 1;
1357 *p = 0;
1358 p++;
1359 }
1360 if (*p != ',')
1361 return 1;
1362 *p = 0;
1363 /* Remove trailing whitespace */
1364 s = p - 1;
1365 while (*s && g_ascii_isspace (*s))
1366 *s-- = 0;
1367 p ++;
1368 while (g_ascii_isspace (*p))
1369 p++;
1370 while (*p) {
1371 if (*p == 'V' && g_ascii_strncasecmp (p, "Version=", 8) == 0) {
1372 p += 8;
1373 assembly->major = strtoul (p, &s, 10);
1374 if (s == p || *s != '.')
1375 return 1;
1376 p = ++s;
1377 assembly->minor = strtoul (p, &s, 10);
1378 if (s == p || *s != '.')
1379 return 1;
1380 p = ++s;
1381 assembly->build = strtoul (p, &s, 10);
1382 if (s == p || *s != '.')
1383 return 1;
1384 p = ++s;
1385 assembly->revision = strtoul (p, &s, 10);
1386 if (s == p)
1387 return 1;
1388 p = s;
1389 } else if (*p == 'C' && g_ascii_strncasecmp (p, "Culture=", 8) == 0) {
1390 p += 8;
1391 if (g_ascii_strncasecmp (p, "neutral", 7) == 0) {
1392 assembly->culture = "";
1393 p += 7;
1394 } else {
1395 assembly->culture = p;
1396 while (*p && *p != ',') {
1397 p++;
1398 }
1399 }
1400 } else if (*p == 'P' && g_ascii_strncasecmp (p, "PublicKeyToken=", 15) == 0) {
1401 p += 15;
1402 if (strncmp (p, "null", 4) == 0) {
1403 p += 4;
1404 } else {
1405 int len;
1406 gchar *start = p;
1407 while (*p && *p != ',') {
1408 p++;
1409 }
1410 len = (p - start + 1);
1411 if (len > MONO_PUBLIC_KEY_TOKEN_LENGTH)
1412 len = MONO_PUBLIC_KEY_TOKEN_LENGTH;
1413 g_strlcpy ((char*)assembly->public_key_token, start, len);
1414 }
1415 } else {
1416 while (*p && *p != ',')
1417 p++;
1418 }
1419 found_sep = 0;
1420 while (g_ascii_isspace (*p) || *p == ',') {
1421 *p++ = 0;
1422 found_sep = 1;
1423 continue;
1424 }
1425 /* failed */
1426 if (!found_sep)
1427 return 1;
1428 }
1429
1430 return 0;
1431 }
1432
1433 /*
1434 * mono_reflection_parse_type:
1435 * @name: type name
1436 *
1437 * Parse a type name as accepted by the GetType () method and output the info
1438 * extracted in the info structure.
1439 * the name param will be mangled, so, make a copy before passing it to this function.
1440 * The fields in info will be valid until the memory pointed to by name is valid.
1441 *
1442 * See also mono_type_get_name () below.
1443 *
1444 * Returns: 0 on parse error.
1445 */
1446 static int
1447 _mono_reflection_parse_type (char *name, char **endptr, gboolean is_recursed,
1448 MonoTypeNameParse *info)
1449 {
1450 char *start, *p, *w, *last_point, *startn;
1451 int in_modifiers = 0;
1452 int isbyref = 0, rank = 0, isptr = 0;
1453
1454 start = p = w = name;
1455
1456 //FIXME could we just zero the whole struct? memset (&info, 0, sizeof (MonoTypeNameParse))
1457 memset (&info->assembly, 0, sizeof (MonoAssemblyName));
1458 info->name = info->name_space = NULL;
1459 info->nested = NULL;
1460 info->modifiers = NULL;
1461 info->type_arguments = NULL;
1462
1463 /* last_point separates the namespace from the name */
1464 last_point = NULL;
1465 /* Skips spaces */
1466 while (*p == ' ') p++, start++, w++, name++;
1467
1468 while (*p) {
1469 switch (*p) {
1470 case '+':
1471 *p = 0; /* NULL terminate the name */
1472 startn = p + 1;
1473 info->nested = g_list_append (info->nested, startn);
1474 /* we have parsed the nesting namespace + name */
1475 if (info->name)
1476 break;
1477 if (last_point) {
1478 info->name_space = start;
1479 *last_point = 0;
1480 info->name = last_point + 1;
1481 } else {
1482 info->name_space = (char *)"";
1483 info->name = start;
1484 }
1485 break;
1486 case '.':
1487 last_point = p;
1488 break;
1489 case '\\':
1490 ++p;
1491 break;
1492 case '&':
1493 case '*':
1494 case '[':
1495 case ',':
1496 case ']':
1497 in_modifiers = 1;
1498 break;
1499 default:
1500 break;
1501 }
1502 if (in_modifiers)
1503 break;
1504 // *w++ = *p++;
1505 p++;
1506 }
1507
1508 if (!info->name) {
1509 if (last_point) {
1510 info->name_space = start;
1511 *last_point = 0;
1512 info->name = last_point + 1;
1513 } else {
1514 info->name_space = (char *)"";
1515 info->name = start;
1516 }
1517 }
1518 while (*p) {
1519 switch (*p) {
1520 case '&':
1521 if (isbyref) /* only one level allowed by the spec */
1522 return 0;
1523 isbyref = 1;
1524 isptr = 0;
1525 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (0));
1526 *p++ = 0;
1527 break;
1528 case '*':
1529 if (isbyref) /* pointer to ref not okay */
1530 return 0;
1531 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-1));
1532 isptr = 1;
1533 *p++ = 0;
1534 break;
1535 case '[':
1536 if (isbyref) /* array of ref and generic ref are not okay */
1537 return 0;
1538 //Decide if it's an array of a generic argument list
1539 *p++ = 0;
1540
1541 if (!*p) //XXX test
1542 return 0;
1543 if (*p == ',' || *p == '*' || *p == ']') { //array
1544 isptr = 0;
1545 rank = 1;
1546 while (*p) {
1547 if (*p == ']')
1548 break;
1549 if (*p == ',')
1550 rank++;
1551 else if (*p == '*') /* '*' means unknown lower bound */
1552 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-2));
1553 else
1554 return 0;
1555 ++p;
1556 }
1557 if (*p++ != ']')
1558 return 0;
1559 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (rank));
1560 } else {
1561 if (rank || isptr) /* generic args after array spec or ptr*/ //XXX test
1562 return 0;
1563 isptr = 0;
1564 info->type_arguments = g_ptr_array_new ();
1565 while (*p) {
1566 MonoTypeNameParse *subinfo = g_new0 (MonoTypeNameParse, 1);
1567 gboolean fqname = FALSE;
1568
1569 g_ptr_array_add (info->type_arguments, subinfo);
1570
1571 while (*p == ' ') p++;
1572 if (*p == '[') {
1573 p++;
1574 fqname = TRUE;
1575 }
1576
1577 if (!_mono_reflection_parse_type (p, &p, TRUE, subinfo))
1578 return 0;
1579
1580 /*MS is lenient on [] delimited parameters that aren't fqn - and F# uses them.*/
1581 if (fqname && (*p != ']')) {
1582 char *aname;
1583
1584 if (*p != ',')
1585 return 0;
1586 *p++ = 0;
1587
1588 aname = p;
1589 while (*p && (*p != ']'))
1590 p++;
1591
1592 if (*p != ']')
1593 return 0;
1594
1595 *p++ = 0;
1596 while (*aname) {
1597 if (g_ascii_isspace (*aname)) {
1598 ++aname;
1599 continue;
1600 }
1601 break;
1602 }
1603 if (!*aname ||
1604 !assembly_name_to_aname (&subinfo->assembly, aname))
1605 return 0;
1606 } else if (fqname && (*p == ']')) {
1607 *p++ = 0;
1608 }
1609 if (*p == ']') {
1610 *p++ = 0;
1611 break;
1612 } else if (!*p) {
1613 return 0;
1614 }
1615 *p++ = 0;
1616 }
1617 }
1618 break;
1619 case ']':
1620 if (is_recursed)
1621 goto end;
1622 return 0;
1623 case ',':
1624 if (is_recursed)
1625 goto end;
1626 *p++ = 0;
1627 while (*p) {
1628 if (g_ascii_isspace (*p)) {
1629 ++p;
1630 continue;
1631 }
1632 break;
1633 }
1634 if (!*p)
1635 return 0; /* missing assembly name */
1636 if (!assembly_name_to_aname (&info->assembly, p))
1637 return 0;
1638 break;
1639 default:
1640 return 0;
1641 }
1642 if (info->assembly.name)
1643 break;
1644 }
1645 // *w = 0; /* terminate class name */
1646 end:
1647 if (!info->name || !*info->name)
1648 return 0;
1649 if (endptr)
1650 *endptr = p;
1651 /* add other consistency checks */
1652 return 1;
1653 }
1654
1655
1656 /**
1657 * mono_identifier_unescape_type_name_chars:
1658 * @identifier: the display name of a mono type
1659 *
1660 * Returns:
1661 * The name in internal form, that is without escaping backslashes.
1662 *
1663 * The string is modified in place!
1664 */
1665 char*
1666 mono_identifier_unescape_type_name_chars(char* identifier)
1667 {
1668 char *w, *r;
1669 if (!identifier)
1670 return NULL;
1671 for (w = r = identifier; *r != 0; r++)
1672 {
1673 char c = *r;
1674 if (c == '\\') {
1675 r++;
1676 if (*r == 0)
1677 break;
1678 c = *r;
1679 }
1680 *w = c;
1681 w++;
1682 }
1683 if (w != r)
1684 *w = 0;
1685 return identifier;
1686 }
1687
1688 void
1689 mono_identifier_unescape_info (MonoTypeNameParse* info);
1690
1691 static void
1692 unescape_each_type_argument(void* data, void* user_data)
1693 {
1694 MonoTypeNameParse* info = (MonoTypeNameParse*)data;
1695 mono_identifier_unescape_info (info);
1696 }
1697
1698 static void
1699 unescape_each_nested_name (void* data, void* user_data)
1700 {
1701 char* nested_name = (char*) data;
1702 mono_identifier_unescape_type_name_chars(nested_name);
1703 }
1704
1705 /**
1706 * mono_identifier_unescape_info:
1707 *
1708 * @info: a parsed display form of an (optionally assembly qualified) full type name.
1709 *
1710 * Returns: nothing.
1711 *
1712 * Destructively updates the info by unescaping the identifiers that
1713 * comprise the type namespace, name, nested types (if any) and
1714 * generic type arguments (if any).
1715 *
1716 * The resulting info has the names in internal form.
1717 *
1718 */
1719 void
1720 mono_identifier_unescape_info (MonoTypeNameParse *info)
1721 {
1722 if (!info)
1723 return;
1724 mono_identifier_unescape_type_name_chars(info->name_space);
1725 mono_identifier_unescape_type_name_chars(info->name);
1726 // but don't escape info->assembly
1727 if (info->type_arguments)
1728 g_ptr_array_foreach(info->type_arguments, &unescape_each_type_argument, NULL);
1729 if (info->nested)
1730 g_list_foreach(info->nested, &unescape_each_nested_name, NULL);
1731 }
1732
1733 int
1734 mono_reflection_parse_type (char *name, MonoTypeNameParse *info)
1735 {
1736 int ok = _mono_reflection_parse_type (name, NULL, FALSE, info);
1737 if (ok) {
1738 mono_identifier_unescape_info (info);
1739 }
1740 return ok;
1741 }
1742
1743 static MonoType*
1744 _mono_reflection_get_type_from_info (MonoTypeNameParse *info, MonoImage *image, gboolean ignorecase, MonoError *error)
1745 {
1746 gboolean type_resolve = FALSE;
1747 MonoType *type;
1748 MonoImage *rootimage = image;
1749
1750 mono_error_init (error);
1751
1752 if (info->assembly.name) {
1753 MonoAssembly *assembly = mono_assembly_loaded (&info->assembly);
1754 if (!assembly && image && image->assembly && mono_assembly_names_equal (&info->assembly, &image->assembly->aname))
1755 /*
1756 * This could happen in the AOT compiler case when the search hook is not
1757 * installed.
1758 */
1759 assembly = image->assembly;
1760 if (!assembly) {
1761 /* then we must load the assembly ourselve - see #60439 */
1762 assembly = mono_assembly_load (&info->assembly, image->assembly->basedir, NULL);
1763 if (!assembly)
1764 return NULL;
1765 }
1766 image = assembly->image;
1767 } else if (!image) {
1768 image = mono_defaults.corlib;
1769 }
1770
1771 type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
1772 if (type == NULL && !info->assembly.name && image != mono_defaults.corlib) {
1773 /* ignore the error and try again */
1774 mono_error_cleanup (error);
1775 mono_error_init (error);
1776 image = mono_defaults.corlib;
1777 type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
1778 }
1779
1780 return type;
1781 }
1782
1783 /**
1784 * mono_reflection_get_type_internal:
1785 *
1786 * Returns: may return NULL on success, sets error on failure.
1787 */
1788 static MonoType*
1789 mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
1790 {
1791 MonoClass *klass;
1792 GList *mod;
1793 int modval;
1794 gboolean bounded = FALSE;
1795
1796 mono_error_init (error);
1797 if (!image)
1798 image = mono_defaults.corlib;
1799
1800 if (!rootimage)
1801 rootimage = mono_defaults.corlib;
1802
1803 if (ignorecase)
1804 klass = mono_class_from_name_case_checked (image, info->name_space, info->name, error);
1805 else
1806 klass = mono_class_from_name_checked (image, info->name_space, info->name, error);
1807
1808 if (!klass)
1809 return NULL;
1810
1811 for (mod = info->nested; mod; mod = mod->next) {
1812 gpointer iter = NULL;
1813 MonoClass *parent;
1814
1815 parent = klass;
1816 mono_class_init (parent);
1817
1818 while ((klass = mono_class_get_nested_types (parent, &iter))) {
1819 char *lastp;
1820 char *nested_name, *nested_nspace;
1821 gboolean match = TRUE;
1822
1823 lastp = strrchr ((const char *)mod->data, '.');
1824 if (lastp) {
1825 /* Nested classes can have namespaces */
1826 int nspace_len;
1827
1828 nested_name = g_strdup (lastp + 1);
1829 nspace_len = lastp - (char*)mod->data;
1830 nested_nspace = (char *)g_malloc (nspace_len + 1);
1831 memcpy (nested_nspace, mod->data, nspace_len);
1832 nested_nspace [nspace_len] = '\0';
1833
1834 } else {
1835 nested_name = (char *)mod->data;
1836 nested_nspace = NULL;
1837 }
1838
1839 if (nested_nspace) {
1840 if (ignorecase) {
1841 if (!(klass->name_space && mono_utf8_strcasecmp (klass->name_space, nested_nspace) == 0))
1842 match = FALSE;
1843 } else {
1844 if (!(klass->name_space && strcmp (klass->name_space, nested_nspace) == 0))
1845 match = FALSE;
1846 }
1847 }
1848 if (match) {
1849 if (ignorecase) {
1850 if (mono_utf8_strcasecmp (klass->name, nested_name) != 0)
1851 match = FALSE;
1852 } else {
1853 if (strcmp (klass->name, nested_name) != 0)
1854 match = FALSE;
1855 }
1856 }
1857 if (lastp) {
1858 g_free (nested_name);
1859 g_free (nested_nspace);
1860 }
1861 if (match)
1862 break;
1863 }
1864
1865 if (!klass)
1866 break;
1867 }
1868 if (!klass)
1869 return NULL;
1870
1871 if (info->type_arguments) {
1872 MonoType **type_args = g_new0 (MonoType *, info->type_arguments->len);
1873 MonoReflectionType *the_type;
1874 MonoType *instance;
1875 int i;
1876
1877 for (i = 0; i < info->type_arguments->len; i++) {
1878 MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
1879
1880 type_args [i] = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase, error);
1881 if (!type_args [i]) {
1882 g_free (type_args);
1883 return NULL;
1884 }
1885 }
1886
1887 the_type = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, error);
1888 if (!the_type)
1889 return NULL;
1890
1891 instance = mono_reflection_bind_generic_parameters (
1892 the_type, info->type_arguments->len, type_args, error);
1893
1894 g_free (type_args);
1895 if (!instance)
1896 return NULL;
1897
1898 klass = mono_class_from_mono_type (instance);
1899 }
1900
1901 for (mod = info->modifiers; mod; mod = mod->next) {
1902 modval = GPOINTER_TO_UINT (mod->data);
1903 if (!modval) { /* byref: must be last modifier */
1904 return &klass->this_arg;
1905 } else if (modval == -1) {
1906 klass = mono_ptr_class_get (&klass->byval_arg);
1907 } else if (modval == -2) {
1908 bounded = TRUE;
1909 } else { /* array rank */
1910 klass = mono_bounded_array_class_get (klass, modval, bounded);
1911 }
1912 }
1913
1914 return &klass->byval_arg;
1915 }
1916
1917 /*
1918 * mono_reflection_get_type:
1919 * @image: a metadata context
1920 * @info: type description structure
1921 * @ignorecase: flag for case-insensitive string compares
1922 * @type_resolve: whenever type resolve was already tried
1923 *
1924 * Build a MonoType from the type description in @info.
1925 *
1926 */
1927
1928 MonoType*
1929 mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve) {
1930 MonoError error;
1931 MonoType *result = mono_reflection_get_type_with_rootimage (image, image, info, ignorecase, type_resolve, &error);
1932 mono_error_cleanup (&error);
1933 return result;
1934 }
1935
1936 /**
1937 * mono_reflection_get_type_checked:
1938 * @rootimage: the image of the currently active managed caller
1939 * @image: a metadata context
1940 * @info: type description structure
1941 * @ignorecase: flag for case-insensitive string compares
1942 * @type_resolve: whenever type resolve was already tried
1943 * @error: set on error.
1944 *
1945 * Build a MonoType from the type description in @info. On failure returns NULL and sets @error.
1946 *
1947 */
1948 MonoType*
1949 mono_reflection_get_type_checked (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error) {
1950 mono_error_init (error);
1951 return mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, type_resolve, error);
1952 }
1953
1954
1955 static MonoType*
1956 module_builder_array_get_type (MonoArrayHandle module_builders, int i, MonoImage *rootimage, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
1957 {
1958 HANDLE_FUNCTION_ENTER ();
1959 mono_error_init (error);
1960 MonoType *type = NULL;
1961 MonoReflectionModuleBuilderHandle mb = MONO_HANDLE_NEW (MonoReflectionModuleBuilder, NULL);
1962 MONO_HANDLE_ARRAY_GETREF (mb, module_builders, i);
1963 MonoDynamicImage *dynamic_image = MONO_HANDLE_GETVAL (mb, dynamic_image);
1964 type = mono_reflection_get_type_internal (rootimage, &dynamic_image->image, info, ignorecase, error);
1965 HANDLE_FUNCTION_RETURN_VAL (type);
1966 }
1967
1968 static MonoType*
1969 module_array_get_type (MonoArrayHandle modules, int i, MonoImage *rootimage, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
1970 {
1971 HANDLE_FUNCTION_ENTER ();
1972 mono_error_init (error);
1973 MonoType *type = NULL;
1974 MonoReflectionModuleHandle mod = MONO_HANDLE_NEW (MonoReflectionModule, NULL);
1975 MONO_HANDLE_ARRAY_GETREF (mod, modules, i);
1976 MonoImage *image = MONO_HANDLE_GETVAL (mod, image);
1977 type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase, error);
1978 HANDLE_FUNCTION_RETURN_VAL (type);
1979 }
1980
1981 static MonoType*
1982 mono_reflection_get_type_internal_dynamic (MonoImage *rootimage, MonoAssembly *assembly, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
1983 {
1984 HANDLE_FUNCTION_ENTER ();
1985 MonoType *type = NULL;
1986 int i;
1987
1988 mono_error_init (error);
1989 g_assert (assembly_is_dynamic (assembly));
1990 MonoReflectionAssemblyBuilderHandle abuilder = MONO_HANDLE_CAST (MonoReflectionAssemblyBuilder, mono_assembly_get_object_handle (((MonoDynamicAssembly*)assembly)->domain, assembly, error));
1991 if (!is_ok (error))
1992 goto leave;
1993
1994 /* Enumerate all modules */
1995
1996 MonoArrayHandle modules = MONO_HANDLE_NEW (MonoArray, NULL);
1997 MONO_HANDLE_GET (modules, abuilder, modules);
1998 if (!MONO_HANDLE_IS_NULL (modules)) {
1999 int n = mono_array_handle_length (modules);
2000 for (i = 0; i < n; ++i) {
2001 type = module_builder_array_get_type (modules, i, rootimage, info, ignorecase, error);
2002 if (type)
2003 break;
2004 if (!is_ok (error))
2005 goto leave;
2006 }
2007 }
2008
2009 MonoArrayHandle loaded_modules = MONO_HANDLE_NEW (MonoArray, NULL);
2010 MONO_HANDLE_GET (loaded_modules, abuilder, loaded_modules);
2011 if (!type && !MONO_HANDLE_IS_NULL(loaded_modules)) {
2012 int n = mono_array_handle_length (loaded_modules);
2013 for (i = 0; i < n; ++i) {
2014 type = module_array_get_type (loaded_modules, i, rootimage, info, ignorecase, error);
2015 if (type)
2016 break;
2017 if (!is_ok (error))
2018 goto leave;
2019 }
2020 }
2021
2022 leave:
2023 HANDLE_FUNCTION_RETURN_VAL (type);
2024 }
2025
2026 MonoType*
2027 mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error)
2028 {
2029 MonoType *type;
2030 MonoReflectionAssembly *assembly;
2031 GString *fullName;
2032 GList *mod;
2033
2034 mono_error_init (error);
2035
2036 if (image && image_is_dynamic (image))
2037 type = mono_reflection_get_type_internal_dynamic (rootimage, image->assembly, info, ignorecase, error);
2038 else {
2039 type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase, error);
2040 }
2041 return_val_if_nok (error, NULL);
2042
2043 if (type)
2044 return type;
2045 if (!mono_domain_has_type_resolve (mono_domain_get ()))
2046 return NULL;
2047
2048 if (type_resolve) {
2049 if (*type_resolve)
2050 return NULL;
2051 else
2052 *type_resolve = TRUE;
2053 }
2054
2055 /* Reconstruct the type name */
2056 fullName = g_string_new ("");
2057 if (info->name_space && (info->name_space [0] != '\0'))
2058 g_string_printf (fullName, "%s.%s", info->name_space, info->name);
2059 else
2060 g_string_printf (fullName, "%s", info->name);
2061 for (mod = info->nested; mod; mod = mod->next)
2062 g_string_append_printf (fullName, "+%s", (char*)mod->data);
2063
2064 assembly = mono_domain_try_type_resolve_checked ( mono_domain_get (), fullName->str, NULL, error);
2065 if (!is_ok (error)) {
2066 g_string_free (fullName, TRUE);
2067 return NULL;
2068 }
2069
2070 if (assembly) {
2071 if (assembly_is_dynamic (assembly->assembly))
2072 type = mono_reflection_get_type_internal_dynamic (rootimage, assembly->assembly,
2073 info, ignorecase, error);
2074 else
2075 type = mono_reflection_get_type_internal (rootimage, assembly->assembly->image,
2076 info, ignorecase, error);
2077 }
2078 g_string_free (fullName, TRUE);
2079 return_val_if_nok (error, NULL);
2080 return type;
2081 }
2082
2083 void
2084 mono_reflection_free_type_info (MonoTypeNameParse *info)
2085 {
2086 g_list_free (info->modifiers);
2087 g_list_free (info->nested);
2088
2089 if (info->type_arguments) {
2090 int i;
2091
2092 for (i = 0; i < info->type_arguments->len; i++) {
2093 MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
2094
2095 mono_reflection_free_type_info (subinfo);
2096 /*We free the subinfo since it is allocated by _mono_reflection_parse_type*/
2097 g_free (subinfo);
2098 }
2099
2100 g_ptr_array_free (info->type_arguments, TRUE);
2101 }
2102 }
2103
2104 /*
2105 * mono_reflection_type_from_name:
2106 * @name: type name.
2107 * @image: a metadata context (can be NULL).
2108 *
2109 * Retrieves a MonoType from its @name. If the name is not fully qualified,
2110 * it defaults to get the type from @image or, if @image is NULL or loading
2111 * from it fails, uses corlib.
2112 *
2113 */
2114 MonoType*
2115 mono_reflection_type_from_name (char *name, MonoImage *image)
2116 {
2117 MonoError error;
2118 MonoType *result = mono_reflection_type_from_name_checked (name, image, &error);
2119 mono_error_cleanup (&error);
2120 return result;
2121 }
2122
2123 /**
2124 * mono_reflection_type_from_name_checked:
2125 * @name: type name.
2126 * @image: a metadata context (can be NULL).
2127 * @error: set on errror.
2128 *
2129 * Retrieves a MonoType from its @name. If the name is not fully qualified,
2130 * it defaults to get the type from @image or, if @image is NULL or loading
2131 * from it fails, uses corlib. On failure returns NULL and sets @error.
2132 *
2133 */
2134 MonoType*
2135 mono_reflection_type_from_name_checked (char *name, MonoImage *image, MonoError *error)
2136 {
2137 MonoType *type = NULL;
2138 MonoTypeNameParse info;
2139 char *tmp;
2140
2141 mono_error_init (error);
2142 /* Make a copy since parse_type modifies its argument */
2143 tmp = g_strdup (name);
2144
2145 /*g_print ("requested type %s\n", str);*/
2146 if (mono_reflection_parse_type (tmp, &info)) {
2147 type = _mono_reflection_get_type_from_info (&info, image, FALSE, error);
2148 if (!is_ok (error)) {
2149 g_free (tmp);
2150 mono_reflection_free_type_info (&info);
2151 return NULL;
2152 }
2153 }
2154
2155 g_free (tmp);
2156 mono_reflection_free_type_info (&info);
2157 return type;
2158 }
2159
2160 /*
2161 * mono_reflection_get_token:
2162 *
2163 * Return the metadata token of OBJ which should be an object
2164 * representing a metadata element.
2165 */
2166 guint32
2167 mono_reflection_get_token (MonoObject *obj)
2168 {
2169 MonoError error;
2170 guint32 result = mono_reflection_get_token_checked (obj, &error);
2171 mono_error_assert_ok (&error);
2172 return result;
2173 }
2174
2175 /**
2176 * mono_reflection_get_token_checked:
2177 * @obj: the object
2178 * @error: set on error
2179 *
2180 * Return the metadata token of @obj which should be an object
2181 * representing a metadata element. On failure sets @error.
2182 */
2183 guint32
2184 mono_reflection_get_token_checked (MonoObject *obj, MonoError *error)
2185 {
2186 MonoClass *klass;
2187 guint32 token = 0;
2188
2189 mono_error_init (error);
2190
2191 klass = obj->vtable->klass;
2192
2193 if (strcmp (klass->name, "MethodBuilder") == 0) {
2194 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
2195
2196 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
2197 } else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
2198 MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
2199
2200 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
2201 } else if (strcmp (klass->name, "FieldBuilder") == 0) {
2202 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
2203
2204 token = fb->table_idx | MONO_TOKEN_FIELD_DEF;
2205 } else if (strcmp (klass->name, "TypeBuilder") == 0) {
2206 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
2207 token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
2208 } else if (strcmp (klass->name, "RuntimeType") == 0) {
2209 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error);
2210 return_val_if_nok (error, 0);
2211 MonoClass *mc = mono_class_from_mono_type (type);
2212 if (!mono_class_init (mc)) {
2213 mono_error_set_for_class_failure (error, mc);
2214 return 0;
2215 }
2216
2217 token = mc->type_token;
2218 } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
2219 strcmp (klass->name, "MonoMethod") == 0) {
2220 MonoReflectionMethod *m = (MonoReflectionMethod *)obj;
2221 if (m->method->is_inflated) {
2222 MonoMethodInflated *inflated = (MonoMethodInflated *) m->method;
2223 return inflated->declaring->token;
2224 } else {
2225 token = m->method->token;
2226 }
2227 } else if (strcmp (klass->name, "MonoField") == 0) {
2228 MonoReflectionField *f = (MonoReflectionField*)obj;
2229
2230 token = mono_class_get_field_token (f->field);
2231 } else if (strcmp (klass->name, "MonoProperty") == 0) {
2232 MonoReflectionProperty *p = (MonoReflectionProperty*)obj;
2233
2234 token = mono_class_get_property_token (p->property);
2235 } else if (strcmp (klass->name, "MonoEvent") == 0) {
2236 MonoReflectionMonoEvent *p = (MonoReflectionMonoEvent*)obj;
2237
2238 token = mono_class_get_event_token (p->event);
2239 } else if (strcmp (klass->name, "ParameterInfo") == 0 || strcmp (klass->name, "MonoParameterInfo") == 0) {
2240 MonoReflectionParameter *p = (MonoReflectionParameter*)obj;
2241 MonoClass *member_class = mono_object_class (p->MemberImpl);
2242 g_assert (mono_class_is_reflection_method_or_constructor (member_class));
2243
2244 token = mono_method_get_param_token (((MonoReflectionMethod*)p->MemberImpl)->method, p->PositionImpl);
2245 } else if (strcmp (klass->name, "Module") == 0 || strcmp (klass->name, "MonoModule") == 0) {
2246 MonoReflectionModule *m = (MonoReflectionModule*)obj;
2247
2248 token = m->token;
2249 } else if (strcmp (klass->name, "Assembly") == 0 || strcmp (klass->name, "MonoAssembly") == 0) {
2250 token = mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1);
2251 } else {
2252 mono_error_set_not_implemented (error, "MetadataToken is not supported for type '%s.%s'",
2253 klass->name_space, klass->name);
2254 return 0;
2255 }
2256
2257 return token;
2258 }
2259
2260
2261 gboolean
2262 mono_reflection_is_usertype (MonoReflectionType *ref)
2263 {
2264 MonoClass *klass = mono_object_class (ref);
2265 return klass->image != mono_defaults.corlib || strcmp ("TypeDelegator", klass->name) == 0;
2266 }
2267
2268 /**
2269 * mono_reflection_bind_generic_parameters:
2270 * @type: a managed type object (which should be some kind of generic (instance? definition?))
2271 * @type_args: the number of type arguments to bind
2272 * @types: array of type arguments
2273 * @error: set on error
2274 *
2275 * Given a managed type object for a generic type instance, binds each of its arguments to the specified types.
2276 * Returns the MonoType* for the resulting type instantiation. On failure returns NULL and sets @error.
2277 */
2278 MonoType*
2279 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types, MonoError *error)
2280 {
2281 MonoClass *klass;
2282 gboolean is_dynamic = FALSE;
2283 MonoClass *geninst;
2284
2285 mono_error_init (error);
2286
2287 mono_loader_lock ();
2288
2289 if (mono_is_sre_type_builder (mono_object_class (type))) {
2290 is_dynamic = TRUE;
2291 } else if (mono_is_sre_generic_instance (mono_object_class (type))) {
2292 /* Does this ever make sense? what does instantiating a generic instance even mean? */
2293 g_assert_not_reached ();
2294 MonoReflectionGenericClass *rgi = (MonoReflectionGenericClass *) type;
2295 MonoReflectionType *gtd = rgi->generic_type;
2296
2297 if (mono_is_sre_type_builder (mono_object_class (gtd)))
2298 is_dynamic = TRUE;
2299 }
2300
2301 MonoType *t = mono_reflection_type_get_handle (type, error);
2302 if (!is_ok (error)) {
2303 mono_loader_unlock ();
2304 return NULL;
2305 }
2306
2307 klass = mono_class_from_mono_type (t);
2308 if (!mono_class_is_gtd (klass)) {
2309 mono_loader_unlock ();
2310 mono_error_set_type_load_class (error, klass, "Cannot bind generic parameters of a non-generic type");
2311 return NULL;
2312 }
2313
2314 guint gtd_type_argc = mono_class_get_generic_container (klass)->type_argc;
2315 if (gtd_type_argc != type_argc) {
2316 mono_loader_unlock ();
2317 mono_error_set_argument (error, "types", "The generic type definition needs %d type arguments, but was instantiated with %d ", gtd_type_argc, type_argc);
2318 return NULL;
2319 }
2320
2321
2322 if (klass->wastypebuilder)
2323 is_dynamic = TRUE;
2324
2325 mono_loader_unlock ();
2326
2327 geninst = mono_class_bind_generic_parameters (klass, type_argc, types, is_dynamic);
2328
2329 return &geninst->byval_arg;
2330 }
2331
2332 MonoClass*
2333 mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic)
2334 {
2335 MonoGenericClass *gclass;
2336 MonoGenericInst *inst;
2337
2338 g_assert (mono_class_is_gtd (klass));
2339
2340 inst = mono_metadata_get_generic_inst (type_argc, types);
2341 gclass = mono_metadata_lookup_generic_class (klass, inst, is_dynamic);
2342
2343 return mono_generic_class_get_class (gclass);
2344 }
2345
2346 static MonoReflectionMethod*
2347 reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types, MonoError *error)
2348 {
2349 MonoClass *klass;
2350 MonoMethod *method, *inflated;
2351 MonoMethodInflated *imethod;
2352 MonoGenericContext tmp_context;
2353 MonoGenericInst *ginst;
2354 MonoType **type_argv;
2355 int count, i;
2356
2357 mono_error_init (error);
2358
2359 g_assert (strcmp (rmethod->object.vtable->klass->name, "MethodBuilder"));
2360
2361 method = rmethod->method;
2362
2363 klass = method->klass;
2364
2365 if (method->is_inflated)
2366 method = ((MonoMethodInflated *) method)->declaring;
2367
2368 count = mono_method_signature (method)->generic_param_count;
2369 if (count != mono_array_length (types))
2370 return NULL;
2371
2372 type_argv = g_new0 (MonoType *, count);
2373 for (i = 0; i < count; i++) {
2374 MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (types, gpointer, i);
2375 type_argv [i] = mono_reflection_type_get_handle (garg, error);
2376 if (!is_ok (error)) {
2377 g_free (type_argv);
2378 return NULL;
2379 }
2380 }
2381 ginst = mono_metadata_get_generic_inst (count, type_argv);
2382 g_free (type_argv);
2383
2384 tmp_context.class_inst = mono_class_is_ginst (klass) ? mono_class_get_generic_class (klass)->context.class_inst : NULL;
2385 tmp_context.method_inst = ginst;
2386
2387 inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, error);
2388 mono_error_assert_ok (error);
2389 imethod = (MonoMethodInflated *) inflated;
2390
2391 /*FIXME but I think this is no longer necessary*/
2392 if (image_is_dynamic (method->klass->image)) {
2393 MonoDynamicImage *image = (MonoDynamicImage*)method->klass->image;
2394 /*
2395 * This table maps metadata structures representing inflated methods/fields
2396 * to the reflection objects representing their generic definitions.
2397 */
2398 mono_image_lock ((MonoImage*)image);
2399 mono_g_hash_table_insert (image->generic_def_objects, imethod, rmethod);
2400 mono_image_unlock ((MonoImage*)image);
2401 }
2402
2403 if (!mono_verifier_is_method_valid_generic_instantiation (inflated)) {
2404 mono_error_set_argument (error, "typeArguments", "Invalid generic arguments");
2405 return NULL;
2406 }
2407
2408 return mono_method_get_object_checked (mono_object_domain (rmethod), inflated, NULL, error);
2409 }
2410
2411 MonoReflectionMethod*
2412 ves_icall_MonoMethod_MakeGenericMethod_impl (MonoReflectionMethod *rmethod, MonoArray *types)
2413 {
2414 MonoError error;
2415 MonoReflectionMethod *result = reflection_bind_generic_method_parameters (rmethod, types, &error);
2416 mono_error_set_pending_exception (&error);
2417 return result;
2418 }
2419
2420
2421 /* SECURITY_ACTION_* are defined in mono/metadata/tabledefs.h */
2422 const static guint32 declsec_flags_map[] = {
2423 0x00000000, /* empty */
2424 MONO_DECLSEC_FLAG_REQUEST, /* SECURITY_ACTION_REQUEST (x01) */
2425 MONO_DECLSEC_FLAG_DEMAND, /* SECURITY_ACTION_DEMAND (x02) */
2426 MONO_DECLSEC_FLAG_ASSERT, /* SECURITY_ACTION_ASSERT (x03) */
2427 MONO_DECLSEC_FLAG_DENY, /* SECURITY_ACTION_DENY (x04) */
2428 MONO_DECLSEC_FLAG_PERMITONLY, /* SECURITY_ACTION_PERMITONLY (x05) */
2429 MONO_DECLSEC_FLAG_LINKDEMAND, /* SECURITY_ACTION_LINKDEMAND (x06) */
2430 MONO_DECLSEC_FLAG_INHERITANCEDEMAND, /* SECURITY_ACTION_INHERITANCEDEMAND (x07) */
2431 MONO_DECLSEC_FLAG_REQUEST_MINIMUM, /* SECURITY_ACTION_REQUEST_MINIMUM (x08) */
2432 MONO_DECLSEC_FLAG_REQUEST_OPTIONAL, /* SECURITY_ACTION_REQUEST_OPTIONAL (x09) */
2433 MONO_DECLSEC_FLAG_REQUEST_REFUSE, /* SECURITY_ACTION_REQUEST_REFUSE (x0A) */
2434 MONO_DECLSEC_FLAG_PREJIT_GRANT, /* SECURITY_ACTION_PREJIT_GRANT (x0B) */
2435 MONO_DECLSEC_FLAG_PREJIT_DENY, /* SECURITY_ACTION_PREJIT_DENY (x0C) */
2436 MONO_DECLSEC_FLAG_NONCAS_DEMAND, /* SECURITY_ACTION_NONCAS_DEMAND (x0D) */
2437 MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND, /* SECURITY_ACTION_NONCAS_LINKDEMAND (x0E) */
2438 MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND, /* SECURITY_ACTION_NONCAS_INHERITANCEDEMAND (x0F) */
2439 MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE, /* SECURITY_ACTION_LINKDEMAND_CHOICE (x10) */
2440 MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE, /* SECURITY_ACTION_INHERITANCEDEMAND_CHOICE (x11) */
2441 MONO_DECLSEC_FLAG_DEMAND_CHOICE, /* SECURITY_ACTION_DEMAND_CHOICE (x12) */
2442 };
2443
2444 /*
2445 * Returns flags that includes all available security action associated to the handle.
2446 * @token: metadata token (either for a class or a method)
2447 * @image: image where resides the metadata.
2448 */
2449 static guint32
2450 mono_declsec_get_flags (MonoImage *image, guint32 token)
2451 {
2452 int index = mono_metadata_declsec_from_index (image, token);
2453 MonoTableInfo *t = &image->tables [MONO_TABLE_DECLSECURITY];
2454 guint32 result = 0;
2455 guint32 action;
2456 int i;
2457
2458 /* HasSecurity can be present for other, not specially encoded, attributes,
2459 e.g. SuppressUnmanagedCodeSecurityAttribute */
2460 if (index < 0)
2461 return 0;
2462
2463 for (i = index; i < t->rows; i++) {
2464 guint32 cols [MONO_DECL_SECURITY_SIZE];
2465
2466 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
2467 if (cols [MONO_DECL_SECURITY_PARENT] != token)
2468 break;
2469
2470 action = cols [MONO_DECL_SECURITY_ACTION];
2471 if ((action >= MONO_DECLSEC_ACTION_MIN) && (action <= MONO_DECLSEC_ACTION_MAX)) {
2472 result |= declsec_flags_map [action];
2473 } else {
2474 g_assert_not_reached ();
2475 }
2476 }
2477 return result;
2478 }
2479
2480 /*
2481 * Get the security actions (in the form of flags) associated with the specified method.
2482 *
2483 * @method: The method for which we want the declarative security flags.
2484 * Return the declarative security flags for the method (only).
2485 *
2486 * Note: To keep MonoMethod size down we do not cache the declarative security flags
2487 * (except for the stack modifiers which are kept in the MonoJitInfo structure)
2488 */
2489 guint32
2490 mono_declsec_flags_from_method (MonoMethod *method)
2491 {
2492 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2493 /* FIXME: No cache (for the moment) */
2494 guint32 idx = mono_method_get_index (method);
2495 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2496 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
2497 return mono_declsec_get_flags (method->klass->image, idx);
2498 }
2499 return 0;
2500 }
2501
2502 /*
2503 * Get the security actions (in the form of flags) associated with the specified class.
2504 *
2505 * @klass: The class for which we want the declarative security flags.
2506 * Return the declarative security flags for the class.
2507 *
2508 * Note: We cache the flags inside the MonoClass structure as this will get
2509 * called very often (at least for each method).
2510 */
2511 guint32
2512 mono_declsec_flags_from_class (MonoClass *klass)
2513 {
2514 if (mono_class_get_flags (klass) & TYPE_ATTRIBUTE_HAS_SECURITY) {
2515 guint32 flags = mono_class_get_declsec_flags (klass);
2516
2517 if (!flags) {
2518 guint32 idx;
2519
2520 idx = mono_metadata_token_index (klass->type_token);
2521 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2522 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
2523 flags = mono_declsec_get_flags (klass->image, idx);
2524 /* we cache the flags on classes */
2525 mono_class_set_declsec_flags (klass, flags);
2526 }
2527 return flags;
2528 }
2529 return 0;
2530 }
2531
2532 /*
2533 * Get the security actions (in the form of flags) associated with the specified assembly.
2534 *
2535 * @assembly: The assembly for which we want the declarative security flags.
2536 * Return the declarative security flags for the assembly.
2537 */
2538 guint32
2539 mono_declsec_flags_from_assembly (MonoAssembly *assembly)
2540 {
2541 guint32 idx = 1; /* there is only one assembly */
2542 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2543 idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
2544 return mono_declsec_get_flags (assembly->image, idx);
2545 }
2546
2547
2548 /*
2549 * Fill actions for the specific index (which may either be an encoded class token or
2550 * an encoded method token) from the metadata image.
2551 * Returns TRUE if some actions requiring code generation are present, FALSE otherwise.
2552 */
2553 static MonoBoolean
2554 fill_actions_from_index (MonoImage *image, guint32 token, MonoDeclSecurityActions* actions,
2555 guint32 id_std, guint32 id_noncas, guint32 id_choice)
2556 {
2557 MonoBoolean result = FALSE;
2558 MonoTableInfo *t;
2559 guint32 cols [MONO_DECL_SECURITY_SIZE];
2560 int index = mono_metadata_declsec_from_index (image, token);
2561 int i;
2562
2563 t = &image->tables [MONO_TABLE_DECLSECURITY];
2564 for (i = index; i < t->rows; i++) {
2565 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
2566
2567 if (cols [MONO_DECL_SECURITY_PARENT] != token)
2568 return result;
2569
2570 /* if present only replace (class) permissions with method permissions */
2571 /* if empty accept either class or method permissions */
2572 if (cols [MONO_DECL_SECURITY_ACTION] == id_std) {
2573 if (!actions->demand.blob) {
2574 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2575 actions->demand.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
2576 actions->demand.blob = (char*) (blob + 2);
2577 actions->demand.size = mono_metadata_decode_blob_size (blob, &blob);
2578 result = TRUE;
2579 }
2580 } else if (cols [MONO_DECL_SECURITY_ACTION] == id_noncas) {
2581 if (!actions->noncasdemand.blob) {
2582 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2583 actions->noncasdemand.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
2584 actions->noncasdemand.blob = (char*) (blob + 2);
2585 actions->noncasdemand.size = mono_metadata_decode_blob_size (blob, &blob);
2586 result = TRUE;
2587 }
2588 } else if (cols [MONO_DECL_SECURITY_ACTION] == id_choice) {
2589 if (!actions->demandchoice.blob) {
2590 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2591 actions->demandchoice.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
2592 actions->demandchoice.blob = (char*) (blob + 2);
2593 actions->demandchoice.size = mono_metadata_decode_blob_size (blob, &blob);
2594 result = TRUE;
2595 }
2596 }
2597 }
2598
2599 return result;
2600 }
2601
2602 static MonoBoolean
2603 mono_declsec_get_class_demands_params (MonoClass *klass, MonoDeclSecurityActions* demands,
2604 guint32 id_std, guint32 id_noncas, guint32 id_choice)
2605 {
2606 guint32 idx = mono_metadata_token_index (klass->type_token);
2607 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2608 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
2609 return fill_actions_from_index (klass->image, idx, demands, id_std, id_noncas, id_choice);
2610 }
2611
2612 static MonoBoolean
2613 mono_declsec_get_method_demands_params (MonoMethod *method, MonoDeclSecurityActions* demands,
2614 guint32 id_std, guint32 id_noncas, guint32 id_choice)
2615 {
2616 guint32 idx = mono_method_get_index (method);
2617 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2618 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
2619 return fill_actions_from_index (method->klass->image, idx, demands, id_std, id_noncas, id_choice);
2620 }
2621
2622 /*
2623 * Collect all actions (that requires to generate code in mini) assigned for
2624 * the specified method.
2625 * Note: Don't use the content of actions if the function return FALSE.
2626 */
2627 MonoBoolean
2628 mono_declsec_get_demands (MonoMethod *method, MonoDeclSecurityActions* demands)
2629 {
2630 guint32 mask = MONO_DECLSEC_FLAG_DEMAND | MONO_DECLSEC_FLAG_NONCAS_DEMAND |
2631 MONO_DECLSEC_FLAG_DEMAND_CHOICE;
2632 MonoBoolean result = FALSE;
2633 guint32 flags;
2634
2635 /* quick exit if no declarative security is present in the metadata */
2636 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
2637 return FALSE;
2638
2639 /* we want the original as the wrapper is "free" of the security informations */
2640 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
2641 method = mono_marshal_method_from_wrapper (method);
2642 if (!method)
2643 return FALSE;
2644 }
2645
2646 /* First we look for method-level attributes */
2647 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2648 mono_class_init (method->klass);
2649 memset (demands, 0, sizeof (MonoDeclSecurityActions));
2650
2651 result = mono_declsec_get_method_demands_params (method, demands,
2652 SECURITY_ACTION_DEMAND, SECURITY_ACTION_NONCASDEMAND, SECURITY_ACTION_DEMANDCHOICE);
2653 }
2654
2655 /* Here we use (or create) the class declarative cache to look for demands */
2656 flags = mono_declsec_flags_from_class (method->klass);
2657 if (flags & mask) {
2658 if (!result) {
2659 mono_class_init (method->klass);
2660 memset (demands, 0, sizeof (MonoDeclSecurityActions));
2661 }
2662 result |= mono_declsec_get_class_demands_params (method->klass, demands,
2663 SECURITY_ACTION_DEMAND, SECURITY_ACTION_NONCASDEMAND, SECURITY_ACTION_DEMANDCHOICE);
2664 }
2665
2666 /* The boolean return value is used as a shortcut in case nothing needs to
2667 be generated (e.g. LinkDemand[Choice] and InheritanceDemand[Choice]) */
2668 return result;
2669 }
2670
2671
2672 /*
2673 * Collect all Link actions: LinkDemand, NonCasLinkDemand and LinkDemandChoice (2.0).
2674 *
2675 * Note: Don't use the content of actions if the function return FALSE.
2676 */
2677 MonoBoolean
2678 mono_declsec_get_linkdemands (MonoMethod *method, MonoDeclSecurityActions* klass, MonoDeclSecurityActions *cmethod)
2679 {
2680 MonoBoolean result = FALSE;
2681 guint32 flags;
2682
2683 /* quick exit if no declarative security is present in the metadata */
2684 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
2685 return FALSE;
2686
2687 /* we want the original as the wrapper is "free" of the security informations */
2688 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
2689 method = mono_marshal_method_from_wrapper (method);
2690 if (!method)
2691 return FALSE;
2692 }
2693
2694 /* results are independant - zeroize both */
2695 memset (cmethod, 0, sizeof (MonoDeclSecurityActions));
2696 memset (klass, 0, sizeof (MonoDeclSecurityActions));
2697
2698 /* First we look for method-level attributes */
2699 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2700 mono_class_init (method->klass);
2701
2702 result = mono_declsec_get_method_demands_params (method, cmethod,
2703 SECURITY_ACTION_LINKDEMAND, SECURITY_ACTION_NONCASLINKDEMAND, SECURITY_ACTION_LINKDEMANDCHOICE);
2704 }
2705
2706 /* Here we use (or create) the class declarative cache to look for demands */
2707 flags = mono_declsec_flags_from_class (method->klass);
2708 if (flags & (MONO_DECLSEC_FLAG_LINKDEMAND | MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND | MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE)) {
2709 mono_class_init (method->klass);
2710
2711 result |= mono_declsec_get_class_demands_params (method->klass, klass,
2712 SECURITY_ACTION_LINKDEMAND, SECURITY_ACTION_NONCASLINKDEMAND, SECURITY_ACTION_LINKDEMANDCHOICE);
2713 }
2714
2715 return result;
2716 }
2717
2718 /*
2719 * Collect all Inherit actions: InheritanceDemand, NonCasInheritanceDemand and InheritanceDemandChoice (2.0).
2720 *
2721 * @klass The inherited class - this is the class that provides the security check (attributes)
2722 * @demans
2723 * return TRUE if inheritance demands (any kind) are present, FALSE otherwise.
2724 *
2725 * Note: Don't use the content of actions if the function return FALSE.
2726 */
2727 MonoBoolean
2728 mono_declsec_get_inheritdemands_class (MonoClass *klass, MonoDeclSecurityActions* demands)
2729 {
2730 MonoBoolean result = FALSE;
2731 guint32 flags;
2732
2733 /* quick exit if no declarative security is present in the metadata */
2734 if (!klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
2735 return FALSE;
2736
2737 /* Here we use (or create) the class declarative cache to look for demands */
2738 flags = mono_declsec_flags_from_class (klass);
2739 if (flags & (MONO_DECLSEC_FLAG_INHERITANCEDEMAND | MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND | MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE)) {
2740 mono_class_init (klass);
2741 memset (demands, 0, sizeof (MonoDeclSecurityActions));
2742
2743 result |= mono_declsec_get_class_demands_params (klass, demands,
2744 SECURITY_ACTION_INHERITDEMAND, SECURITY_ACTION_NONCASINHERITANCE, SECURITY_ACTION_INHERITDEMANDCHOICE);
2745 }
2746
2747 return result;
2748 }
2749
2750 /*
2751 * Collect all Inherit actions: InheritanceDemand, NonCasInheritanceDemand and InheritanceDemandChoice (2.0).
2752 *
2753 * Note: Don't use the content of actions if the function return FALSE.
2754 */
2755 MonoBoolean
2756 mono_declsec_get_inheritdemands_method (MonoMethod *method, MonoDeclSecurityActions* demands)
2757 {
2758 /* quick exit if no declarative security is present in the metadata */
2759 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
2760 return FALSE;
2761
2762 /* we want the original as the wrapper is "free" of the security informations */
2763 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
2764 method = mono_marshal_method_from_wrapper (method);
2765 if (!method)
2766 return FALSE;
2767 }
2768
2769 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2770 mono_class_init (method->klass);
2771 memset (demands, 0, sizeof (MonoDeclSecurityActions));
2772
2773 return mono_declsec_get_method_demands_params (method, demands,
2774 SECURITY_ACTION_INHERITDEMAND, SECURITY_ACTION_NONCASINHERITANCE, SECURITY_ACTION_INHERITDEMANDCHOICE);
2775 }
2776 return FALSE;
2777 }
2778
2779
2780 static MonoBoolean
2781 get_declsec_action (MonoImage *image, guint32 token, guint32 action, MonoDeclSecurityEntry *entry)
2782 {
2783 guint32 cols [MONO_DECL_SECURITY_SIZE];
2784 MonoTableInfo *t;
2785 int i;
2786
2787 int index = mono_metadata_declsec_from_index (image, token);
2788 if (index == -1)
2789 return FALSE;
2790
2791 t = &image->tables [MONO_TABLE_DECLSECURITY];
2792 for (i = index; i < t->rows; i++) {
2793 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
2794
2795 /* shortcut - index are ordered */
2796 if (token != cols [MONO_DECL_SECURITY_PARENT])
2797 return FALSE;
2798
2799 if (cols [MONO_DECL_SECURITY_ACTION] == action) {
2800 const char *metadata = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2801 entry->blob = (char*) (metadata + 2);
2802 entry->size = mono_metadata_decode_blob_size (metadata, &metadata);
2803 return TRUE;
2804 }
2805 }
2806
2807 return FALSE;
2808 }
2809
2810 MonoBoolean
2811 mono_declsec_get_method_action (MonoMethod *method, guint32 action, MonoDeclSecurityEntry *entry)
2812 {
2813 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
2814 guint32 idx = mono_method_get_index (method);
2815 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2816 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
2817 return get_declsec_action (method->klass->image, idx, action, entry);
2818 }
2819 return FALSE;
2820 }
2821
2822 MonoBoolean
2823 mono_declsec_get_class_action (MonoClass *klass, guint32 action, MonoDeclSecurityEntry *entry)
2824 {
2825 /* use cache */
2826 guint32 flags = mono_declsec_flags_from_class (klass);
2827 if (declsec_flags_map [action] & flags) {
2828 guint32 idx = mono_metadata_token_index (klass->type_token);
2829 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2830 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
2831 return get_declsec_action (klass->image, idx, action, entry);
2832 }
2833 return FALSE;
2834 }
2835
2836 MonoBoolean
2837 mono_declsec_get_assembly_action (MonoAssembly *assembly, guint32 action, MonoDeclSecurityEntry *entry)
2838 {
2839 guint32 idx = 1; /* there is only one assembly */
2840 idx <<= MONO_HAS_DECL_SECURITY_BITS;
2841 idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
2842
2843 return get_declsec_action (assembly->image, idx, action, entry);
2844 }
2845
2846 gboolean
2847 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass, MonoError *error)
2848 {
2849 MonoObject *res, *exc;
2850 void *params [1];
2851 static MonoMethod *method = NULL;
2852
2853 mono_error_init (error);
2854
2855 if (method == NULL) {
2856 method = mono_class_get_method_from_name (mono_class_get_type_builder_class (), "IsAssignableTo", 1);
2857 g_assert (method);
2858 }
2859
2860 /*
2861 * The result of mono_type_get_object_checked () might be a System.MonoType but we
2862 * need a TypeBuilder so use mono_class_get_ref_info (klass).
2863 */
2864 g_assert (mono_class_get_ref_info (klass));
2865 g_assert (!strcmp (((MonoObject*)(mono_class_get_ref_info (klass)))->vtable->klass->name, "TypeBuilder"));
2866
2867 params [0] = mono_type_get_object_checked (mono_domain_get (), &oklass->byval_arg, error);
2868 return_val_if_nok (error, FALSE);
2869
2870 MonoError inner_error;
2871 res = mono_runtime_try_invoke (method, (MonoObject*)(mono_class_get_ref_info (klass)), params, &exc, &inner_error);
2872
2873 if (exc || !is_ok (&inner_error)) {
2874 mono_error_cleanup (&inner_error);
2875 return FALSE;
2876 } else
2877 return *(MonoBoolean*)mono_object_unbox (res);
2878 }
2879
2880 /**
2881 * mono_reflection_type_get_type:
2882 * @reftype: the System.Type object
2883 *
2884 * Returns the MonoType* associated with the C# System.Type object @reftype.
2885 */
2886 MonoType*
2887 mono_reflection_type_get_type (MonoReflectionType *reftype)
2888 {
2889 g_assert (reftype);
2890
2891 MonoError error;
2892 MonoType *result = mono_reflection_type_get_handle (reftype, &error);
2893 mono_error_assert_ok (&error);
2894 return result;
2895 }
2896
2897 /**
2898 * mono_reflection_assembly_get_assembly:
2899 * @refassembly: the System.Reflection.Assembly object
2900 *
2901 * Returns the MonoAssembly* associated with the C# System.Reflection.Assembly object @refassembly.
2902 */
2903 MonoAssembly*
2904 mono_reflection_assembly_get_assembly (MonoReflectionAssembly *refassembly)
2905 {
2906 g_assert (refassembly);
2907
2908 return refassembly->assembly;
2909 }
2910
2911 /**
2912 * mono_class_from_mono_type_handle:
2913 * @reftype: the System.Type handle
2914 *
2915 * Returns the MonoClass* corresponding to the given type.
2916 */
2917 MonoClass*
2918 mono_class_from_mono_type_handle (MonoReflectionTypeHandle reftype)
2919 {
2920 return mono_class_from_mono_type (MONO_HANDLE_RAW (reftype)->type);
2921 }
Mirror of the official Mono project git repository