?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[runtime] MonoError-ize mono_compile_method
[mono-project.git] / mono / metadata / icall.c
blob3a47c3286ee772462fe9bb2714535c84f47f6f14
1 /*
2 * icall.c:
3 *
4 * Authors:
5 * Dietmar Maurer (dietmar@ximian.com)
6 * Paolo Molaro (lupus@ximian.com)
7 * Patrik Torstensson (patrik.torstensson@labs2.com)
8 * Marek Safar (marek.safar@gmail.com)
9 * Aleksey Kliger (aleksey@xamarin.com)
10 *
11 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
12 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
13 * Copyright 2011-2015 Xamarin Inc (http://www.xamarin.com).
14 * Licensed under the MIT license. See LICENSE file in the project root for full license information.
15 */
16
17 #include <config.h>
18 #include <glib.h>
19 #include <stdarg.h>
20 #include <string.h>
21 #include <ctype.h>
22 #ifdef HAVE_ALLOCA_H
23 #include <alloca.h>
24 #endif
25 #ifdef HAVE_SYS_TIME_H
26 #include <sys/time.h>
27 #endif
28 #ifdef HAVE_UNISTD_H
29 #include <unistd.h>
30 #endif
31 #if defined (HOST_WIN32)
32 #include <stdlib.h>
33 #endif
34 #if defined (HAVE_WCHAR_H)
35 #include <wchar.h>
36 #endif
37
38 #include "mono/utils/mono-membar.h"
39 #include <mono/metadata/object.h>
40 #include <mono/metadata/threads.h>
41 #include <mono/metadata/threads-types.h>
42 #include <mono/metadata/threadpool-ms.h>
43 #include <mono/metadata/threadpool-ms-io.h>
44 #include <mono/metadata/monitor.h>
45 #include <mono/metadata/reflection.h>
46 #include <mono/metadata/assembly.h>
47 #include <mono/metadata/tabledefs.h>
48 #include <mono/metadata/exception.h>
49 #include <mono/metadata/exception-internals.h>
50 #include <mono/metadata/file-io.h>
51 #include <mono/metadata/console-io.h>
52 #include <mono/metadata/mono-route.h>
53 #include <mono/metadata/socket-io.h>
54 #include <mono/metadata/mono-endian.h>
55 #include <mono/metadata/tokentype.h>
56 #include <mono/metadata/domain-internals.h>
57 #include <mono/metadata/metadata-internals.h>
58 #include <mono/metadata/class-internals.h>
59 #include <mono/metadata/reflection-internals.h>
60 #include <mono/metadata/marshal.h>
61 #include <mono/metadata/gc-internals.h>
62 #include <mono/metadata/mono-gc.h>
63 #include <mono/metadata/rand.h>
64 #include <mono/metadata/sysmath.h>
65 #include <mono/metadata/string-icalls.h>
66 #include <mono/metadata/debug-helpers.h>
67 #include <mono/metadata/process.h>
68 #include <mono/metadata/environment.h>
69 #include <mono/metadata/profiler-private.h>
70 #include <mono/metadata/locales.h>
71 #include <mono/metadata/filewatcher.h>
72 #include <mono/metadata/security.h>
73 #include <mono/metadata/mono-config.h>
74 #include <mono/metadata/cil-coff.h>
75 #include <mono/metadata/number-formatter.h>
76 #include <mono/metadata/security-manager.h>
77 #include <mono/metadata/security-core-clr.h>
78 #include <mono/metadata/mono-perfcounters.h>
79 #include <mono/metadata/mono-debug.h>
80 #include <mono/metadata/mono-ptr-array.h>
81 #include <mono/metadata/verify-internals.h>
82 #include <mono/metadata/runtime.h>
83 #include <mono/metadata/file-mmap.h>
84 #include <mono/metadata/seq-points-data.h>
85 #include <mono/io-layer/io-layer.h>
86 #include <mono/utils/monobitset.h>
87 #include <mono/utils/mono-time.h>
88 #include <mono/utils/mono-proclib.h>
89 #include <mono/utils/mono-string.h>
90 #include <mono/utils/mono-error-internals.h>
91 #include <mono/utils/mono-mmap.h>
92 #include <mono/utils/mono-io-portability.h>
93 #include <mono/utils/mono-digest.h>
94 #include <mono/utils/bsearch.h>
95 #include <mono/utils/mono-os-mutex.h>
96 #include <mono/utils/mono-threads.h>
97
98 #if defined (HOST_WIN32)
99 #include <windows.h>
100 #include <shlobj.h>
101 #endif
102 #include "decimal-ms.h"
103 #include "number-ms.h"
104
105 #if !defined(HOST_WIN32) && defined(HAVE_SYS_UTSNAME_H)
106 #include <sys/utsname.h>
107 #endif
108
109 extern MonoString* ves_icall_System_Environment_GetOSVersionString (void);
110
111 ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
112
113 /* Lazy class loading functions */
114 static GENERATE_GET_CLASS_WITH_CACHE (system_version, System, Version)
115 static GENERATE_GET_CLASS_WITH_CACHE (assembly_name, System.Reflection, AssemblyName)
116 static GENERATE_GET_CLASS_WITH_CACHE (constructor_info, System.Reflection, ConstructorInfo)
117 static GENERATE_GET_CLASS_WITH_CACHE (property_info, System.Reflection, PropertyInfo)
118 static GENERATE_GET_CLASS_WITH_CACHE (event_info, System.Reflection, EventInfo)
119 static GENERATE_GET_CLASS_WITH_CACHE (module, System.Reflection, Module)
120
121 static MonoArray*
122 type_array_from_modifiers (MonoImage *image, MonoType *type, int optional, MonoError *error);
123
124 static inline MonoBoolean
125 is_generic_parameter (MonoType *type)
126 {
127 return !type->byref && (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR);
128 }
129
130 static void
131 mono_class_init_checked (MonoClass *klass, MonoError *error)
132 {
133 mono_error_init (error);
134
135 if (!mono_class_init (klass))
136 mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (klass));
137 }
138
139 ICALL_EXPORT MonoObject *
140 ves_icall_System_Array_GetValueImpl (MonoArray *arr, guint32 pos)
141 {
142 MonoError error;
143 MonoClass *ac;
144 gint32 esize;
145 gpointer *ea;
146 MonoObject *result = NULL;
147
148 ac = (MonoClass *)arr->obj.vtable->klass;
149
150 esize = mono_array_element_size (ac);
151 ea = (gpointer*)((char*)arr->vector + (pos * esize));
152
153 if (ac->element_class->valuetype) {
154 result = mono_value_box_checked (arr->obj.vtable->domain, ac->element_class, ea, &error);
155 mono_error_set_pending_exception (&error);
156 } else
157 result = (MonoObject *)*ea;
158 return result;
159 }
160
161 ICALL_EXPORT MonoObject *
162 ves_icall_System_Array_GetValue (MonoArray *arr, MonoArray *idxs)
163 {
164 MonoClass *ac, *ic;
165 MonoArray *io;
166 gint32 i, pos, *ind;
167
168 MONO_CHECK_ARG_NULL (idxs, NULL);
169
170 io = idxs;
171 ic = (MonoClass *)io->obj.vtable->klass;
172
173 ac = (MonoClass *)arr->obj.vtable->klass;
174
175 g_assert (ic->rank == 1);
176 if (io->bounds != NULL || io->max_length != ac->rank) {
177 mono_set_pending_exception (mono_get_exception_argument (NULL, NULL));
178 return NULL;
179 }
180
181 ind = (gint32 *)io->vector;
182
183 if (arr->bounds == NULL) {
184 if (*ind < 0 || *ind >= arr->max_length) {
185 mono_set_pending_exception (mono_get_exception_index_out_of_range ());
186 return NULL;
187 }
188
189 return ves_icall_System_Array_GetValueImpl (arr, *ind);
190 }
191
192 for (i = 0; i < ac->rank; i++) {
193 if ((ind [i] < arr->bounds [i].lower_bound) ||
194 (ind [i] >= (mono_array_lower_bound_t)arr->bounds [i].length + arr->bounds [i].lower_bound)) {
195 mono_set_pending_exception (mono_get_exception_index_out_of_range ());
196 return NULL;
197 }
198 }
199
200 pos = ind [0] - arr->bounds [0].lower_bound;
201 for (i = 1; i < ac->rank; i++)
202 pos = pos * arr->bounds [i].length + ind [i] -
203 arr->bounds [i].lower_bound;
204
205 return ves_icall_System_Array_GetValueImpl (arr, pos);
206 }
207
208 ICALL_EXPORT void
209 ves_icall_System_Array_SetValueImpl (MonoArray *arr, MonoObject *value, guint32 pos)
210 {
211 MonoError error;
212 MonoClass *ac, *vc, *ec;
213 gint32 esize, vsize;
214 gpointer *ea, *va;
215 int et, vt;
216
217 guint64 u64 = 0;
218 gint64 i64 = 0;
219 gdouble r64 = 0;
220
221 mono_error_init (&error);
222
223 if (value)
224 vc = value->vtable->klass;
225 else
226 vc = NULL;
227
228 ac = arr->obj.vtable->klass;
229 ec = ac->element_class;
230
231 esize = mono_array_element_size (ac);
232 ea = (gpointer*)((char*)arr->vector + (pos * esize));
233 va = (gpointer*)((char*)value + sizeof (MonoObject));
234
235 if (mono_class_is_nullable (ec)) {
236 mono_nullable_init ((guint8*)ea, value, ec);
237 return;
238 }
239
240 if (!value) {
241 mono_gc_bzero_atomic (ea, esize);
242 return;
243 }
244
245 #define NO_WIDENING_CONVERSION G_STMT_START{\
246 mono_set_pending_exception (mono_get_exception_argument ( \
247 "value", "not a widening conversion")); \
248 return; \
249 }G_STMT_END
250
251 #define CHECK_WIDENING_CONVERSION(extra) G_STMT_START{\
252 if (esize < vsize + (extra)) { \
253 mono_set_pending_exception (mono_get_exception_argument ( \
254 "value", "not a widening conversion")); \
255 return; \
256 } \
257 }G_STMT_END
258
259 #define INVALID_CAST G_STMT_START{ \
260 mono_get_runtime_callbacks ()->set_cast_details (vc, ec); \
261 mono_set_pending_exception (mono_get_exception_invalid_cast ()); \
262 return; \
263 }G_STMT_END
264
265 /* Check element (destination) type. */
266 switch (ec->byval_arg.type) {
267 case MONO_TYPE_STRING:
268 switch (vc->byval_arg.type) {
269 case MONO_TYPE_STRING:
270 break;
271 default:
272 INVALID_CAST;
273 }
274 break;
275 case MONO_TYPE_BOOLEAN:
276 switch (vc->byval_arg.type) {
277 case MONO_TYPE_BOOLEAN:
278 break;
279 case MONO_TYPE_CHAR:
280 case MONO_TYPE_U1:
281 case MONO_TYPE_U2:
282 case MONO_TYPE_U4:
283 case MONO_TYPE_U8:
284 case MONO_TYPE_I1:
285 case MONO_TYPE_I2:
286 case MONO_TYPE_I4:
287 case MONO_TYPE_I8:
288 case MONO_TYPE_R4:
289 case MONO_TYPE_R8:
290 NO_WIDENING_CONVERSION;
291 default:
292 INVALID_CAST;
293 }
294 break;
295 default:
296 break;
297 }
298
299 if (!ec->valuetype) {
300 gboolean castOk = (NULL != mono_object_isinst_checked (value, ec, &error));
301 if (mono_error_set_pending_exception (&error))
302 return;
303 if (!castOk)
304 INVALID_CAST;
305 mono_gc_wbarrier_set_arrayref (arr, ea, (MonoObject*)value);
306 return;
307 }
308
309 if (mono_object_isinst_checked (value, ec, &error)) {
310 if (ec->has_references)
311 mono_value_copy (ea, (char*)value + sizeof (MonoObject), ec);
312 else
313 mono_gc_memmove_atomic (ea, (char *)value + sizeof (MonoObject), esize);
314 return;
315 }
316 if (mono_error_set_pending_exception (&error))
317 return;
318
319 if (!vc->valuetype)
320 INVALID_CAST;
321
322 vsize = mono_class_instance_size (vc) - sizeof (MonoObject);
323
324 et = ec->byval_arg.type;
325 if (et == MONO_TYPE_VALUETYPE && ec->byval_arg.data.klass->enumtype)
326 et = mono_class_enum_basetype (ec->byval_arg.data.klass)->type;
327
328 vt = vc->byval_arg.type;
329 if (vt == MONO_TYPE_VALUETYPE && vc->byval_arg.data.klass->enumtype)
330 vt = mono_class_enum_basetype (vc->byval_arg.data.klass)->type;
331
332 #define ASSIGN_UNSIGNED(etype) G_STMT_START{\
333 switch (vt) { \
334 case MONO_TYPE_U1: \
335 case MONO_TYPE_U2: \
336 case MONO_TYPE_U4: \
337 case MONO_TYPE_U8: \
338 case MONO_TYPE_CHAR: \
339 CHECK_WIDENING_CONVERSION(0); \
340 *(etype *) ea = (etype) u64; \
341 return; \
342 /* You can't assign a signed value to an unsigned array. */ \
343 case MONO_TYPE_I1: \
344 case MONO_TYPE_I2: \
345 case MONO_TYPE_I4: \
346 case MONO_TYPE_I8: \
347 /* You can't assign a floating point number to an integer array. */ \
348 case MONO_TYPE_R4: \
349 case MONO_TYPE_R8: \
350 NO_WIDENING_CONVERSION; \
351 } \
352 }G_STMT_END
353
354 #define ASSIGN_SIGNED(etype) G_STMT_START{\
355 switch (vt) { \
356 case MONO_TYPE_I1: \
357 case MONO_TYPE_I2: \
358 case MONO_TYPE_I4: \
359 case MONO_TYPE_I8: \
360 CHECK_WIDENING_CONVERSION(0); \
361 *(etype *) ea = (etype) i64; \
362 return; \
363 /* You can assign an unsigned value to a signed array if the array's */ \
364 /* element size is larger than the value size. */ \
365 case MONO_TYPE_U1: \
366 case MONO_TYPE_U2: \
367 case MONO_TYPE_U4: \
368 case MONO_TYPE_U8: \
369 case MONO_TYPE_CHAR: \
370 CHECK_WIDENING_CONVERSION(1); \
371 *(etype *) ea = (etype) u64; \
372 return; \
373 /* You can't assign a floating point number to an integer array. */ \
374 case MONO_TYPE_R4: \
375 case MONO_TYPE_R8: \
376 NO_WIDENING_CONVERSION; \
377 } \
378 }G_STMT_END
379
380 #define ASSIGN_REAL(etype) G_STMT_START{\
381 switch (vt) { \
382 case MONO_TYPE_R4: \
383 case MONO_TYPE_R8: \
384 CHECK_WIDENING_CONVERSION(0); \
385 *(etype *) ea = (etype) r64; \
386 return; \
387 /* All integer values fit into a floating point array, so we don't */ \
388 /* need to CHECK_WIDENING_CONVERSION here. */ \
389 case MONO_TYPE_I1: \
390 case MONO_TYPE_I2: \
391 case MONO_TYPE_I4: \
392 case MONO_TYPE_I8: \
393 *(etype *) ea = (etype) i64; \
394 return; \
395 case MONO_TYPE_U1: \
396 case MONO_TYPE_U2: \
397 case MONO_TYPE_U4: \
398 case MONO_TYPE_U8: \
399 case MONO_TYPE_CHAR: \
400 *(etype *) ea = (etype) u64; \
401 return; \
402 } \
403 }G_STMT_END
404
405 switch (vt) {
406 case MONO_TYPE_U1:
407 u64 = *(guint8 *) va;
408 break;
409 case MONO_TYPE_U2:
410 u64 = *(guint16 *) va;
411 break;
412 case MONO_TYPE_U4:
413 u64 = *(guint32 *) va;
414 break;
415 case MONO_TYPE_U8:
416 u64 = *(guint64 *) va;
417 break;
418 case MONO_TYPE_I1:
419 i64 = *(gint8 *) va;
420 break;
421 case MONO_TYPE_I2:
422 i64 = *(gint16 *) va;
423 break;
424 case MONO_TYPE_I4:
425 i64 = *(gint32 *) va;
426 break;
427 case MONO_TYPE_I8:
428 i64 = *(gint64 *) va;
429 break;
430 case MONO_TYPE_R4:
431 r64 = *(gfloat *) va;
432 break;
433 case MONO_TYPE_R8:
434 r64 = *(gdouble *) va;
435 break;
436 case MONO_TYPE_CHAR:
437 u64 = *(guint16 *) va;
438 break;
439 case MONO_TYPE_BOOLEAN:
440 /* Boolean is only compatible with itself. */
441 switch (et) {
442 case MONO_TYPE_CHAR:
443 case MONO_TYPE_U1:
444 case MONO_TYPE_U2:
445 case MONO_TYPE_U4:
446 case MONO_TYPE_U8:
447 case MONO_TYPE_I1:
448 case MONO_TYPE_I2:
449 case MONO_TYPE_I4:
450 case MONO_TYPE_I8:
451 case MONO_TYPE_R4:
452 case MONO_TYPE_R8:
453 NO_WIDENING_CONVERSION;
454 default:
455 INVALID_CAST;
456 }
457 break;
458 }
459
460 /* If we can't do a direct copy, let's try a widening conversion. */
461 switch (et) {
462 case MONO_TYPE_CHAR:
463 ASSIGN_UNSIGNED (guint16);
464 case MONO_TYPE_U1:
465 ASSIGN_UNSIGNED (guint8);
466 case MONO_TYPE_U2:
467 ASSIGN_UNSIGNED (guint16);
468 case MONO_TYPE_U4:
469 ASSIGN_UNSIGNED (guint32);
470 case MONO_TYPE_U8:
471 ASSIGN_UNSIGNED (guint64);
472 case MONO_TYPE_I1:
473 ASSIGN_SIGNED (gint8);
474 case MONO_TYPE_I2:
475 ASSIGN_SIGNED (gint16);
476 case MONO_TYPE_I4:
477 ASSIGN_SIGNED (gint32);
478 case MONO_TYPE_I8:
479 ASSIGN_SIGNED (gint64);
480 case MONO_TYPE_R4:
481 ASSIGN_REAL (gfloat);
482 case MONO_TYPE_R8:
483 ASSIGN_REAL (gdouble);
484 }
485
486 INVALID_CAST;
487 /* Not reached, INVALID_CAST does not return. Just to avoid a compiler warning ... */
488 return;
489
490 #undef INVALID_CAST
491 #undef NO_WIDENING_CONVERSION
492 #undef CHECK_WIDENING_CONVERSION
493 #undef ASSIGN_UNSIGNED
494 #undef ASSIGN_SIGNED
495 #undef ASSIGN_REAL
496 }
497
498 ICALL_EXPORT void
499 ves_icall_System_Array_SetValue (MonoArray *arr, MonoObject *value,
500 MonoArray *idxs)
501 {
502 MonoClass *ac, *ic;
503 gint32 i, pos, *ind;
504
505 MONO_CHECK_ARG_NULL (idxs,);
506
507 ic = idxs->obj.vtable->klass;
508 ac = arr->obj.vtable->klass;
509
510 g_assert (ic->rank == 1);
511 if (idxs->bounds != NULL || idxs->max_length != ac->rank) {
512 mono_set_pending_exception (mono_get_exception_argument (NULL, NULL));
513 return;
514 }
515
516 ind = (gint32 *)idxs->vector;
517
518 if (arr->bounds == NULL) {
519 if (*ind < 0 || *ind >= arr->max_length) {
520 mono_set_pending_exception (mono_get_exception_index_out_of_range ());
521 return;
522 }
523
524 ves_icall_System_Array_SetValueImpl (arr, value, *ind);
525 return;
526 }
527
528 for (i = 0; i < ac->rank; i++)
529 if ((ind [i] < arr->bounds [i].lower_bound) ||
530 (ind [i] >= (mono_array_lower_bound_t)arr->bounds [i].length + arr->bounds [i].lower_bound)) {
531 mono_set_pending_exception (mono_get_exception_index_out_of_range ());
532 return;
533 }
534
535 pos = ind [0] - arr->bounds [0].lower_bound;
536 for (i = 1; i < ac->rank; i++)
537 pos = pos * arr->bounds [i].length + ind [i] -
538 arr->bounds [i].lower_bound;
539
540 ves_icall_System_Array_SetValueImpl (arr, value, pos);
541 }
542
543 ICALL_EXPORT MonoArray *
544 ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
545 {
546 MonoError error;
547 MonoClass *aklass, *klass;
548 MonoArray *array;
549 uintptr_t *sizes, i;
550 gboolean bounded = FALSE;
551
552 MONO_CHECK_ARG_NULL (type, NULL);
553 MONO_CHECK_ARG_NULL (lengths, NULL);
554
555 MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0, NULL);
556 if (bounds)
557 MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds), NULL);
558
559 for (i = 0; i < mono_array_length (lengths); i++) {
560 if (mono_array_get (lengths, gint32, i) < 0) {
561 mono_set_pending_exception (mono_get_exception_argument_out_of_range (NULL));
562 return NULL;
563 }
564 }
565
566 klass = mono_class_from_mono_type (type->type);
567 mono_class_init_checked (klass, &error);
568 if (mono_error_set_pending_exception (&error))
569 return NULL;
570
571 if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint32, 0) != 0))
572 /* vectors are not the same as one dimensional arrays with no-zero bounds */
573 bounded = TRUE;
574 else
575 bounded = FALSE;
576
577 aklass = mono_bounded_array_class_get (klass, mono_array_length (lengths), bounded);
578
579 sizes = (uintptr_t *)alloca (aklass->rank * sizeof(intptr_t) * 2);
580 for (i = 0; i < aklass->rank; ++i) {
581 sizes [i] = mono_array_get (lengths, guint32, i);
582 if (bounds)
583 sizes [i + aklass->rank] = mono_array_get (bounds, gint32, i);
584 else
585 sizes [i + aklass->rank] = 0;
586 }
587
588 array = mono_array_new_full_checked (mono_object_domain (type), aklass, sizes, (intptr_t*)sizes + aklass->rank, &error);
589 mono_error_set_pending_exception (&error);
590
591 return array;
592 }
593
594 ICALL_EXPORT MonoArray *
595 ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType *type, MonoArray *lengths, MonoArray *bounds)
596 {
597 MonoError error;
598 MonoClass *aklass, *klass;
599 MonoArray *array;
600 uintptr_t *sizes, i;
601 gboolean bounded = FALSE;
602
603 MONO_CHECK_ARG_NULL (type, NULL);
604 MONO_CHECK_ARG_NULL (lengths, NULL);
605
606 MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0, NULL);
607 if (bounds)
608 MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds), NULL);
609
610 for (i = 0; i < mono_array_length (lengths); i++) {
611 if ((mono_array_get (lengths, gint64, i) < 0) ||
612 (mono_array_get (lengths, gint64, i) > MONO_ARRAY_MAX_INDEX)) {
613 mono_set_pending_exception (mono_get_exception_argument_out_of_range (NULL));
614 return NULL;
615 }
616 }
617
618 klass = mono_class_from_mono_type (type->type);
619 mono_class_init_checked (klass, &error);
620 if (mono_error_set_pending_exception (&error))
621 return NULL;
622
623 if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint64, 0) != 0))
624 /* vectors are not the same as one dimensional arrays with no-zero bounds */
625 bounded = TRUE;
626 else
627 bounded = FALSE;
628
629 aklass = mono_bounded_array_class_get (klass, mono_array_length (lengths), bounded);
630
631 sizes = (uintptr_t *)alloca (aklass->rank * sizeof(intptr_t) * 2);
632 for (i = 0; i < aklass->rank; ++i) {
633 sizes [i] = mono_array_get (lengths, guint64, i);
634 if (bounds)
635 sizes [i + aklass->rank] = (mono_array_size_t) mono_array_get (bounds, guint64, i);
636 else
637 sizes [i + aklass->rank] = 0;
638 }
639
640 array = mono_array_new_full_checked (mono_object_domain (type), aklass, sizes, (intptr_t*)sizes + aklass->rank, &error);
641 mono_error_set_pending_exception (&error);
642
643 return array;
644 }
645
646 ICALL_EXPORT gint32
647 ves_icall_System_Array_GetRank (MonoObject *arr)
648 {
649 return arr->vtable->klass->rank;
650 }
651
652 ICALL_EXPORT gint32
653 ves_icall_System_Array_GetLength (MonoArray *arr, gint32 dimension)
654 {
655 gint32 rank = arr->obj.vtable->klass->rank;
656 uintptr_t length;
657
658 if ((dimension < 0) || (dimension >= rank)) {
659 mono_set_pending_exception (mono_get_exception_index_out_of_range ());
660 return 0;
661 }
662
663 if (arr->bounds == NULL)
664 length = arr->max_length;
665 else
666 length = arr->bounds [dimension].length;
667
668 #ifdef MONO_BIG_ARRAYS
669 if (length > G_MAXINT32) {
670 mono_set_pending_exception (mono_get_exception_overflow ());
671 return 0;
672 }
673 #endif
674 return length;
675 }
676
677 ICALL_EXPORT gint64
678 ves_icall_System_Array_GetLongLength (MonoArray *arr, gint32 dimension)
679 {
680 gint32 rank = arr->obj.vtable->klass->rank;
681
682 if ((dimension < 0) || (dimension >= rank)) {
683 mono_set_pending_exception (mono_get_exception_index_out_of_range ());
684 return 0;
685 }
686
687 if (arr->bounds == NULL)
688 return arr->max_length;
689
690 return arr->bounds [dimension].length;
691 }
692
693 ICALL_EXPORT gint32
694 ves_icall_System_Array_GetLowerBound (MonoArray *arr, gint32 dimension)
695 {
696 gint32 rank = arr->obj.vtable->klass->rank;
697
698 if ((dimension < 0) || (dimension >= rank)) {
699 mono_set_pending_exception (mono_get_exception_index_out_of_range ());
700 return 0;
701 }
702
703 if (arr->bounds == NULL)
704 return 0;
705
706 return arr->bounds [dimension].lower_bound;
707 }
708
709 ICALL_EXPORT void
710 ves_icall_System_Array_ClearInternal (MonoArray *arr, int idx, int length)
711 {
712 int sz = mono_array_element_size (mono_object_class (arr));
713 mono_gc_bzero_atomic (mono_array_addr_with_size_fast (arr, sz, idx), length * sz);
714 }
715
716 ICALL_EXPORT MonoArray*
717 ves_icall_System_Array_Clone (MonoArray *arr)
718 {
719 MonoError error;
720 MonoArray *result = mono_array_clone_checked (arr, &error);
721 mono_error_set_pending_exception (&error);
722 return result;
723 }
724
725 ICALL_EXPORT gboolean
726 ves_icall_System_Array_FastCopy (MonoArray *source, int source_idx, MonoArray* dest, int dest_idx, int length)
727 {
728 int element_size;
729 void * dest_addr;
730 void * source_addr;
731 MonoVTable *src_vtable;
732 MonoVTable *dest_vtable;
733 MonoClass *src_class;
734 MonoClass *dest_class;
735
736 src_vtable = source->obj.vtable;
737 dest_vtable = dest->obj.vtable;
738
739 if (src_vtable->rank != dest_vtable->rank)
740 return FALSE;
741
742 if (source->bounds || dest->bounds)
743 return FALSE;
744
745 /* there's no integer overflow since mono_array_length returns an unsigned integer */
746 if ((dest_idx + length > mono_array_length_fast (dest)) ||
747 (source_idx + length > mono_array_length_fast (source)))
748 return FALSE;
749
750 src_class = src_vtable->klass->element_class;
751 dest_class = dest_vtable->klass->element_class;
752
753 /*
754 * Handle common cases.
755 */
756
757 /* Case1: object[] -> valuetype[] (ArrayList::ToArray)
758 We fallback to managed here since we need to typecheck each boxed valuetype before storing them in the dest array.
759 */
760 if (src_class == mono_defaults.object_class && dest_class->valuetype)
761 return FALSE;
762
763 /* Check if we're copying a char[] <==> (u)short[] */
764 if (src_class != dest_class) {
765 if (dest_class->valuetype || dest_class->enumtype || src_class->valuetype || src_class->enumtype)
766 return FALSE;
767
768 /* It's only safe to copy between arrays if we can ensure the source will always have a subtype of the destination. We bail otherwise. */
769 if (!mono_class_is_subclass_of (src_class, dest_class, FALSE))
770 return FALSE;
771 }
772
773 if (dest_class->valuetype) {
774 element_size = mono_array_element_size (source->obj.vtable->klass);
775 source_addr = mono_array_addr_with_size_fast (source, element_size, source_idx);
776 if (dest_class->has_references) {
777 mono_value_copy_array (dest, dest_idx, source_addr, length);
778 } else {
779 dest_addr = mono_array_addr_with_size_fast (dest, element_size, dest_idx);
780 mono_gc_memmove_atomic (dest_addr, source_addr, element_size * length);
781 }
782 } else {
783 mono_array_memcpy_refs_fast (dest, dest_idx, source, source_idx, length);
784 }
785
786 return TRUE;
787 }
788
789 ICALL_EXPORT void
790 ves_icall_System_Array_GetGenericValueImpl (MonoArray *arr, guint32 pos, gpointer value)
791 {
792 MonoClass *ac;
793 gint32 esize;
794 gpointer *ea;
795
796 ac = (MonoClass *)arr->obj.vtable->klass;
797
798 esize = mono_array_element_size (ac);
799 ea = (gpointer*)((char*)arr->vector + (pos * esize));
800
801 mono_gc_memmove_atomic (value, ea, esize);
802 }
803
804 ICALL_EXPORT void
805 ves_icall_System_Array_SetGenericValueImpl (MonoArray *arr, guint32 pos, gpointer value)
806 {
807 MonoClass *ac, *ec;
808 gint32 esize;
809 gpointer *ea;
810
811 ac = (MonoClass *)arr->obj.vtable->klass;
812 ec = ac->element_class;
813
814 esize = mono_array_element_size (ac);
815 ea = (gpointer*)((char*)arr->vector + (pos * esize));
816
817 if (MONO_TYPE_IS_REFERENCE (&ec->byval_arg)) {
818 g_assert (esize == sizeof (gpointer));
819 mono_gc_wbarrier_generic_store (ea, *(MonoObject **)value);
820 } else {
821 g_assert (ec->inited);
822 g_assert (esize == mono_class_value_size (ec, NULL));
823 if (ec->has_references)
824 mono_gc_wbarrier_value_copy (ea, value, 1, ec);
825 else
826 mono_gc_memmove_atomic (ea, value, esize);
827 }
828 }
829
830 ICALL_EXPORT void
831 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray *array, MonoClassField *field_handle)
832 {
833 MonoClass *klass = array->obj.vtable->klass;
834 guint32 size = mono_array_element_size (klass);
835 MonoType *type = mono_type_get_underlying_type (&klass->element_class->byval_arg);
836 int align;
837 const char *field_data;
838
839 if (MONO_TYPE_IS_REFERENCE (type) || type->type == MONO_TYPE_VALUETYPE) {
840 MonoException *exc = mono_get_exception_argument("array",
841 "Cannot initialize array of non-primitive type.");
842 mono_set_pending_exception (exc);
843 return;
844 }
845
846 if (!(field_handle->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)) {
847 MonoException *exc = mono_get_exception_argument("field_handle",
848 "Field doesn't have an RVA");
849 mono_set_pending_exception (exc);
850 return;
851 }
852
853 size *= array->max_length;
854 field_data = mono_field_get_data (field_handle);
855
856 if (size > mono_type_size (field_handle->type, &align)) {
857 MonoException *exc = mono_get_exception_argument("field_handle",
858 "Field not large enough to fill array");
859 mono_set_pending_exception (exc);
860 return;
861 }
862
863 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
864 #define SWAP(n) { \
865 guint ## n *data = (guint ## n *) mono_array_addr (array, char, 0); \
866 guint ## n *src = (guint ## n *) field_data; \
867 int i, \
868 nEnt = (size / sizeof(guint ## n)); \
869 \
870 for (i = 0; i < nEnt; i++) { \
871 data[i] = read ## n (&src[i]); \
872 } \
873 }
874
875 /* printf ("Initialize array with elements of %s type\n", klass->element_class->name); */
876
877 switch (type->type) {
878 case MONO_TYPE_CHAR:
879 case MONO_TYPE_I2:
880 case MONO_TYPE_U2:
881 SWAP (16);
882 break;
883 case MONO_TYPE_I4:
884 case MONO_TYPE_U4:
885 case MONO_TYPE_R4:
886 SWAP (32);
887 break;
888 case MONO_TYPE_I8:
889 case MONO_TYPE_U8:
890 case MONO_TYPE_R8:
891 SWAP (64);
892 break;
893 default:
894 memcpy (mono_array_addr (array, char, 0), field_data, size);
895 break;
896 }
897 #else
898 memcpy (mono_array_addr (array, char, 0), field_data, size);
899 #endif
900 }
901
902 ICALL_EXPORT gint
903 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void)
904 {
905 return offsetof (MonoString, chars);
906 }
907
908 ICALL_EXPORT MonoObject *
909 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject *obj)
910 {
911 if ((obj == NULL) || (! (obj->vtable->klass->valuetype)))
912 return obj;
913 else {
914 MonoError error;
915 MonoObject *ret = mono_object_clone_checked (obj, &error);
916 mono_error_set_pending_exception (&error);
917
918 return ret;
919 }
920 }
921
922 ICALL_EXPORT void
923 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (MonoType *handle)
924 {
925 MonoError error;
926 MonoClass *klass;
927 MonoVTable *vtable;
928
929 MONO_CHECK_ARG_NULL (handle,);
930
931 klass = mono_class_from_mono_type (handle);
932 MONO_CHECK_ARG (handle, klass,);
933
934 if (klass->generic_container)
935 return;
936
937 vtable = mono_class_vtable_full (mono_domain_get (), klass, &error);
938 if (!is_ok (&error)) {
939 mono_error_set_pending_exception (&error);
940 return;
941 }
942
943 /* This will call the type constructor */
944 if (!mono_runtime_class_init_full (vtable, &error))
945 mono_error_set_pending_exception (&error);
946 }
947
948 ICALL_EXPORT void
949 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (MonoImage *image)
950 {
951 MonoError error;
952
953 mono_image_check_for_module_cctor (image);
954 if (image->has_module_cctor) {
955 MonoClass *module_klass = mono_class_get_checked (image, MONO_TOKEN_TYPE_DEF | 1, &error);
956 if (!mono_error_ok (&error)) {
957 mono_error_set_pending_exception (&error);
958 return;
959 }
960 /*It's fine to raise the exception here*/
961 MonoVTable * vtable = mono_class_vtable_full (mono_domain_get (), module_klass, &error);
962 if (!is_ok (&error)) {
963 mono_error_set_pending_exception (&error);
964 return;
965 }
966 if (!mono_runtime_class_init_full (vtable, &error))
967 mono_error_set_pending_exception (&error);
968 }
969 }
970
971 ICALL_EXPORT MonoBoolean
972 ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack (void)
973 {
974 guint8 *stack_addr;
975 guint8 *current;
976 size_t stack_size;
977 /* later make this configurable and per-arch */
978 int min_size = 4096 * 4 * sizeof (void*);
979 mono_thread_info_get_stack_bounds (&stack_addr, &stack_size);
980 /* if we have no info we are optimistic and assume there is enough room */
981 if (!stack_addr)
982 return TRUE;
983 #ifdef HOST_WIN32
984 // FIXME: Windows dynamically extends the stack, so stack_addr might be close
985 // to the current sp
986 return TRUE;
987 #endif
988 current = (guint8 *)&stack_addr;
989 if (current > stack_addr) {
990 if ((current - stack_addr) < min_size)
991 return FALSE;
992 } else {
993 if (current - (stack_addr - stack_size) < min_size)
994 return FALSE;
995 }
996 return TRUE;
997 }
998
999 ICALL_EXPORT MonoObject *
1000 ves_icall_System_Object_MemberwiseClone (MonoObject *this_obj)
1001 {
1002 MonoError error;
1003 MonoObject *ret = mono_object_clone_checked (this_obj, &error);
1004 mono_error_set_pending_exception (&error);
1005
1006 return ret;
1007 }
1008
1009 ICALL_EXPORT gint32
1010 ves_icall_System_ValueType_InternalGetHashCode (MonoObject *this_obj, MonoArray **fields)
1011 {
1012 MonoError error;
1013 MonoClass *klass;
1014 MonoObject **values = NULL;
1015 MonoObject *o;
1016 int count = 0;
1017 gint32 result = (int)(gsize)mono_defaults.int32_class;
1018 MonoClassField* field;
1019 gpointer iter;
1020
1021 klass = mono_object_class (this_obj);
1022
1023 if (mono_class_num_fields (klass) == 0)
1024 return result;
1025
1026 /*
1027 * Compute the starting value of the hashcode for fields of primitive
1028 * types, and return the remaining fields in an array to the managed side.
1029 * This way, we can avoid costly reflection operations in managed code.
1030 */
1031 iter = NULL;
1032 while ((field = mono_class_get_fields (klass, &iter))) {
1033 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
1034 continue;
1035 if (mono_field_is_deleted (field))
1036 continue;
1037 /* FIXME: Add more types */
1038 switch (field->type->type) {
1039 case MONO_TYPE_I4:
1040 result ^= *(gint32*)((guint8*)this_obj + field->offset);
1041 break;
1042 case MONO_TYPE_STRING: {
1043 MonoString *s;
1044 s = *(MonoString**)((guint8*)this_obj + field->offset);
1045 if (s != NULL)
1046 result ^= mono_string_hash (s);
1047 break;
1048 }
1049 default:
1050 if (!values)
1051 values = g_newa (MonoObject*, mono_class_num_fields (klass));
1052 o = mono_field_get_value_object_checked (mono_object_domain (this_obj), field, this_obj, &error);
1053 if (!is_ok (&error)) {
1054 mono_error_set_pending_exception (&error);
1055 return 0;
1056 }
1057 values [count++] = o;
1058 }
1059 }
1060
1061 if (values) {
1062 int i;
1063 MonoArray *fields_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.object_class, count, &error);
1064 if (mono_error_set_pending_exception (&error))
1065 return 0;
1066 mono_gc_wbarrier_generic_store (fields, (MonoObject*) fields_arr);
1067 for (i = 0; i < count; ++i)
1068 mono_array_setref (*fields, i, values [i]);
1069 } else {
1070 *fields = NULL;
1071 }
1072 return result;
1073 }
1074
1075 ICALL_EXPORT MonoBoolean
1076 ves_icall_System_ValueType_Equals (MonoObject *this_obj, MonoObject *that, MonoArray **fields)
1077 {
1078 MonoError error;
1079 MonoClass *klass;
1080 MonoObject **values = NULL;
1081 MonoObject *o;
1082 MonoClassField* field;
1083 gpointer iter;
1084 int count = 0;
1085
1086 MONO_CHECK_ARG_NULL (that, FALSE);
1087
1088 if (this_obj->vtable != that->vtable)
1089 return FALSE;
1090
1091 klass = mono_object_class (this_obj);
1092
1093 if (klass->enumtype && mono_class_enum_basetype (klass) && mono_class_enum_basetype (klass)->type == MONO_TYPE_I4)
1094 return (*(gint32*)((guint8*)this_obj + sizeof (MonoObject)) == *(gint32*)((guint8*)that + sizeof (MonoObject)));
1095
1096 /*
1097 * Do the comparison for fields of primitive type and return a result if
1098 * possible. Otherwise, return the remaining fields in an array to the
1099 * managed side. This way, we can avoid costly reflection operations in
1100 * managed code.
1101 */
1102 *fields = NULL;
1103 iter = NULL;
1104 while ((field = mono_class_get_fields (klass, &iter))) {
1105 if (field->type->attrs & FIELD_ATTRIBUTE_STATIC)
1106 continue;
1107 if (mono_field_is_deleted (field))
1108 continue;
1109 /* FIXME: Add more types */
1110 switch (field->type->type) {
1111 case MONO_TYPE_U1:
1112 case MONO_TYPE_I1:
1113 case MONO_TYPE_BOOLEAN:
1114 if (*((guint8*)this_obj + field->offset) != *((guint8*)that + field->offset))
1115 return FALSE;
1116 break;
1117 case MONO_TYPE_U2:
1118 case MONO_TYPE_I2:
1119 case MONO_TYPE_CHAR:
1120 if (*(gint16*)((guint8*)this_obj + field->offset) != *(gint16*)((guint8*)that + field->offset))
1121 return FALSE;
1122 break;
1123 case MONO_TYPE_U4:
1124 case MONO_TYPE_I4:
1125 if (*(gint32*)((guint8*)this_obj + field->offset) != *(gint32*)((guint8*)that + field->offset))
1126 return FALSE;
1127 break;
1128 case MONO_TYPE_U8:
1129 case MONO_TYPE_I8:
1130 if (*(gint64*)((guint8*)this_obj + field->offset) != *(gint64*)((guint8*)that + field->offset))
1131 return FALSE;
1132 break;
1133 case MONO_TYPE_R4:
1134 if (*(float*)((guint8*)this_obj + field->offset) != *(float*)((guint8*)that + field->offset))
1135 return FALSE;
1136 break;
1137 case MONO_TYPE_R8:
1138 if (*(double*)((guint8*)this_obj + field->offset) != *(double*)((guint8*)that + field->offset))
1139 return FALSE;
1140 break;
1141
1142
1143 case MONO_TYPE_STRING: {
1144 MonoString *s1, *s2;
1145 guint32 s1len, s2len;
1146 s1 = *(MonoString**)((guint8*)this_obj + field->offset);
1147 s2 = *(MonoString**)((guint8*)that + field->offset);
1148 if (s1 == s2)
1149 break;
1150 if ((s1 == NULL) || (s2 == NULL))
1151 return FALSE;
1152 s1len = mono_string_length (s1);
1153 s2len = mono_string_length (s2);
1154 if (s1len != s2len)
1155 return FALSE;
1156
1157 if (memcmp (mono_string_chars (s1), mono_string_chars (s2), s1len * sizeof (gunichar2)) != 0)
1158 return FALSE;
1159 break;
1160 }
1161 default:
1162 if (!values)
1163 values = g_newa (MonoObject*, mono_class_num_fields (klass) * 2);
1164 o = mono_field_get_value_object_checked (mono_object_domain (this_obj), field, this_obj, &error);
1165 if (!is_ok (&error)) {
1166 mono_error_set_pending_exception (&error);
1167 return FALSE;
1168 }
1169 values [count++] = o;
1170 o = mono_field_get_value_object_checked (mono_object_domain (this_obj), field, that, &error);
1171 if (!is_ok (&error)) {
1172 mono_error_set_pending_exception (&error);
1173 return FALSE;
1174 }
1175 values [count++] = o;
1176 }
1177
1178 if (klass->enumtype)
1179 /* enums only have one non-static field */
1180 break;
1181 }
1182
1183 if (values) {
1184 int i;
1185 MonoArray *fields_arr = mono_array_new_checked (mono_domain_get (), mono_defaults.object_class, count, &error);
1186 if (mono_error_set_pending_exception (&error))
1187 return FALSE;
1188 mono_gc_wbarrier_generic_store (fields, (MonoObject*) fields_arr);
1189 for (i = 0; i < count; ++i)
1190 mono_array_setref_fast (*fields, i, values [i]);
1191 return FALSE;
1192 } else {
1193 return TRUE;
1194 }
1195 }
1196
1197 ICALL_EXPORT MonoReflectionType *
1198 ves_icall_System_Object_GetType (MonoObject *obj)
1199 {
1200 MonoError error;
1201 MonoReflectionType *ret;
1202 #ifndef DISABLE_REMOTING
1203 if (obj->vtable->klass == mono_defaults.transparent_proxy_class)
1204 ret = mono_type_get_object_checked (mono_object_domain (obj), &((MonoTransparentProxy*)obj)->remote_class->proxy_class->byval_arg, &error);
1205 else
1206 #endif
1207 ret = mono_type_get_object_checked (mono_object_domain (obj), &obj->vtable->klass->byval_arg, &error);
1208
1209 mono_error_set_pending_exception (&error);
1210 return ret;
1211 }
1212
1213 ICALL_EXPORT void
1214 ves_icall_MonoType_type_from_obj (MonoReflectionType *mtype, MonoObject *obj)
1215 {
1216 mtype->type = &obj->vtable->klass->byval_arg;
1217 g_assert (mtype->type->type);
1218 }
1219
1220 ICALL_EXPORT gint32
1221 ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, gboolean create_open_instance)
1222 {
1223 MONO_CHECK_ARG_NULL (obj, 0);
1224
1225 MonoError error;
1226 gint32 result = mono_image_create_token (mb->dynamic_image, obj, create_open_instance, TRUE, &error);
1227 mono_error_set_pending_exception (&error);
1228 return result;
1229 }
1230
1231 ICALL_EXPORT gint32
1232 ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder *mb,
1233 MonoReflectionMethod *method,
1234 MonoArray *opt_param_types)
1235 {
1236 MONO_CHECK_ARG_NULL (method, 0);
1237
1238 MonoError error;
1239 gint32 result = mono_image_create_method_token (
1240 mb->dynamic_image, (MonoObject *) method, opt_param_types, &error);
1241 mono_error_set_pending_exception (&error);
1242 return result;
1243 }
1244
1245 ICALL_EXPORT void
1246 ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file)
1247 {
1248 MonoError error;
1249 mono_image_create_pefile (mb, file, &error);
1250 mono_error_set_pending_exception (&error);
1251 }
1252
1253 ICALL_EXPORT void
1254 ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
1255 {
1256 MonoError error;
1257 mono_image_build_metadata (mb, &error);
1258 mono_error_set_pending_exception (&error);
1259 }
1260
1261 ICALL_EXPORT void
1262 ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder *mb, MonoObject *obj, guint32 token)
1263 {
1264 mono_image_register_token (mb->dynamic_image, token, obj);
1265 }
1266
1267 ICALL_EXPORT MonoObject*
1268 ves_icall_ModuleBuilder_GetRegisteredToken (MonoReflectionModuleBuilder *mb, guint32 token)
1269 {
1270 MonoObject *obj;
1271
1272 mono_loader_lock ();
1273 obj = (MonoObject *)mono_g_hash_table_lookup (mb->dynamic_image->tokens, GUINT_TO_POINTER (token));
1274 mono_loader_unlock ();
1275
1276 return obj;
1277 }
1278
1279 ICALL_EXPORT MonoReflectionModule*
1280 ves_icall_System_Reflection_Emit_AssemblyBuilder_InternalAddModule (MonoReflectionAssemblyBuilder *ab, MonoString *fileName)
1281 {
1282 MonoError error;
1283 MonoReflectionModule *result = mono_image_load_module_dynamic (ab, fileName, &error);
1284 mono_error_set_pending_exception (&error);
1285 return result;
1286 }
1287
1288 /**
1289 * ves_icall_System_Reflection_Emit_TypeBuilder_create_generic_class:
1290 * @tb: a TypeBuilder object
1291 *
1292 * (icall)
1293 * Creates the generic class after all generic parameters have been added.
1294 */
1295 ICALL_EXPORT void
1296 ves_icall_System_Reflection_Emit_TypeBuilder_create_generic_class (MonoReflectionTypeBuilder *tb)
1297 {
1298 MonoError error;
1299 (void) mono_reflection_create_generic_class (tb, &error);
1300 mono_error_set_pending_exception (&error);
1301 }
1302
1303 #ifndef DISABLE_REFLECTION_EMIT
1304 ICALL_EXPORT MonoArray*
1305 ves_icall_System_Reflection_Emit_CustomAttributeBuilder_GetBlob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
1306 {
1307 MonoError error;
1308 MonoArray *result = mono_reflection_get_custom_attrs_blob_checked (assembly, ctor, ctorArgs, properties, propValues, fields, fieldValues, &error);
1309 mono_error_set_pending_exception (&error);
1310 return result;
1311 }
1312 #endif
1313
1314 static gboolean
1315 get_executing (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1316 {
1317 MonoMethod **dest = (MonoMethod **)data;
1318
1319 /* skip unmanaged frames */
1320 if (!managed)
1321 return FALSE;
1322
1323 if (!(*dest)) {
1324 if (!strcmp (m->klass->name_space, "System.Reflection"))
1325 return FALSE;
1326 *dest = m;
1327 return TRUE;
1328 }
1329 return FALSE;
1330 }
1331
1332 static gboolean
1333 get_caller_no_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1334 {
1335 MonoMethod **dest = (MonoMethod **)data;
1336
1337 /* skip unmanaged frames */
1338 if (!managed)
1339 return FALSE;
1340
1341 if (m->wrapper_type != MONO_WRAPPER_NONE)
1342 return FALSE;
1343
1344 if (m == *dest) {
1345 *dest = NULL;
1346 return FALSE;
1347 }
1348
1349 if (m->klass->image == mono_defaults.corlib && !strcmp (m->klass->name_space, "System.Reflection"))
1350 return FALSE;
1351
1352 if (!(*dest)) {
1353 *dest = m;
1354 return TRUE;
1355 }
1356 return FALSE;
1357 }
1358
1359 static gboolean
1360 get_caller_no_system_or_reflection (MonoMethod *m, gint32 no, gint32 ilo, gboolean managed, gpointer data)
1361 {
1362 MonoMethod **dest = (MonoMethod **)data;
1363
1364 /* skip unmanaged frames */
1365 if (!managed)
1366 return FALSE;
1367
1368 if (m->wrapper_type != MONO_WRAPPER_NONE)
1369 return FALSE;
1370
1371 if (m == *dest) {
1372 *dest = NULL;
1373 return FALSE;
1374 }
1375
1376 if (m->klass->image == mono_defaults.corlib && ((!strcmp (m->klass->name_space, "System.Reflection"))
1377 || (!strcmp (m->klass->name_space, "System"))))
1378 return FALSE;
1379
1380 if (!(*dest)) {
1381 *dest = m;
1382 return TRUE;
1383 }
1384 return FALSE;
1385 }
1386
1387 static MonoReflectionType *
1388 type_from_parsed_name (MonoTypeNameParse *info, MonoBoolean ignoreCase, MonoError *error)
1389 {
1390 MonoMethod *m, *dest;
1391
1392 MonoType *type = NULL;
1393 MonoAssembly *assembly = NULL;
1394 gboolean type_resolve = FALSE;
1395 MonoImage *rootimage = NULL;
1396
1397 mono_error_init (error);
1398
1399 /*
1400 * We must compute the calling assembly as type loading must happen under a metadata context.
1401 * For example. The main assembly is a.exe and Type.GetType is called from dir/b.dll. Without
1402 * the metadata context (basedir currently) set to dir/b.dll we won't be able to load a dir/c.dll.
1403 */
1404 m = mono_method_get_last_managed ();
1405 dest = m;
1406 if (m && m->klass->image != mono_defaults.corlib) {
1407 /* Happens with inlining */
1408 } else {
1409 /* Ugly hack: type_from_parsed_name is called from
1410 * System.Type.internal_from_name, which is called most
1411 * directly from System.Type.GetType(string,bool,bool) but
1412 * also indirectly from places such as
1413 * System.Type.GetType(string,func,func) (via
1414 * System.TypeNameParser.GetType and System.TypeSpec.Resolve)
1415 * so we need to skip over all of those to find the true caller.
1416 *
1417 * It would be nice if we had stack marks.
1418 */
1419 mono_stack_walk_no_il (get_caller_no_system_or_reflection, &dest);
1420 if (!dest)
1421 dest = m;
1422 }
1423
1424 /*
1425 * FIXME: mono_method_get_last_managed() sometimes returns NULL, thus
1426 * causing ves_icall_System_Reflection_Assembly_GetCallingAssembly()
1427 * to crash. This only seems to happen in some strange remoting
1428 * scenarios and I was unable to figure out what's happening there.
1429 * Dec 10, 2005 - Martin.
1430 */
1431
1432 if (dest) {
1433 assembly = dest->klass->image->assembly;
1434 type_resolve = TRUE;
1435 rootimage = assembly->image;
1436 } else {
1437 g_warning (G_STRLOC);
1438 }
1439
1440 if (info->assembly.name)
1441 assembly = mono_assembly_load (&info->assembly, assembly ? assembly->basedir : NULL, NULL);
1442
1443 if (assembly) {
1444 /* When loading from the current assembly, AppDomain.TypeResolve will not be called yet */
1445 type = mono_reflection_get_type_checked (rootimage, assembly->image, info, ignoreCase, &type_resolve, error);
1446 return_val_if_nok (error, NULL);
1447 }
1448
1449 // XXXX - aleksey -
1450 // Say we're looking for System.Generic.Dict<int, Local>
1451 // we FAIL the get type above, because S.G.Dict isn't in assembly->image. So we drop down here.
1452 // but then we FAIL AGAIN because now we pass null as the image and the rootimage and everything
1453 // is messed up when we go to construct the Local as the type arg...
1454 //
1455 // By contrast, if we started with Mine<System.Generic.Dict<int, Local>> we'd go in with assembly->image
1456 // as the root and then even the detour into generics would still not screw us when we went to load Local.
1457 if (!info->assembly.name && !type) {
1458 /* try mscorlib */
1459 type = mono_reflection_get_type_checked (rootimage, NULL, info, ignoreCase, &type_resolve, error);
1460 return_val_if_nok (error, NULL);
1461 }
1462 if (assembly && !type && type_resolve) {
1463 type_resolve = FALSE; /* This will invoke TypeResolve if not done in the first 'if' */
1464 type = mono_reflection_get_type_checked (rootimage, assembly->image, info, ignoreCase, &type_resolve, error);
1465 return_val_if_nok (error, NULL);
1466 }
1467
1468 if (!type)
1469 return NULL;
1470
1471 return mono_type_get_object_checked (mono_domain_get (), type, error);
1472 }
1473
1474 ICALL_EXPORT MonoReflectionType*
1475 ves_icall_System_Type_internal_from_name (MonoString *name,
1476 MonoBoolean throwOnError,
1477 MonoBoolean ignoreCase)
1478 {
1479 MonoError error;
1480 char *str = mono_string_to_utf8 (name);
1481 MonoTypeNameParse info;
1482 MonoReflectionType *type;
1483 gboolean parsedOk;
1484
1485 parsedOk = mono_reflection_parse_type (str, &info);
1486
1487 /* mono_reflection_parse_type() mangles the string */
1488 if (!parsedOk) {
1489 mono_reflection_free_type_info (&info);
1490 if (throwOnError) {
1491 mono_error_init (&error);
1492 mono_error_set_argument (&error, "typeName", "failed parse: %s", str);
1493 mono_error_set_pending_exception (&error);
1494 }
1495 g_free (str);
1496 return NULL;
1497 }
1498
1499 type = type_from_parsed_name (&info, ignoreCase, &error);
1500
1501 mono_reflection_free_type_info (&info);
1502 g_free (str);
1503
1504 if (!mono_error_ok (&error)) {
1505 if (throwOnError)
1506 mono_error_set_pending_exception (&error);
1507 else
1508 mono_error_cleanup (&error);
1509 return NULL;
1510 }
1511
1512 if (type == NULL){
1513 MonoException *e = NULL;
1514
1515 if (throwOnError)
1516 e = mono_get_exception_type_load (name, NULL);
1517
1518 if (e) {
1519 mono_set_pending_exception (e);
1520 return NULL;
1521 }
1522 }
1523
1524 return type;
1525 }
1526
1527
1528 ICALL_EXPORT MonoReflectionType*
1529 ves_icall_System_Type_internal_from_handle (MonoType *handle)
1530 {
1531 MonoError error;
1532 MonoReflectionType *ret;
1533 MonoDomain *domain = mono_domain_get ();
1534
1535 ret = mono_type_get_object_checked (domain, handle, &error);
1536 mono_error_set_pending_exception (&error);
1537
1538 return ret;
1539 }
1540
1541 /* System.TypeCode */
1542 typedef enum {
1543 TYPECODE_EMPTY,
1544 TYPECODE_OBJECT,
1545 TYPECODE_DBNULL,
1546 TYPECODE_BOOLEAN,
1547 TYPECODE_CHAR,
1548 TYPECODE_SBYTE,
1549 TYPECODE_BYTE,
1550 TYPECODE_INT16,
1551 TYPECODE_UINT16,
1552 TYPECODE_INT32,
1553 TYPECODE_UINT32,
1554 TYPECODE_INT64,
1555 TYPECODE_UINT64,
1556 TYPECODE_SINGLE,
1557 TYPECODE_DOUBLE,
1558 TYPECODE_DECIMAL,
1559 TYPECODE_DATETIME,
1560 TYPECODE_STRING = 18
1561 } TypeCode;
1562
1563 ICALL_EXPORT guint32
1564 ves_icall_type_GetTypeCodeInternal (MonoReflectionType *type)
1565 {
1566 int t = type->type->type;
1567
1568 if (type->type->byref)
1569 return TYPECODE_OBJECT;
1570
1571 handle_enum:
1572 switch (t) {
1573 case MONO_TYPE_VOID:
1574 return TYPECODE_OBJECT;
1575 case MONO_TYPE_BOOLEAN:
1576 return TYPECODE_BOOLEAN;
1577 case MONO_TYPE_U1:
1578 return TYPECODE_BYTE;
1579 case MONO_TYPE_I1:
1580 return TYPECODE_SBYTE;
1581 case MONO_TYPE_U2:
1582 return TYPECODE_UINT16;
1583 case MONO_TYPE_I2:
1584 return TYPECODE_INT16;
1585 case MONO_TYPE_CHAR:
1586 return TYPECODE_CHAR;
1587 case MONO_TYPE_PTR:
1588 case MONO_TYPE_U:
1589 case MONO_TYPE_I:
1590 return TYPECODE_OBJECT;
1591 case MONO_TYPE_U4:
1592 return TYPECODE_UINT32;
1593 case MONO_TYPE_I4:
1594 return TYPECODE_INT32;
1595 case MONO_TYPE_U8:
1596 return TYPECODE_UINT64;
1597 case MONO_TYPE_I8:
1598 return TYPECODE_INT64;
1599 case MONO_TYPE_R4:
1600 return TYPECODE_SINGLE;
1601 case MONO_TYPE_R8:
1602 return TYPECODE_DOUBLE;
1603 case MONO_TYPE_VALUETYPE: {
1604 MonoClass *klass = type->type->data.klass;
1605
1606 if (klass->enumtype) {
1607 t = mono_class_enum_basetype (klass)->type;
1608 goto handle_enum;
1609 } else if (mono_is_corlib_image (klass->image)) {
1610 if (strcmp (klass->name_space, "System") == 0) {
1611 if (strcmp (klass->name, "Decimal") == 0)
1612 return TYPECODE_DECIMAL;
1613 else if (strcmp (klass->name, "DateTime") == 0)
1614 return TYPECODE_DATETIME;
1615 }
1616 }
1617 return TYPECODE_OBJECT;
1618 }
1619 case MONO_TYPE_STRING:
1620 return TYPECODE_STRING;
1621 case MONO_TYPE_SZARRAY:
1622 case MONO_TYPE_ARRAY:
1623 case MONO_TYPE_OBJECT:
1624 case MONO_TYPE_VAR:
1625 case MONO_TYPE_MVAR:
1626 case MONO_TYPE_TYPEDBYREF:
1627 return TYPECODE_OBJECT;
1628 case MONO_TYPE_CLASS:
1629 {
1630 MonoClass *klass = type->type->data.klass;
1631 if (klass->image == mono_defaults.corlib && strcmp (klass->name_space, "System") == 0) {
1632 if (strcmp (klass->name, "DBNull") == 0)
1633 return TYPECODE_DBNULL;
1634 }
1635 }
1636 return TYPECODE_OBJECT;
1637 case MONO_TYPE_GENERICINST:
1638 return TYPECODE_OBJECT;
1639 default:
1640 g_error ("type 0x%02x not handled in GetTypeCode()", t);
1641 }
1642 return 0;
1643 }
1644
1645 static gboolean
1646 mono_type_is_primitive (MonoType *type)
1647 {
1648 return (type->type >= MONO_TYPE_BOOLEAN && type->type <= MONO_TYPE_R8) ||
1649 type-> type == MONO_TYPE_I || type->type == MONO_TYPE_U;
1650 }
1651
1652 static MonoType*
1653 mono_type_get_underlying_type_ignore_byref (MonoType *type)
1654 {
1655 if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype)
1656 return mono_class_enum_basetype (type->data.klass);
1657 if (type->type == MONO_TYPE_GENERICINST && type->data.generic_class->container_class->enumtype)
1658 return mono_class_enum_basetype (type->data.generic_class->container_class);
1659 return type;
1660 }
1661
1662 ICALL_EXPORT guint32
1663 ves_icall_RuntimeTypeHandle_type_is_assignable_from (MonoReflectionType *type, MonoReflectionType *c)
1664 {
1665 MonoClass *klass;
1666 MonoClass *klassc;
1667
1668 g_assert (type != NULL);
1669
1670 klass = mono_class_from_mono_type (type->type);
1671 klassc = mono_class_from_mono_type (c->type);
1672
1673 if (type->type->byref ^ c->type->byref)
1674 return FALSE;
1675
1676 if (type->type->byref) {
1677 MonoType *t = mono_type_get_underlying_type_ignore_byref (type->type);
1678 MonoType *ot = mono_type_get_underlying_type_ignore_byref (c->type);
1679
1680 klass = mono_class_from_mono_type (t);
1681 klassc = mono_class_from_mono_type (ot);
1682
1683 if (mono_type_is_primitive (t)) {
1684 return mono_type_is_primitive (ot) && klass->instance_size == klassc->instance_size;
1685 } else if (t->type == MONO_TYPE_VAR || t->type == MONO_TYPE_MVAR) {
1686 return t->type == ot->type && t->data.generic_param->num == ot->data.generic_param->num;
1687 } else if (t->type == MONO_TYPE_PTR || t->type == MONO_TYPE_FNPTR) {
1688 return t->type == ot->type;
1689 } else {
1690 if (ot->type == MONO_TYPE_VAR || ot->type == MONO_TYPE_MVAR)
1691 return FALSE;
1692
1693 if (klass->valuetype)
1694 return klass == klassc;
1695 return klass->valuetype == klassc->valuetype;
1696 }
1697 }
1698 return mono_class_is_assignable_from (klass, klassc);
1699 }
1700
1701 ICALL_EXPORT guint32
1702 ves_icall_RuntimeTypeHandle_IsInstanceOfType (MonoReflectionType *type, MonoObject *obj)
1703 {
1704 MonoError error;
1705 MonoClass *klass = mono_class_from_mono_type (type->type);
1706 mono_class_init_checked (klass, &error);
1707 if (!is_ok (&error)) {
1708 mono_error_set_pending_exception (&error);
1709 return FALSE;
1710 }
1711 guint32 result = (mono_object_isinst_checked (obj, klass, &error) != NULL);
1712 mono_error_set_pending_exception (&error);
1713 return result;
1714 }
1715
1716 ICALL_EXPORT guint32
1717 ves_icall_RuntimeTypeHandle_GetAttributes (MonoReflectionType *type)
1718 {
1719 MonoClass *klass = mono_class_from_mono_type (type->type);
1720 return klass->flags;
1721 }
1722
1723 ICALL_EXPORT MonoReflectionMarshalAsAttribute*
1724 ves_icall_System_Reflection_FieldInfo_get_marshal_info (MonoReflectionField *field)
1725 {
1726 MonoError error;
1727 MonoClass *klass = field->field->parent;
1728 MonoMarshalType *info;
1729 MonoType *ftype;
1730 int i;
1731
1732 if (klass->generic_container ||
1733 (klass->generic_class && klass->generic_class->context.class_inst->is_open))
1734 return NULL;
1735
1736 ftype = mono_field_get_type (field->field);
1737 if (ftype && !(ftype->attrs & FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL))
1738 return NULL;
1739
1740 info = mono_marshal_load_type_info (klass);
1741
1742 for (i = 0; i < info->num_fields; ++i) {
1743 if (info->fields [i].field == field->field) {
1744 if (!info->fields [i].mspec)
1745 return NULL;
1746 else {
1747 MonoReflectionMarshalAsAttribute* obj;
1748 obj = mono_reflection_marshal_as_attribute_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec, &error);
1749 if (!mono_error_ok (&error))
1750 mono_error_set_pending_exception (&error);
1751 return obj;
1752 }
1753 }
1754 }
1755
1756 return NULL;
1757 }
1758
1759 ICALL_EXPORT MonoReflectionField*
1760 ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField *handle, MonoType *type)
1761 {
1762 MonoError error;
1763 gboolean found = FALSE;
1764 MonoClass *klass;
1765 MonoClass *k;
1766
1767 g_assert (handle);
1768
1769 if (!type) {
1770 klass = handle->parent;
1771 } else {
1772 klass = mono_class_from_mono_type (type);
1773
1774 /* Check that the field belongs to the class */
1775 for (k = klass; k; k = k->parent) {
1776 if (k == handle->parent) {
1777 found = TRUE;
1778 break;
1779 }
1780 }
1781
1782 if (!found)
1783 /* The managed code will throw the exception */
1784 return NULL;
1785 }
1786
1787 MonoReflectionField *result = mono_field_get_object_checked (mono_domain_get (), klass, handle, &error);
1788 mono_error_set_pending_exception (&error);
1789 return result;
1790 }
1791
1792 ICALL_EXPORT MonoArray*
1793 ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField *field, MonoBoolean optional)
1794 {
1795 MonoError error;
1796 MonoType *type = mono_field_get_type_checked (field->field, &error);
1797 MonoArray *res;
1798
1799 if (!mono_error_ok (&error)) {
1800 mono_error_set_pending_exception (&error);
1801 return NULL;
1802 }
1803
1804 res = type_array_from_modifiers (field->field->parent->image, type, optional, &error);
1805 mono_error_set_pending_exception (&error);
1806 return res;
1807 }
1808
1809 ICALL_EXPORT int
1810 vell_icall_get_method_attributes (MonoMethod *method)
1811 {
1812 return method->flags;
1813 }
1814
1815 ICALL_EXPORT void
1816 ves_icall_get_method_info (MonoMethod *method, MonoMethodInfo *info)
1817 {
1818 MonoError error;
1819 MonoReflectionType *rt;
1820 MonoDomain *domain = mono_domain_get ();
1821 MonoMethodSignature* sig;
1822
1823 sig = mono_method_signature_checked (method, &error);
1824 if (!mono_error_ok (&error)) {
1825 mono_error_set_pending_exception (&error);
1826 return;
1827 }
1828
1829 rt = mono_type_get_object_checked (domain, &method->klass->byval_arg, &error);
1830 if (!mono_error_ok (&error)) {
1831 mono_error_set_pending_exception (&error);
1832 return;
1833 }
1834
1835 MONO_STRUCT_SETREF (info, parent, rt);
1836
1837 rt = mono_type_get_object_checked (domain, sig->ret, &error);
1838 if (!mono_error_ok (&error)) {
1839 mono_error_set_pending_exception (&error);
1840 return;
1841 }
1842
1843 MONO_STRUCT_SETREF (info, ret, rt);
1844
1845 info->attrs = method->flags;
1846 info->implattrs = method->iflags;
1847 if (sig->call_convention == MONO_CALL_DEFAULT)
1848 info->callconv = sig->sentinelpos >= 0 ? 2 : 1;
1849 else {
1850 if (sig->call_convention == MONO_CALL_VARARG || sig->sentinelpos >= 0)
1851 info->callconv = 2;
1852 else
1853 info->callconv = 1;
1854 }
1855 info->callconv |= (sig->hasthis << 5) | (sig->explicit_this << 6);
1856 }
1857
1858 ICALL_EXPORT MonoArray*
1859 ves_icall_get_parameter_info (MonoMethod *method, MonoReflectionMethod *member)
1860 {
1861 MonoError error;
1862 MonoDomain *domain = mono_domain_get ();
1863
1864 MonoArray *result = mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL, &error);
1865 mono_error_set_pending_exception (&error);
1866 return result;
1867 }
1868
1869 ICALL_EXPORT MonoReflectionMarshalAsAttribute*
1870 ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod *method)
1871 {
1872 MonoError error;
1873 MonoDomain *domain = mono_domain_get ();
1874 MonoReflectionMarshalAsAttribute* res = NULL;
1875 MonoMarshalSpec **mspecs;
1876 int i;
1877
1878 mspecs = g_new (MonoMarshalSpec*, mono_method_signature (method)->param_count + 1);
1879 mono_method_get_marshal_info (method, mspecs);
1880
1881 if (mspecs [0]) {
1882 res = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [0], &error);
1883 if (!mono_error_ok (&error)) {
1884 mono_error_set_pending_exception (&error);
1885 return NULL;
1886 }
1887 }
1888
1889 for (i = mono_method_signature (method)->param_count; i >= 0; i--)
1890 if (mspecs [i])
1891 mono_metadata_free_marshal_spec (mspecs [i]);
1892 g_free (mspecs);
1893
1894 return res;
1895 }
1896
1897 ICALL_EXPORT gint32
1898 ves_icall_MonoField_GetFieldOffset (MonoReflectionField *field)
1899 {
1900 MonoClass *parent = field->field->parent;
1901 if (!parent->size_inited)
1902 mono_class_init (parent);
1903 mono_class_setup_fields_locking (parent);
1904
1905 return field->field->offset - sizeof (MonoObject);
1906 }
1907
1908 ICALL_EXPORT MonoReflectionType*
1909 ves_icall_MonoField_GetParentType (MonoReflectionField *field, MonoBoolean declaring)
1910 {
1911 MonoError error;
1912 MonoReflectionType *ret;
1913 MonoClass *parent;
1914
1915 parent = declaring? field->field->parent: field->klass;
1916
1917 ret = mono_type_get_object_checked (mono_object_domain (field), &parent->byval_arg, &error);
1918 mono_error_set_pending_exception (&error);
1919
1920 return ret;
1921
1922 }
1923
1924 ICALL_EXPORT MonoObject *
1925 ves_icall_MonoField_GetValueInternal (MonoReflectionField *field, MonoObject *obj)
1926 {
1927 MonoError error;
1928 MonoClass *fklass = field->klass;
1929 MonoClassField *cf = field->field;
1930 MonoDomain *domain = mono_object_domain (field);
1931
1932 if (fklass->image->assembly->ref_only) {
1933 mono_set_pending_exception (mono_get_exception_invalid_operation (
1934 "It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods."));
1935 return NULL;
1936 }
1937
1938 if (mono_security_core_clr_enabled () &&
1939 !mono_security_core_clr_ensure_reflection_access_field (cf, &error)) {
1940 mono_error_set_pending_exception (&error);
1941 return NULL;
1942 }
1943
1944 MonoObject * result = mono_field_get_value_object_checked (domain, cf, obj, &error);
1945 mono_error_set_pending_exception (&error);
1946 return result;
1947 }
1948
1949 ICALL_EXPORT void
1950 ves_icall_MonoField_SetValueInternal (MonoReflectionField *field, MonoObject *obj, MonoObject *value)
1951 {
1952 MonoError error;
1953 MonoClassField *cf = field->field;
1954 MonoType *type;
1955 gchar *v;
1956
1957 if (field->klass->image->assembly->ref_only) {
1958 mono_set_pending_exception (mono_get_exception_invalid_operation (
1959 "It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods."));
1960 return;
1961 }
1962
1963 if (mono_security_core_clr_enabled () &&
1964 !mono_security_core_clr_ensure_reflection_access_field (cf, &error)) {
1965 mono_error_set_pending_exception (&error);
1966 return;
1967 }
1968
1969 type = mono_field_get_type_checked (cf, &error);
1970 if (!mono_error_ok (&error)) {
1971 mono_error_set_pending_exception (&error);
1972 return;
1973 }
1974
1975 v = (gchar *) value;
1976 if (!type->byref) {
1977 switch (type->type) {
1978 case MONO_TYPE_U1:
1979 case MONO_TYPE_I1:
1980 case MONO_TYPE_BOOLEAN:
1981 case MONO_TYPE_U2:
1982 case MONO_TYPE_I2:
1983 case MONO_TYPE_CHAR:
1984 case MONO_TYPE_U:
1985 case MONO_TYPE_I:
1986 case MONO_TYPE_U4:
1987 case MONO_TYPE_I4:
1988 case MONO_TYPE_R4:
1989 case MONO_TYPE_U8:
1990 case MONO_TYPE_I8:
1991 case MONO_TYPE_R8:
1992 case MONO_TYPE_VALUETYPE:
1993 case MONO_TYPE_PTR:
1994 if (v != NULL)
1995 v += sizeof (MonoObject);
1996 break;
1997 case MONO_TYPE_STRING:
1998 case MONO_TYPE_OBJECT:
1999 case MONO_TYPE_CLASS:
2000 case MONO_TYPE_ARRAY:
2001 case MONO_TYPE_SZARRAY:
2002 /* Do nothing */
2003 break;
2004 case MONO_TYPE_GENERICINST: {
2005 MonoGenericClass *gclass = type->data.generic_class;
2006 g_assert (!gclass->context.class_inst->is_open);
2007
2008 if (mono_class_is_nullable (mono_class_from_mono_type (type))) {
2009 MonoClass *nklass = mono_class_from_mono_type (type);
2010 MonoObject *nullable;
2011
2012 /*
2013 * Convert the boxed vtype into a Nullable structure.
2014 * This is complicated by the fact that Nullables have
2015 * a variable structure.
2016 */
2017 nullable = mono_object_new_checked (mono_domain_get (), nklass, &error);
2018 if (!mono_error_ok (&error)) {
2019 mono_error_set_pending_exception (&error);
2020 return;
2021 }
2022
2023 mono_nullable_init ((guint8 *)mono_object_unbox (nullable), value, nklass);
2024
2025 v = (gchar *)mono_object_unbox (nullable);
2026 }
2027 else
2028 if (gclass->container_class->valuetype && (v != NULL))
2029 v += sizeof (MonoObject);
2030 break;
2031 }
2032 default:
2033 g_error ("type 0x%x not handled in "
2034 "ves_icall_FieldInfo_SetValueInternal", type->type);
2035 return;
2036 }
2037 }
2038
2039 if (type->attrs & FIELD_ATTRIBUTE_STATIC) {
2040 MonoVTable *vtable = mono_class_vtable_full (mono_object_domain (field), cf->parent, &error);
2041 if (!is_ok (&error)) {
2042 mono_error_set_pending_exception (&error);
2043 return;
2044 }
2045 if (!vtable->initialized) {
2046 if (!mono_runtime_class_init_full (vtable, &error)) {
2047 mono_error_set_pending_exception (&error);
2048 return;
2049 }
2050 }
2051 mono_field_static_set_value (vtable, cf, v);
2052 } else {
2053 mono_field_set_value (obj, cf, v);
2054 }
2055 }
2056
2057 ICALL_EXPORT void
2058 ves_icall_System_RuntimeFieldHandle_SetValueDirect (MonoReflectionField *field, MonoReflectionType *field_type, MonoTypedRef *obj, MonoObject *value, MonoReflectionType *context_type)
2059 {
2060 MonoClassField *f;
2061
2062 g_assert (field);
2063 g_assert (obj);
2064 g_assert (value);
2065
2066 f = field->field;
2067 if (!MONO_TYPE_ISSTRUCT (&f->parent->byval_arg)) {
2068 mono_set_pending_exception (mono_get_exception_not_implemented (NULL));
2069 return;
2070 }
2071
2072 if (MONO_TYPE_IS_REFERENCE (f->type))
2073 mono_copy_value (f->type, (guint8*)obj->value + f->offset - sizeof (MonoObject), value, FALSE);
2074 else
2075 mono_copy_value (f->type, (guint8*)obj->value + f->offset - sizeof (MonoObject), mono_object_unbox (value), FALSE);
2076 }
2077
2078 ICALL_EXPORT MonoObject *
2079 ves_icall_MonoField_GetRawConstantValue (MonoReflectionField *rfield)
2080 {
2081 MonoObject *o = NULL;
2082 MonoClassField *field = rfield->field;
2083 MonoClass *klass;
2084 MonoDomain *domain = mono_object_domain (rfield);
2085 gchar *v;
2086 MonoTypeEnum def_type;
2087 const char *def_value;
2088 MonoType *t;
2089 MonoError error;
2090
2091 mono_class_init (field->parent);
2092
2093 t = mono_field_get_type_checked (field, &error);
2094 if (!mono_error_ok (&error)) {
2095 mono_error_set_pending_exception (&error);
2096 return NULL;
2097 }
2098
2099 if (!(t->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)) {
2100 mono_set_pending_exception (mono_get_exception_invalid_operation (NULL));
2101 return NULL;
2102 }
2103
2104 if (image_is_dynamic (field->parent->image)) {
2105 MonoClass *klass = field->parent;
2106 int fidx = field - klass->fields;
2107
2108 g_assert (fidx >= 0 && fidx < klass->field.count);
2109 g_assert (klass->ext);
2110 g_assert (klass->ext->field_def_values);
2111 def_type = klass->ext->field_def_values [fidx].def_type;
2112 def_value = klass->ext->field_def_values [fidx].data;
2113 if (def_type == MONO_TYPE_END) {
2114 mono_set_pending_exception (mono_get_exception_invalid_operation (NULL));
2115 return NULL;
2116 }
2117 } else {
2118 def_value = mono_class_get_field_default_value (field, &def_type);
2119 /* FIXME, maybe we should try to raise TLE if field->parent is broken */
2120 if (!def_value) {
2121 mono_set_pending_exception (mono_get_exception_invalid_operation (NULL));
2122 return NULL;
2123 }
2124 }
2125
2126 /*FIXME unify this with reflection.c:mono_get_object_from_blob*/
2127 switch (def_type) {
2128 case MONO_TYPE_U1:
2129 case MONO_TYPE_I1:
2130 case MONO_TYPE_BOOLEAN:
2131 case MONO_TYPE_U2:
2132 case MONO_TYPE_I2:
2133 case MONO_TYPE_CHAR:
2134 case MONO_TYPE_U:
2135 case MONO_TYPE_I:
2136 case MONO_TYPE_U4:
2137 case MONO_TYPE_I4:
2138 case MONO_TYPE_R4:
2139 case MONO_TYPE_U8:
2140 case MONO_TYPE_I8:
2141 case MONO_TYPE_R8: {
2142 MonoType *t;
2143
2144 /* boxed value type */
2145 t = g_new0 (MonoType, 1);
2146 t->type = def_type;
2147 klass = mono_class_from_mono_type (t);
2148 g_free (t);
2149 o = mono_object_new_checked (domain, klass, &error);
2150 if (!mono_error_ok (&error)) {
2151 mono_error_set_pending_exception (&error);
2152 return NULL;
2153 }
2154 v = ((gchar *) o) + sizeof (MonoObject);
2155 mono_get_constant_value_from_blob (domain, def_type, def_value, v, &error);
2156 if (mono_error_set_pending_exception (&error))
2157 return NULL;
2158 break;
2159 }
2160 case MONO_TYPE_STRING:
2161 case MONO_TYPE_CLASS:
2162 mono_get_constant_value_from_blob (domain, def_type, def_value, &o, &error);
2163 if (mono_error_set_pending_exception (&error))
2164 return NULL;
2165 break;
2166 default:
2167 g_assert_not_reached ();
2168 }
2169
2170 return o;
2171 }
2172
2173 ICALL_EXPORT MonoReflectionType*
2174 ves_icall_MonoField_ResolveType (MonoReflectionField *ref_field)
2175 {
2176 MonoError error;
2177 MonoReflectionType *ret;
2178 MonoType *type;
2179
2180 type = mono_field_get_type_checked (ref_field->field, &error);
2181 if (!mono_error_ok (&error)) {
2182 mono_error_set_pending_exception (&error);
2183 return NULL;
2184 }
2185
2186 ret = mono_type_get_object_checked (mono_object_domain (ref_field), type, &error);
2187 if (!mono_error_ok (&error)) {
2188 mono_error_set_pending_exception (&error);
2189 return NULL;
2190 }
2191
2192 return ret;
2193 }
2194
2195 /* From MonoProperty.cs */
2196 typedef enum {
2197 PInfo_Attributes = 1,
2198 PInfo_GetMethod = 1 << 1,
2199 PInfo_SetMethod = 1 << 2,
2200 PInfo_ReflectedType = 1 << 3,
2201 PInfo_DeclaringType = 1 << 4,
2202 PInfo_Name = 1 << 5
2203 } PInfo;
2204
2205 ICALL_EXPORT void
2206 ves_icall_MonoPropertyInfo_get_property_info (const MonoReflectionProperty *property, MonoPropertyInfo *info, PInfo req_info)
2207 {
2208 MonoError error;
2209 MonoReflectionType *rt;
2210 MonoReflectionMethod *rm;
2211 MonoDomain *domain = mono_object_domain (property);
2212 const MonoProperty *pproperty = property->property;
2213
2214 if ((req_info & PInfo_ReflectedType) != 0) {
2215 rt = mono_type_get_object_checked (domain, &property->klass->byval_arg, &error);
2216 if (mono_error_set_pending_exception (&error))
2217 return;
2218
2219 MONO_STRUCT_SETREF (info, parent, rt);
2220 }
2221 if ((req_info & PInfo_DeclaringType) != 0) {
2222 rt = mono_type_get_object_checked (domain, &pproperty->parent->byval_arg, &error);
2223 if (mono_error_set_pending_exception (&error))
2224 return;
2225
2226 MONO_STRUCT_SETREF (info, declaring_type, rt);
2227 }
2228
2229 if ((req_info & PInfo_Name) != 0)
2230 MONO_STRUCT_SETREF (info, name, mono_string_new (domain, pproperty->name));
2231
2232 if ((req_info & PInfo_Attributes) != 0)
2233 info->attrs = pproperty->attrs;
2234
2235 if ((req_info & PInfo_GetMethod) != 0) {
2236 if (pproperty->get &&
2237 (((pproperty->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) ||
2238 pproperty->get->klass == property->klass)) {
2239 rm = mono_method_get_object_checked (domain, pproperty->get, property->klass, &error);
2240 if (mono_error_set_pending_exception (&error))
2241 return;
2242 } else {
2243 rm = NULL;
2244 }
2245
2246 MONO_STRUCT_SETREF (info, get, rm);
2247 }
2248 if ((req_info & PInfo_SetMethod) != 0) {
2249 if (pproperty->set &&
2250 (((pproperty->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) ||
2251 pproperty->set->klass == property->klass)) {
2252 rm = mono_method_get_object_checked (domain, pproperty->set, property->klass, &error);
2253 if (mono_error_set_pending_exception (&error))
2254 return;
2255 } else {
2256 rm = NULL;
2257 }
2258
2259 MONO_STRUCT_SETREF (info, set, rm);
2260 }
2261 /*
2262 * There may be other methods defined for properties, though, it seems they are not exposed
2263 * in the reflection API
2264 */
2265 }
2266
2267 ICALL_EXPORT void
2268 ves_icall_MonoEventInfo_get_event_info (MonoReflectionMonoEvent *event, MonoEventInfo *info)
2269 {
2270 MonoError error;
2271 MonoReflectionType *rt;
2272 MonoReflectionMethod *rm;
2273 MonoDomain *domain = mono_object_domain (event);
2274
2275 rt = mono_type_get_object_checked (domain, &event->klass->byval_arg, &error);
2276 if (mono_error_set_pending_exception (&error))
2277 return;
2278
2279 MONO_STRUCT_SETREF (info, reflected_type, rt);
2280
2281 rt = mono_type_get_object_checked (domain, &event->event->parent->byval_arg, &error);
2282 if (mono_error_set_pending_exception (&error))
2283 return;
2284
2285 MONO_STRUCT_SETREF (info, declaring_type, rt);
2286
2287 MONO_STRUCT_SETREF (info, name, mono_string_new (domain, event->event->name));
2288 info->attrs = event->event->attrs;
2289
2290 if (event->event->add) {
2291 rm = mono_method_get_object_checked (domain, event->event->add, NULL, &error);
2292 if (mono_error_set_pending_exception (&error))
2293 return;
2294 } else {
2295 rm = NULL;
2296 }
2297
2298 MONO_STRUCT_SETREF (info, add_method, rm);
2299
2300 if (event->event->remove) {
2301 rm = mono_method_get_object_checked (domain, event->event->remove, NULL, &error);
2302 if (mono_error_set_pending_exception (&error))
2303 return;
2304 } else {
2305 rm = NULL;
2306 }
2307
2308 MONO_STRUCT_SETREF (info, remove_method, rm);
2309
2310 if (event->event->raise) {
2311 rm = mono_method_get_object_checked (domain, event->event->raise, NULL, &error);
2312 if (mono_error_set_pending_exception (&error))
2313 return;
2314 } else {
2315 rm = NULL;
2316 }
2317
2318 MONO_STRUCT_SETREF (info, raise_method, rm);
2319
2320 #ifndef MONO_SMALL_CONFIG
2321 if (event->event->other) {
2322 int i, n = 0;
2323 while (event->event->other [n])
2324 n++;
2325 MonoArray *info_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, n, &error);
2326 if (mono_error_set_pending_exception (&error))
2327 return;
2328 MONO_STRUCT_SETREF (info, other_methods, info_arr);
2329
2330 for (i = 0; i < n; i++) {
2331 rm = mono_method_get_object_checked (domain, event->event->other [i], NULL, &error);
2332 if (mono_error_set_pending_exception (&error))
2333 return;
2334 mono_array_setref (info->other_methods, i, rm);
2335 }
2336 }
2337 #endif
2338 }
2339
2340 static void
2341 collect_interfaces (MonoClass *klass, GHashTable *ifaces, MonoError *error)
2342 {
2343 int i;
2344 MonoClass *ic;
2345
2346 mono_class_setup_interfaces (klass, error);
2347 if (!mono_error_ok (error))
2348 return;
2349
2350 for (i = 0; i < klass->interface_count; i++) {
2351 ic = klass->interfaces [i];
2352 g_hash_table_insert (ifaces, ic, ic);
2353
2354 collect_interfaces (ic, ifaces, error);
2355 if (!mono_error_ok (error))
2356 return;
2357 }
2358 }
2359
2360 typedef struct {
2361 MonoArray *iface_array;
2362 MonoGenericContext *context;
2363 MonoError *error;
2364 MonoDomain *domain;
2365 int next_idx;
2366 } FillIfaceArrayData;
2367
2368 static void
2369 fill_iface_array (gpointer key, gpointer value, gpointer user_data)
2370 {
2371 MonoReflectionType *rt;
2372 FillIfaceArrayData *data = (FillIfaceArrayData *)user_data;
2373 MonoClass *ic = (MonoClass *)key;
2374 MonoType *ret = &ic->byval_arg, *inflated = NULL;
2375
2376 if (!mono_error_ok (data->error))
2377 return;
2378
2379 if (data->context && ic->generic_class && ic->generic_class->context.class_inst->is_open) {
2380 inflated = ret = mono_class_inflate_generic_type_checked (ret, data->context, data->error);
2381 if (!mono_error_ok (data->error))
2382 return;
2383 }
2384
2385 rt = mono_type_get_object_checked (data->domain, ret, data->error);
2386 if (!mono_error_ok (data->error))
2387 return;
2388
2389 mono_array_setref (data->iface_array, data->next_idx++, rt);
2390
2391 if (inflated)
2392 mono_metadata_free_type (inflated);
2393 }
2394
2395 static guint
2396 get_interfaces_hash (gconstpointer v1)
2397 {
2398 MonoClass *k = (MonoClass*)v1;
2399
2400 return k->type_token;
2401 }
2402
2403 ICALL_EXPORT MonoArray*
2404 ves_icall_Type_GetInterfaces (MonoReflectionType* type)
2405 {
2406 MonoError error;
2407 MonoClass *klass = mono_class_from_mono_type (type->type);
2408 MonoClass *parent;
2409 FillIfaceArrayData data = { 0 };
2410 int len;
2411
2412 GHashTable *iface_hash = g_hash_table_new (get_interfaces_hash, NULL);
2413
2414 if (klass->generic_class && klass->generic_class->context.class_inst->is_open) {
2415 data.context = mono_class_get_context (klass);
2416 klass = klass->generic_class->container_class;
2417 }
2418
2419 for (parent = klass; parent; parent = parent->parent) {
2420 mono_class_setup_interfaces (parent, &error);
2421 if (!mono_error_ok (&error))
2422 goto fail;
2423 collect_interfaces (parent, iface_hash, &error);
2424 if (!mono_error_ok (&error))
2425 goto fail;
2426 }
2427
2428 data.error = &error;
2429 data.domain = mono_object_domain (type);
2430
2431 len = g_hash_table_size (iface_hash);
2432 if (len == 0) {
2433 g_hash_table_destroy (iface_hash);
2434 if (!data.domain->empty_types) {
2435 data.domain->empty_types = mono_array_new_cached (data.domain, mono_defaults.monotype_class, 0, &error);
2436 if (!is_ok (&error))
2437 goto fail;
2438 }
2439 return data.domain->empty_types;
2440 }
2441
2442 data.iface_array = mono_array_new_cached (data.domain, mono_defaults.monotype_class, len, &error);
2443 if (!is_ok (&error))
2444 goto fail;
2445 g_hash_table_foreach (iface_hash, fill_iface_array, &data);
2446 if (!mono_error_ok (&error))
2447 goto fail;
2448
2449 g_hash_table_destroy (iface_hash);
2450 return data.iface_array;
2451
2452 fail:
2453 g_hash_table_destroy (iface_hash);
2454 mono_error_set_pending_exception (&error);
2455 return NULL;
2456 }
2457
2458 ICALL_EXPORT void
2459 ves_icall_Type_GetInterfaceMapData (MonoReflectionType *type, MonoReflectionType *iface, MonoArray **targets, MonoArray **methods)
2460 {
2461 gboolean variance_used;
2462 MonoClass *klass = mono_class_from_mono_type (type->type);
2463 MonoClass *iclass = mono_class_from_mono_type (iface->type);
2464 MonoReflectionMethod *member;
2465 MonoMethod* method;
2466 gpointer iter;
2467 int i = 0, len, ioffset;
2468 MonoDomain *domain;
2469 MonoError error;
2470
2471 mono_class_init_checked (klass, &error);
2472 if (mono_error_set_pending_exception (&error))
2473 return;
2474 mono_class_init_checked (iclass, &error);
2475 if (mono_error_set_pending_exception (&error))
2476 return;
2477
2478 mono_class_setup_vtable (klass);
2479
2480 ioffset = mono_class_interface_offset_with_variance (klass, iclass, &variance_used);
2481 if (ioffset == -1)
2482 return;
2483
2484 len = mono_class_num_methods (iclass);
2485 domain = mono_object_domain (type);
2486 MonoArray *targets_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, len, &error);
2487 if (mono_error_set_pending_exception (&error))
2488 return;
2489 mono_gc_wbarrier_generic_store (targets, (MonoObject*) targets_arr);
2490 MonoArray *methods_arr = mono_array_new_checked (domain, mono_defaults.method_info_class, len, &error);
2491 if (mono_error_set_pending_exception (&error))
2492 return;
2493 mono_gc_wbarrier_generic_store (methods, (MonoObject*) methods_arr);
2494 iter = NULL;
2495 while ((method = mono_class_get_methods (iclass, &iter))) {
2496 member = mono_method_get_object_checked (domain, method, iclass, &error);
2497 if (mono_error_set_pending_exception (&error))
2498 return;
2499 mono_array_setref (*methods, i, member);
2500 member = mono_method_get_object_checked (domain, klass->vtable [i + ioffset], klass, &error);
2501 if (mono_error_set_pending_exception (&error))
2502 return;
2503 mono_array_setref (*targets, i, member);
2504
2505 i ++;
2506 }
2507 }
2508
2509 ICALL_EXPORT void
2510 ves_icall_Type_GetPacking (MonoReflectionType *type, guint32 *packing, guint32 *size)
2511 {
2512 MonoError error;
2513 MonoClass *klass = mono_class_from_mono_type (type->type);
2514
2515 mono_class_init_checked (klass, &error);
2516 if (mono_error_set_pending_exception (&error))
2517 return;
2518
2519 if (image_is_dynamic (klass->image)) {
2520 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)type;
2521 *packing = tb->packing_size;
2522 *size = tb->class_size;
2523 } else {
2524 mono_metadata_packing_from_typedef (klass->image, klass->type_token, packing, size);
2525 }
2526 }
2527
2528 ICALL_EXPORT MonoReflectionType*
2529 ves_icall_RuntimeTypeHandle_GetElementType (MonoReflectionType *type)
2530 {
2531 MonoError error;
2532 MonoReflectionType *ret;
2533 MonoClass *klass;
2534
2535 if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY) {
2536 ret = mono_type_get_object_checked (mono_object_domain (type), &type->type->data.klass->byval_arg, &error);
2537 mono_error_set_pending_exception (&error);
2538 return ret;
2539 }
2540
2541 klass = mono_class_from_mono_type (type->type);
2542 mono_class_init_checked (klass, &error);
2543 if (mono_error_set_pending_exception (&error))
2544 return NULL;
2545
2546
2547 // GetElementType should only return a type for:
2548 // Array Pointer PassedByRef
2549 if (type->type->byref)
2550 ret = mono_type_get_object_checked (mono_object_domain (type), &klass->byval_arg, &error);
2551 else if (klass->element_class && MONO_CLASS_IS_ARRAY (klass))
2552 ret = mono_type_get_object_checked (mono_object_domain (type), &klass->element_class->byval_arg, &error);
2553 else if (klass->element_class && type->type->type == MONO_TYPE_PTR)
2554 ret = mono_type_get_object_checked (mono_object_domain (type), &klass->element_class->byval_arg, &error);
2555 else
2556 return NULL;
2557
2558 mono_error_set_pending_exception (&error);
2559
2560 return ret;
2561 }
2562
2563 ICALL_EXPORT MonoReflectionType*
2564 ves_icall_RuntimeTypeHandle_GetBaseType (MonoReflectionType *type)
2565 {
2566 MonoError error;
2567 MonoReflectionType *ret;
2568
2569 if (type->type->byref)
2570 return NULL;
2571
2572 MonoClass *klass = mono_class_from_mono_type (type->type);
2573 if (!klass->parent)
2574 return NULL;
2575
2576 ret = mono_type_get_object_checked (mono_object_domain (type), &klass->parent->byval_arg, &error);
2577 mono_error_set_pending_exception (&error);
2578
2579 return ret;
2580 }
2581
2582 ICALL_EXPORT MonoBoolean
2583 ves_icall_RuntimeTypeHandle_IsPointer (MonoReflectionType *type)
2584 {
2585 return type->type->type == MONO_TYPE_PTR;
2586 }
2587
2588 ICALL_EXPORT MonoBoolean
2589 ves_icall_RuntimeTypeHandle_IsPrimitive (MonoReflectionType *type)
2590 {
2591 return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) || (type->type->type == MONO_TYPE_I) || (type->type->type == MONO_TYPE_U)));
2592 }
2593
2594 ICALL_EXPORT MonoBoolean
2595 ves_icall_RuntimeTypeHandle_IsByRef (MonoReflectionType *type)
2596 {
2597 return type->type->byref;
2598 }
2599
2600 ICALL_EXPORT MonoBoolean
2601 ves_icall_RuntimeTypeHandle_IsComObject (MonoReflectionType *type)
2602 {
2603 MonoError error;
2604 MonoClass *klass = mono_class_from_mono_type (type->type);
2605 mono_class_init_checked (klass, &error);
2606 if (mono_error_set_pending_exception (&error))
2607 return FALSE;
2608
2609 return mono_class_is_com_object (klass);
2610 }
2611
2612 ICALL_EXPORT guint32
2613 ves_icall_reflection_get_token (MonoObject* obj)
2614 {
2615 MonoError error;
2616 guint32 result = mono_reflection_get_token_checked (obj, &error);
2617 mono_error_set_pending_exception (&error);
2618 return result;
2619 }
2620
2621 ICALL_EXPORT MonoReflectionModule*
2622 ves_icall_RuntimeTypeHandle_GetModule (MonoReflectionType *type)
2623 {
2624 MonoError error;
2625 MonoReflectionModule *result = NULL;
2626 MonoClass *klass = mono_class_from_mono_type (type->type);
2627 result = mono_module_get_object_checked (mono_object_domain (type), klass->image, &error);
2628 mono_error_set_pending_exception (&error);
2629 return result;
2630 }
2631
2632 ICALL_EXPORT MonoReflectionAssembly*
2633 ves_icall_RuntimeTypeHandle_GetAssembly (MonoReflectionType *type)
2634 {
2635 MonoError error;
2636 MonoDomain *domain = mono_domain_get ();
2637 MonoClass *klass = mono_class_from_mono_type (type->type);
2638 MonoReflectionAssembly *result = mono_assembly_get_object_checked (domain, klass->image->assembly, &error);
2639 mono_error_set_pending_exception (&error);
2640 return result;
2641 }
2642
2643 ICALL_EXPORT MonoReflectionType*
2644 ves_icall_MonoType_get_DeclaringType (MonoReflectionType *type)
2645 {
2646 MonoError error;
2647 MonoReflectionType *ret;
2648 MonoDomain *domain = mono_domain_get ();
2649 MonoClass *klass;
2650
2651 if (type->type->byref)
2652 return NULL;
2653 if (type->type->type == MONO_TYPE_VAR) {
2654 MonoGenericContainer *param = mono_type_get_generic_param_owner (type->type);
2655 klass = param ? param->owner.klass : NULL;
2656 } else if (type->type->type == MONO_TYPE_MVAR) {
2657 MonoGenericContainer *param = mono_type_get_generic_param_owner (type->type);
2658 klass = param ? param->owner.method->klass : NULL;
2659 } else {
2660 klass = mono_class_from_mono_type (type->type)->nested_in;
2661 }
2662
2663 if (!klass)
2664 return NULL;
2665
2666 ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
2667 mono_error_set_pending_exception (&error);
2668
2669 return ret;
2670 }
2671
2672 ICALL_EXPORT MonoString*
2673 ves_icall_MonoType_get_Name (MonoReflectionType *type)
2674 {
2675 MonoDomain *domain = mono_domain_get ();
2676 MonoClass *klass = mono_class_from_mono_type (type->type);
2677
2678 if (type->type->byref) {
2679 char *n = g_strdup_printf ("%s&", klass->name);
2680 MonoString *res = mono_string_new (domain, n);
2681
2682 g_free (n);
2683
2684 return res;
2685 } else {
2686 return mono_string_new (domain, klass->name);
2687 }
2688 }
2689
2690 ICALL_EXPORT MonoString*
2691 ves_icall_MonoType_get_Namespace (MonoReflectionType *type)
2692 {
2693 MonoDomain *domain = mono_domain_get ();
2694 MonoClass *klass = mono_class_from_mono_type (type->type);
2695
2696 while (klass->nested_in)
2697 klass = klass->nested_in;
2698
2699 if (klass->name_space [0] == '\0')
2700 return NULL;
2701 else
2702 return mono_string_new (domain, klass->name_space);
2703 }
2704
2705 ICALL_EXPORT gint32
2706 ves_icall_RuntimeTypeHandle_GetArrayRank (MonoReflectionType *type)
2707 {
2708 MonoClass *klass;
2709
2710 if (type->type->type != MONO_TYPE_ARRAY && type->type->type != MONO_TYPE_SZARRAY) {
2711 mono_set_pending_exception (mono_get_exception_argument ("type", "Type must be an array type"));
2712 return 0;
2713 }
2714
2715 klass = mono_class_from_mono_type (type->type);
2716
2717 return klass->rank;
2718 }
2719
2720 static MonoArray*
2721 create_type_array (MonoDomain *domain, MonoBoolean runtimeTypeArray, int count, MonoError *error)
2722 {
2723 return mono_array_new_checked (domain, runtimeTypeArray ? mono_defaults.runtimetype_class : mono_defaults.systemtype_class, count, error);
2724 }
2725
2726 ICALL_EXPORT MonoArray*
2727 ves_icall_MonoType_GetGenericArguments (MonoReflectionType *type, MonoBoolean runtimeTypeArray)
2728 {
2729 MonoError error;
2730 MonoReflectionType *rt;
2731 MonoArray *res;
2732 MonoClass *klass, *pklass;
2733 MonoDomain *domain = mono_object_domain (type);
2734 int i;
2735
2736 klass = mono_class_from_mono_type (type->type);
2737
2738 if (klass->generic_container) {
2739 MonoGenericContainer *container = klass->generic_container;
2740 res = create_type_array (domain, runtimeTypeArray, container->type_argc, &error);
2741 if (mono_error_set_pending_exception (&error))
2742 return NULL;
2743 for (i = 0; i < container->type_argc; ++i) {
2744 pklass = mono_class_from_generic_parameter_internal (mono_generic_container_get_param (container, i));
2745
2746 rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
2747 if (mono_error_set_pending_exception (&error))
2748 return NULL;
2749
2750 mono_array_setref (res, i, rt);
2751 }
2752 } else if (klass->generic_class) {
2753 MonoGenericInst *inst = klass->generic_class->context.class_inst;
2754 res = create_type_array (domain, runtimeTypeArray, inst->type_argc, &error);
2755 if (mono_error_set_pending_exception (&error))
2756 return NULL;
2757 for (i = 0; i < inst->type_argc; ++i) {
2758 rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
2759 if (mono_error_set_pending_exception (&error))
2760 return NULL;
2761
2762 mono_array_setref (res, i, rt);
2763 }
2764 } else {
2765 res = NULL;
2766 }
2767 return res;
2768 }
2769
2770 ICALL_EXPORT gboolean
2771 ves_icall_RuntimeTypeHandle_IsGenericTypeDefinition (MonoReflectionType *type)
2772 {
2773 MonoClass *klass;
2774
2775 if (!IS_MONOTYPE (type))
2776 return FALSE;
2777
2778 if (type->type->byref)
2779 return FALSE;
2780
2781 klass = mono_class_from_mono_type (type->type);
2782 return klass->generic_container != NULL;
2783 }
2784
2785 ICALL_EXPORT MonoReflectionType*
2786 ves_icall_RuntimeTypeHandle_GetGenericTypeDefinition_impl (MonoReflectionType *type)
2787 {
2788 MonoError error;
2789 MonoReflectionType *ret;
2790 MonoClass *klass;
2791
2792 if (type->type->byref)
2793 return NULL;
2794
2795 klass = mono_class_from_mono_type (type->type);
2796
2797 if (klass->generic_container) {
2798 return type; /* check this one */
2799 }
2800 if (klass->generic_class) {
2801 MonoClass *generic_class = klass->generic_class->container_class;
2802 gpointer tb;
2803
2804 tb = mono_class_get_ref_info (generic_class);
2805
2806 if (generic_class->wastypebuilder && tb)
2807 return (MonoReflectionType *)tb;
2808 else {
2809 ret = mono_type_get_object_checked (mono_object_domain (type), &generic_class->byval_arg, &error);
2810 mono_error_set_pending_exception (&error);
2811
2812 return ret;
2813 }
2814 }
2815 return NULL;
2816 }
2817
2818 ICALL_EXPORT MonoReflectionType*
2819 ves_icall_Type_MakeGenericType (MonoReflectionType *type, MonoArray *type_array)
2820 {
2821 MonoError error;
2822 MonoReflectionType *ret;
2823 MonoClass *klass;
2824 MonoType *geninst, **types;
2825 int i, count;
2826
2827 g_assert (IS_MONOTYPE (type));
2828 mono_class_init_checked (mono_class_from_mono_type (type->type), &error);
2829 if (mono_error_set_pending_exception (&error))
2830 return NULL;
2831
2832 count = mono_array_length (type_array);
2833 types = g_new0 (MonoType *, count);
2834
2835 for (i = 0; i < count; i++) {
2836 MonoReflectionType *t = (MonoReflectionType *)mono_array_get (type_array, gpointer, i);
2837 types [i] = t->type;
2838 }
2839
2840 geninst = mono_reflection_bind_generic_parameters (type, count, types, &error);
2841 g_free (types);
2842 if (!geninst) {
2843 mono_error_set_pending_exception (&error);
2844 return NULL;
2845 }
2846
2847 klass = mono_class_from_mono_type (geninst);
2848
2849 /*we might inflate to the GTD*/
2850 if (klass->generic_class && !mono_verifier_class_is_valid_generic_instantiation (klass)) {
2851 mono_set_pending_exception (mono_get_exception_argument ("typeArguments", "Invalid generic arguments"));
2852 return NULL;
2853 }
2854
2855 ret = mono_type_get_object_checked (mono_object_domain (type), geninst, &error);
2856 mono_error_set_pending_exception (&error);
2857
2858 return ret;
2859 }
2860
2861 ICALL_EXPORT gboolean
2862 ves_icall_RuntimeTypeHandle_HasInstantiation (MonoReflectionType *type)
2863 {
2864 MonoClass *klass;
2865
2866 if (!IS_MONOTYPE (type))
2867 return FALSE;
2868
2869 if (type->type->byref)
2870 return FALSE;
2871
2872 klass = mono_class_from_mono_type (type->type);
2873 return klass->generic_class != NULL || klass->generic_container != NULL;
2874 }
2875
2876 ICALL_EXPORT gint32
2877 ves_icall_Type_GetGenericParameterPosition (MonoReflectionType *type)
2878 {
2879 if (!IS_MONOTYPE (type))
2880 return -1;
2881
2882 if (is_generic_parameter (type->type))
2883 return mono_type_get_generic_param_num (type->type);
2884 return -1;
2885 }
2886
2887 ICALL_EXPORT GenericParameterAttributes
2888 ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType *type)
2889 {
2890 g_assert (IS_MONOTYPE (type));
2891 g_assert (is_generic_parameter (type->type));
2892 return (GenericParameterAttributes)mono_generic_param_info (type->type->data.generic_param)->flags;
2893 }
2894
2895 ICALL_EXPORT MonoArray *
2896 ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType *type)
2897 {
2898 MonoError error;
2899 MonoReflectionType *rt;
2900 MonoGenericParamInfo *param_info;
2901 MonoDomain *domain;
2902 MonoClass **ptr;
2903 MonoArray *res;
2904 int i, count;
2905
2906 g_assert (IS_MONOTYPE (type));
2907
2908 domain = mono_object_domain (type);
2909 param_info = mono_generic_param_info (type->type->data.generic_param);
2910 for (count = 0, ptr = param_info->constraints; ptr && *ptr; ptr++, count++)
2911 ;
2912
2913 res = mono_array_new_checked (domain, mono_defaults.monotype_class, count, &error);
2914 if (mono_error_set_pending_exception (&error))
2915 return NULL;
2916 for (i = 0; i < count; i++) {
2917 rt = mono_type_get_object_checked (domain, &param_info->constraints [i]->byval_arg, &error);
2918 if (mono_error_set_pending_exception (&error))
2919 return NULL;
2920
2921 mono_array_setref (res, i, rt);
2922 }
2923
2924
2925 return res;
2926 }
2927
2928 ICALL_EXPORT MonoBoolean
2929 ves_icall_RuntimeTypeHandle_IsGenericVariable (MonoReflectionType *type)
2930 {
2931 return is_generic_parameter (type->type);
2932 }
2933
2934 ICALL_EXPORT MonoBoolean
2935 ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb)
2936 {
2937 return is_generic_parameter (tb->type.type);
2938 }
2939
2940 ICALL_EXPORT void
2941 ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype,
2942 MonoReflectionType *t)
2943 {
2944 enumtype->type = t->type;
2945 }
2946
2947 ICALL_EXPORT MonoReflectionMethod*
2948 ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType *type,
2949 MonoReflectionMethod* generic)
2950 {
2951 MonoDomain *domain;
2952 MonoClass *klass;
2953 MonoMethod *method;
2954 gpointer iter;
2955 MonoError error;
2956 MonoReflectionMethod *ret = NULL;
2957
2958 domain = ((MonoObject *)type)->vtable->domain;
2959
2960 klass = mono_class_from_mono_type (type->type);
2961 mono_class_init_checked (klass, &error);
2962 if (mono_error_set_pending_exception (&error))
2963 return NULL;
2964
2965 iter = NULL;
2966 while ((method = mono_class_get_methods (klass, &iter))) {
2967 if (method->token == generic->method->token) {
2968 ret = mono_method_get_object_checked (domain, method, klass, &error);
2969 if (mono_error_set_pending_exception (&error))
2970 return NULL;
2971 }
2972 }
2973
2974 return ret;
2975 }
2976
2977 ICALL_EXPORT MonoReflectionMethod *
2978 ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType *ref_type)
2979 {
2980 MonoMethod *method;
2981 MonoType *type = ref_type->type;
2982 MonoError error;
2983 MonoReflectionMethod *ret = NULL;
2984
2985 if (type->byref || (type->type != MONO_TYPE_MVAR && type->type != MONO_TYPE_VAR)) {
2986 mono_set_pending_exception (mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments"));
2987 return NULL;
2988 }
2989 if (type->type == MONO_TYPE_VAR)
2990 return NULL;
2991
2992 method = mono_type_get_generic_param_owner (type)->owner.method;
2993 g_assert (method);
2994
2995 ret = mono_method_get_object_checked (mono_object_domain (ref_type), method, method->klass, &error);
2996 if (!mono_error_ok (&error))
2997 mono_set_pending_exception (mono_error_convert_to_exception (&error));
2998 return ret;
2999 }
3000
3001 ICALL_EXPORT MonoBoolean
3002 ves_icall_System_RuntimeType_IsTypeExportedToWindowsRuntime (void)
3003 {
3004 mono_set_pending_exception (mono_get_exception_not_implemented (NULL));
3005 return FALSE;
3006 }
3007
3008 ICALL_EXPORT MonoBoolean
3009 ves_icall_System_RuntimeType_IsWindowsRuntimeObjectType (void)
3010 {
3011 mono_set_pending_exception (mono_get_exception_not_implemented (NULL));
3012 return FALSE;
3013 }
3014
3015 ICALL_EXPORT void
3016 ves_icall_MonoMethod_GetPInvoke (MonoReflectionMethod *method, int* flags, MonoString** entry_point, MonoString** dll_name)
3017 {
3018 MonoDomain *domain = mono_domain_get ();
3019 MonoImage *image = method->method->klass->image;
3020 MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)method->method;
3021 MonoTableInfo *tables = image->tables;
3022 MonoTableInfo *im = &tables [MONO_TABLE_IMPLMAP];
3023 MonoTableInfo *mr = &tables [MONO_TABLE_MODULEREF];
3024 guint32 im_cols [MONO_IMPLMAP_SIZE];
3025 guint32 scope_token;
3026 const char *import = NULL;
3027 const char *scope = NULL;
3028
3029 if (image_is_dynamic (image)) {
3030 MonoReflectionMethodAux *method_aux =
3031 (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)image)->method_aux_hash, method->method);
3032 if (method_aux) {
3033 import = method_aux->dllentry;
3034 scope = method_aux->dll;
3035 }
3036
3037 if (!import || !scope) {
3038 mono_set_pending_exception (mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information"));
3039 return;
3040 }
3041 }
3042 else {
3043 if (piinfo->implmap_idx) {
3044 mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
3045
3046 piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS];
3047 import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]);
3048 scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME);
3049 scope = mono_metadata_string_heap (image, scope_token);
3050 }
3051 }
3052
3053 *flags = piinfo->piflags;
3054 *entry_point = mono_string_new (domain, import);
3055 *dll_name = mono_string_new (domain, scope);
3056 }
3057
3058 ICALL_EXPORT MonoReflectionMethod *
3059 ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod *method)
3060 {
3061 MonoMethodInflated *imethod;
3062 MonoMethod *result;
3063 MonoReflectionMethod *ret = NULL;
3064 MonoError error;
3065
3066 if (method->method->is_generic)
3067 return method;
3068
3069 if (!method->method->is_inflated)
3070 return NULL;
3071
3072 imethod = (MonoMethodInflated *) method->method;
3073
3074 result = imethod->declaring;
3075 /* Not a generic method. */
3076 if (!result->is_generic)
3077 return NULL;
3078
3079 if (image_is_dynamic (method->method->klass->image)) {
3080 MonoDynamicImage *image = (MonoDynamicImage*)method->method->klass->image;
3081 MonoReflectionMethod *res;
3082
3083 /*
3084 * FIXME: Why is this stuff needed at all ? Why can't the code below work for
3085 * the dynamic case as well ?
3086 */
3087 mono_image_lock ((MonoImage*)image);
3088 res = (MonoReflectionMethod *)mono_g_hash_table_lookup (image->generic_def_objects, imethod);
3089 mono_image_unlock ((MonoImage*)image);
3090
3091 if (res)
3092 return res;
3093 }
3094
3095 if (imethod->context.class_inst) {
3096 MonoClass *klass = ((MonoMethod *) imethod)->klass;
3097 /*Generic methods gets the context of the GTD.*/
3098 if (mono_class_get_context (klass)) {
3099 result = mono_class_inflate_generic_method_full_checked (result, klass, mono_class_get_context (klass), &error);
3100 if (!mono_error_ok (&error))
3101 goto leave;
3102 }
3103 }
3104
3105 ret = mono_method_get_object_checked (mono_object_domain (method), result, NULL, &error);
3106 leave:
3107 if (!mono_error_ok (&error))
3108 mono_error_set_pending_exception (&error);
3109 return ret;
3110 }
3111
3112 ICALL_EXPORT gboolean
3113 ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod *method)
3114 {
3115 return mono_method_signature (method->method)->generic_param_count != 0;
3116 }
3117
3118 ICALL_EXPORT gboolean
3119 ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod *method)
3120 {
3121 return method->method->is_generic;
3122 }
3123
3124 ICALL_EXPORT MonoArray*
3125 ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod *method)
3126 {
3127 MonoError error;
3128 MonoReflectionType *rt;
3129 MonoArray *res;
3130 MonoDomain *domain;
3131 int count, i;
3132
3133 domain = mono_object_domain (method);
3134
3135 if (method->method->is_inflated) {
3136 MonoGenericInst *inst = mono_method_get_context (method->method)->method_inst;
3137
3138 if (inst) {
3139 count = inst->type_argc;
3140 res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error);
3141 if (mono_error_set_pending_exception (&error))
3142 return NULL;
3143
3144 for (i = 0; i < count; i++) {
3145 rt = mono_type_get_object_checked (domain, inst->type_argv [i], &error);
3146 if (mono_error_set_pending_exception (&error))
3147 return NULL;
3148
3149 mono_array_setref (res, i, rt);
3150 }
3151
3152 return res;
3153 }
3154 }
3155
3156 count = mono_method_signature (method->method)->generic_param_count;
3157 res = mono_array_new_checked (domain, mono_defaults.systemtype_class, count, &error);
3158 if (mono_error_set_pending_exception (&error))
3159 return NULL;
3160
3161 for (i = 0; i < count; i++) {
3162 MonoGenericContainer *container = mono_method_get_generic_container (method->method);
3163 MonoGenericParam *param = mono_generic_container_get_param (container, i);
3164 MonoClass *pklass = mono_class_from_generic_parameter_internal (param);
3165
3166 rt = mono_type_get_object_checked (domain, &pklass->byval_arg, &error);
3167 if (mono_error_set_pending_exception (&error))
3168 return NULL;
3169
3170 mono_array_setref (res, i, rt);
3171 }
3172
3173 return res;
3174 }
3175
3176 ICALL_EXPORT MonoObject *
3177 ves_icall_InternalInvoke (MonoReflectionMethod *method, MonoObject *this_arg, MonoArray *params, MonoException **exc)
3178 {
3179 MonoError error;
3180 /*
3181 * Invoke from reflection is supposed to always be a virtual call (the API
3182 * is stupid), mono_runtime_invoke_*() calls the provided method, allowing
3183 * greater flexibility.
3184 */
3185 MonoMethod *m = method->method;
3186 MonoMethodSignature *sig = mono_method_signature (m);
3187 MonoImage *image;
3188 int pcount;
3189 void *obj = this_arg;
3190
3191 *exc = NULL;
3192
3193 if (mono_security_core_clr_enabled () &&
3194 !mono_security_core_clr_ensure_reflection_access_method (m, &error)) {
3195 mono_error_set_pending_exception (&error);
3196 return NULL;
3197 }
3198
3199 if (!(m->flags & METHOD_ATTRIBUTE_STATIC)) {
3200 if (!mono_class_vtable_full (mono_object_domain (method), m->klass, &error)) {
3201 mono_error_cleanup (&error); /* FIXME does this make sense? */
3202 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_class_get_exception_for_failure (m->klass));
3203 return NULL;
3204 }
3205
3206 if (this_arg) {
3207 if (!mono_object_isinst_checked (this_arg, m->klass, &error)) {
3208 if (!is_ok (&error)) {
3209 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_error_convert_to_exception (&error));
3210 return NULL;
3211 }
3212 char *this_name = mono_type_get_full_name (mono_object_get_class (this_arg));
3213 char *target_name = mono_type_get_full_name (m->klass);
3214 char *msg = g_strdup_printf ("Object of type '%s' doesn't match target type '%s'", this_name, target_name);
3215 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", msg));
3216 g_free (msg);
3217 g_free (target_name);
3218 g_free (this_name);
3219 return NULL;
3220 }
3221 m = mono_object_get_virtual_method (this_arg, m);
3222 /* must pass the pointer to the value for valuetype methods */
3223 if (m->klass->valuetype)
3224 obj = mono_object_unbox (this_arg);
3225 } else if (strcmp (m->name, ".ctor") && !m->wrapper_type) {
3226 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Non-static method requires a target."));
3227 return NULL;
3228 }
3229 }
3230
3231 if (sig->ret->byref) {
3232 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System", "NotSupportedException", "Cannot invoke method returning ByRef type via reflection"));
3233 return NULL;
3234 }
3235
3236 pcount = params? mono_array_length (params): 0;
3237 if (pcount != sig->param_count) {
3238 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetParameterCountException"));
3239 return NULL;
3240 }
3241
3242 if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor") && !this_arg) {
3243 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class."));
3244 return NULL;
3245 }
3246
3247 image = m->klass->image;
3248 if (image->assembly->ref_only) {
3249 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_get_exception_invalid_operation ("It is illegal to invoke a method on a type loaded using the ReflectionOnly api."));
3250 return NULL;
3251 }
3252
3253 if (image_is_dynamic (image) && !((MonoDynamicImage*)image)->run) {
3254 mono_gc_wbarrier_generic_store (exc, (MonoObject*) mono_get_exception_not_supported ("Cannot invoke a method in a dynamic assembly without run access."));
3255 return NULL;
3256 }
3257
3258 if (m->klass->rank && !strcmp (m->name, ".ctor")) {
3259 MonoArray *arr;
3260 int i;
3261 uintptr_t *lengths;
3262 intptr_t *lower_bounds;
3263 pcount = mono_array_length (params);
3264 lengths = (uintptr_t *)alloca (sizeof (uintptr_t) * pcount);
3265 /* Note: the synthetized array .ctors have int32 as argument type */
3266 for (i = 0; i < pcount; ++i)
3267 lengths [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, i) + sizeof (MonoObject));
3268
3269 if (m->klass->rank == 1 && sig->param_count == 2 && m->klass->element_class->rank) {
3270 /* This is a ctor for jagged arrays. MS creates an array of arrays. */
3271 arr = mono_array_new_full_checked (mono_object_domain (params), m->klass, lengths, NULL, &error);
3272 if (!mono_error_ok (&error)) {
3273 mono_error_set_pending_exception (&error);
3274 return NULL;
3275 }
3276
3277 for (i = 0; i < mono_array_length (arr); ++i) {
3278 MonoArray *subarray = mono_array_new_full_checked (mono_object_domain (params), m->klass->element_class, &lengths [1], NULL, &error);
3279 if (!mono_error_ok (&error)) {
3280 mono_error_set_pending_exception (&error);
3281 return NULL;
3282 }
3283 mono_array_setref_fast (arr, i, subarray);
3284 }
3285 return (MonoObject*)arr;
3286 }
3287
3288 if (m->klass->rank == pcount) {
3289 /* Only lengths provided. */
3290 arr = mono_array_new_full_checked (mono_object_domain (params), m->klass, lengths, NULL, &error);
3291 if (!mono_error_ok (&error)) {
3292 mono_error_set_pending_exception (&error);
3293 return NULL;
3294 }
3295
3296 return (MonoObject*)arr;
3297 } else {
3298 g_assert (pcount == (m->klass->rank * 2));
3299 /* The arguments are lower-bound-length pairs */
3300 lower_bounds = (intptr_t *)g_alloca (sizeof (intptr_t) * pcount);
3301
3302 for (i = 0; i < pcount / 2; ++i) {
3303 lower_bounds [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, (i * 2)) + sizeof (MonoObject));
3304 lengths [i] = *(int32_t*) ((char*)mono_array_get (params, gpointer, (i * 2) + 1) + sizeof (MonoObject));
3305 }
3306
3307 arr = mono_array_new_full_checked (mono_object_domain (params), m->klass, lengths, lower_bounds, &error);
3308 if (!mono_error_ok (&error)) {
3309 mono_error_set_pending_exception (&error);
3310 return NULL;
3311 }
3312
3313 return (MonoObject*)arr;
3314 }
3315 }
3316 return mono_runtime_invoke_array (m, obj, params, NULL);
3317 }
3318
3319 #ifndef DISABLE_REMOTING
3320 ICALL_EXPORT MonoObject *
3321 ves_icall_InternalExecute (MonoReflectionMethod *method, MonoObject *this_arg, MonoArray *params, MonoArray **outArgs)
3322 {
3323 MonoError error;
3324 MonoDomain *domain = mono_object_domain (method);
3325 MonoMethod *m = method->method;
3326 MonoMethodSignature *sig = mono_method_signature (m);
3327 MonoArray *out_args;
3328 MonoObject *result;
3329 int i, j, outarg_count = 0;
3330
3331 if (m->klass == mono_defaults.object_class) {
3332 if (!strcmp (m->name, "FieldGetter")) {
3333 MonoClass *k = this_arg->vtable->klass;
3334 MonoString *name;
3335 char *str;
3336
3337 /* If this is a proxy, then it must be a CBO */
3338 if (k == mono_defaults.transparent_proxy_class) {
3339 MonoTransparentProxy *tp = (MonoTransparentProxy*) this_arg;
3340 this_arg = tp->rp->unwrapped_server;
3341 g_assert (this_arg);
3342 k = this_arg->vtable->klass;
3343 }
3344
3345 name = mono_array_get (params, MonoString *, 1);
3346 str = mono_string_to_utf8 (name);
3347
3348 do {
3349 MonoClassField* field = mono_class_get_field_from_name (k, str);
3350 if (field) {
3351 g_free (str);
3352 MonoClass *field_klass = mono_class_from_mono_type (field->type);
3353 if (field_klass->valuetype) {
3354 result = mono_value_box_checked (domain, field_klass, (char *)this_arg + field->offset, &error);
3355 if (mono_error_set_pending_exception (&error))
3356 return NULL;
3357 } else
3358 result = (MonoObject *)*((gpointer *)((char *)this_arg + field->offset));
3359
3360 out_args = mono_array_new_checked (domain, mono_defaults.object_class, 1, &error);
3361 if (mono_error_set_pending_exception (&error))
3362 return NULL;
3363 mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
3364 mono_array_setref (out_args, 0, result);
3365 return NULL;
3366 }
3367 k = k->parent;
3368 } while (k);
3369
3370 g_free (str);
3371 g_assert_not_reached ();
3372
3373 } else if (!strcmp (m->name, "FieldSetter")) {
3374 MonoClass *k = this_arg->vtable->klass;
3375 MonoString *name;
3376 guint32 size;
3377 gint32 align;
3378 char *str;
3379
3380 /* If this is a proxy, then it must be a CBO */
3381 if (k == mono_defaults.transparent_proxy_class) {
3382 MonoTransparentProxy *tp = (MonoTransparentProxy*) this_arg;
3383 this_arg = tp->rp->unwrapped_server;
3384 g_assert (this_arg);
3385 k = this_arg->vtable->klass;
3386 }
3387
3388 name = mono_array_get (params, MonoString *, 1);
3389 str = mono_string_to_utf8 (name);
3390
3391 do {
3392 MonoClassField* field = mono_class_get_field_from_name (k, str);
3393 if (field) {
3394 g_free (str);
3395 MonoClass *field_klass = mono_class_from_mono_type (field->type);
3396 MonoObject *val = (MonoObject *)mono_array_get (params, gpointer, 2);
3397
3398 if (field_klass->valuetype) {
3399 size = mono_type_size (field->type, &align);
3400 g_assert (size == mono_class_value_size (field_klass, NULL));
3401 mono_gc_wbarrier_value_copy ((char *)this_arg + field->offset, (char*)val + sizeof (MonoObject), 1, field_klass);
3402 } else {
3403 mono_gc_wbarrier_set_field (this_arg, (char*)this_arg + field->offset, val);
3404 }
3405
3406 out_args = mono_array_new_checked (domain, mono_defaults.object_class, 0, &error);
3407 if (mono_error_set_pending_exception (&error))
3408 return NULL;
3409 mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
3410
3411 return NULL;
3412 }
3413
3414 k = k->parent;
3415 } while (k);
3416
3417 g_free (str);
3418 g_assert_not_reached ();
3419
3420 }
3421 }
3422
3423 for (i = 0; i < mono_array_length (params); i++) {
3424 if (sig->params [i]->byref)
3425 outarg_count++;
3426 }
3427
3428 out_args = mono_array_new_checked (domain, mono_defaults.object_class, outarg_count, &error);
3429 if (mono_error_set_pending_exception (&error))
3430 return NULL;
3431
3432 /* handle constructors only for objects already allocated */
3433 if (!strcmp (method->method->name, ".ctor"))
3434 g_assert (this_arg);
3435
3436 /* This can be called only on MBR objects, so no need to unbox for valuetypes. */
3437 g_assert (!method->method->klass->valuetype);
3438 result = mono_runtime_invoke_array (method->method, this_arg, params, NULL);
3439
3440 for (i = 0, j = 0; i < mono_array_length (params); i++) {
3441 if (sig->params [i]->byref) {
3442 gpointer arg;
3443 arg = mono_array_get (params, gpointer, i);
3444 mono_array_setref (out_args, j, arg);
3445 j++;
3446 }
3447 }
3448
3449 mono_gc_wbarrier_generic_store (outArgs, (MonoObject*) out_args);
3450
3451 return result;
3452 }
3453 #endif
3454
3455 static guint64
3456 read_enum_value (const char *mem, int type)
3457 {
3458 switch (type) {
3459 case MONO_TYPE_BOOLEAN:
3460 case MONO_TYPE_U1:
3461 return *(guint8*)mem;
3462 case MONO_TYPE_I1:
3463 return *(gint8*)mem;
3464 case MONO_TYPE_CHAR:
3465 case MONO_TYPE_U2:
3466 return read16 (mem);
3467 case MONO_TYPE_I2:
3468 return (gint16) read16 (mem);
3469 case MONO_TYPE_U4:
3470 return read32 (mem);
3471 case MONO_TYPE_I4:
3472 return (gint32) read32 (mem);
3473 case MONO_TYPE_U8:
3474 case MONO_TYPE_I8:
3475 return read64 (mem);
3476 default:
3477 g_assert_not_reached ();
3478 }
3479 return 0;
3480 }
3481
3482 static void
3483 write_enum_value (char *mem, int type, guint64 value)
3484 {
3485 switch (type) {
3486 case MONO_TYPE_U1:
3487 case MONO_TYPE_I1: {
3488 guint8 *p = (guint8*)mem;
3489 *p = value;
3490 break;
3491 }
3492 case MONO_TYPE_U2:
3493 case MONO_TYPE_I2:
3494 case MONO_TYPE_CHAR: {
3495 guint16 *p = (guint16 *)mem;
3496 *p = value;
3497 break;
3498 }
3499 case MONO_TYPE_U4:
3500 case MONO_TYPE_I4: {
3501 guint32 *p = (guint32 *)mem;
3502 *p = value;
3503 break;
3504 }
3505 case MONO_TYPE_U8:
3506 case MONO_TYPE_I8: {
3507 guint64 *p = (guint64 *)mem;
3508 *p = value;
3509 break;
3510 }
3511 default:
3512 g_assert_not_reached ();
3513 }
3514 return;
3515 }
3516
3517 ICALL_EXPORT MonoObject *
3518 ves_icall_System_Enum_ToObject (MonoReflectionType *enumType, guint64 value)
3519 {
3520 MonoError error;
3521 MonoDomain *domain;
3522 MonoClass *enumc;
3523 MonoObject *res;
3524 MonoType *etype;
3525
3526 domain = mono_object_domain (enumType);
3527 enumc = mono_class_from_mono_type (enumType->type);
3528
3529 mono_class_init_checked (enumc, &error);
3530 if (mono_error_set_pending_exception (&error))
3531 return NULL;
3532
3533 etype = mono_class_enum_basetype (enumc);
3534
3535 res = mono_object_new_checked (domain, enumc, &error);
3536 if (mono_error_set_pending_exception (&error))
3537 return NULL;
3538 write_enum_value ((char *)res + sizeof (MonoObject), etype->type, value);
3539
3540 return res;
3541 }
3542
3543 ICALL_EXPORT MonoBoolean
3544 ves_icall_System_Enum_InternalHasFlag (MonoObject *a, MonoObject *b)
3545 {
3546 int size = mono_class_value_size (a->vtable->klass, NULL);
3547 guint64 a_val = 0, b_val = 0;
3548
3549 memcpy (&a_val, mono_object_unbox (a), size);
3550 memcpy (&b_val, mono_object_unbox (b), size);
3551
3552 return (a_val & b_val) == b_val;
3553 }
3554
3555 ICALL_EXPORT MonoObject *
3556 ves_icall_System_Enum_get_value (MonoObject *eobj)
3557 {
3558 MonoError error;
3559 MonoObject *res;
3560 MonoClass *enumc;
3561 gpointer dst;
3562 gpointer src;
3563 int size;
3564
3565 if (!eobj)
3566 return NULL;
3567
3568 g_assert (eobj->vtable->klass->enumtype);
3569
3570 enumc = mono_class_from_mono_type (mono_class_enum_basetype (eobj->vtable->klass));
3571 res = mono_object_new_checked (mono_object_domain (eobj), enumc, &error);
3572 if (mono_error_set_pending_exception (&error))
3573 return NULL;
3574 dst = (char *)res + sizeof (MonoObject);
3575 src = (char *)eobj + sizeof (MonoObject);
3576 size = mono_class_value_size (enumc, NULL);
3577
3578 memcpy (dst, src, size);
3579
3580 return res;
3581 }
3582
3583 ICALL_EXPORT MonoReflectionType *
3584 ves_icall_System_Enum_get_underlying_type (MonoReflectionType *type)
3585 {
3586 MonoError error;
3587 MonoReflectionType *ret;
3588 MonoType *etype;
3589 MonoClass *klass;
3590
3591 klass = mono_class_from_mono_type (type->type);
3592 mono_class_init_checked (klass, &error);
3593 if (mono_error_set_pending_exception (&error))
3594 return NULL;
3595
3596 etype = mono_class_enum_basetype (klass);
3597 if (!etype) {
3598 mono_set_pending_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum."));
3599 return NULL;
3600 }
3601
3602 ret = mono_type_get_object_checked (mono_object_domain (type), etype, &error);
3603 mono_error_set_pending_exception (&error);
3604
3605 return ret;
3606 }
3607
3608 ICALL_EXPORT int
3609 ves_icall_System_Enum_compare_value_to (MonoObject *eobj, MonoObject *other)
3610 {
3611 gpointer tdata = (char *)eobj + sizeof (MonoObject);
3612 gpointer odata = (char *)other + sizeof (MonoObject);
3613 MonoType *basetype = mono_class_enum_basetype (eobj->vtable->klass);
3614 g_assert (basetype);
3615
3616 if (other == NULL)
3617 return 1;
3618
3619 if (eobj->vtable->klass != other->vtable->klass)
3620 return 2;
3621
3622 #define COMPARE_ENUM_VALUES(ENUM_TYPE) do { \
3623 ENUM_TYPE me = *((ENUM_TYPE*)tdata); \
3624 ENUM_TYPE other = *((ENUM_TYPE*)odata); \
3625 if (me == other) \
3626 return 0; \
3627 return me > other ? 1 : -1; \
3628 } while (0)
3629
3630 switch (basetype->type) {
3631 case MONO_TYPE_U1:
3632 COMPARE_ENUM_VALUES (guint8);
3633 case MONO_TYPE_I1:
3634 COMPARE_ENUM_VALUES (gint8);
3635 case MONO_TYPE_CHAR:
3636 case MONO_TYPE_U2:
3637 COMPARE_ENUM_VALUES (guint16);
3638 case MONO_TYPE_I2:
3639 COMPARE_ENUM_VALUES (gint16);
3640 case MONO_TYPE_U4:
3641 COMPARE_ENUM_VALUES (guint32);
3642 case MONO_TYPE_I4:
3643 COMPARE_ENUM_VALUES (gint32);
3644 case MONO_TYPE_U8:
3645 COMPARE_ENUM_VALUES (guint64);
3646 case MONO_TYPE_I8:
3647 COMPARE_ENUM_VALUES (gint64);
3648 default:
3649 break;
3650 }
3651 #undef COMPARE_ENUM_VALUES
3652 /* indicates that the enum was of an unsupported unerlying type */
3653 return 3;
3654 }
3655
3656 ICALL_EXPORT int
3657 ves_icall_System_Enum_get_hashcode (MonoObject *eobj)
3658 {
3659 gpointer data = (char *)eobj + sizeof (MonoObject);
3660 MonoType *basetype = mono_class_enum_basetype (eobj->vtable->klass);
3661 g_assert (basetype);
3662
3663 switch (basetype->type) {
3664 case MONO_TYPE_I1: {
3665 gint8 value = *((gint8*)data);
3666 return ((int)value ^ (int)value << 8);
3667 }
3668 case MONO_TYPE_U1:
3669 return *((guint8*)data);
3670 case MONO_TYPE_CHAR:
3671 case MONO_TYPE_U2:
3672 return *((guint16*)data);
3673
3674 case MONO_TYPE_I2: {
3675 gint16 value = *((gint16*)data);
3676 return ((int)(guint16)value | (((int)value) << 16));
3677 }
3678 case MONO_TYPE_U4:
3679 return *((guint32*)data);
3680 case MONO_TYPE_I4:
3681 return *((gint32*)data);
3682 case MONO_TYPE_U8:
3683 case MONO_TYPE_I8: {
3684 gint64 value = *((gint64*)data);
3685 return (gint)(value & 0xffffffff) ^ (int)(value >> 32);
3686 }
3687 default:
3688 g_error ("Implement type 0x%02x in get_hashcode", basetype->type);
3689 }
3690 return 0;
3691 }
3692
3693 ICALL_EXPORT MonoBoolean
3694 ves_icall_System_Enum_GetEnumValuesAndNames (MonoReflectionType *type, MonoArray **values, MonoArray **names)
3695 {
3696 MonoError error;
3697 MonoDomain *domain = mono_object_domain (type);
3698 MonoClass *enumc = mono_class_from_mono_type (type->type);
3699 guint j = 0, nvalues;
3700 gpointer iter;
3701 MonoClassField *field;
3702 int base_type;
3703 guint64 field_value, previous_value = 0;
3704 gboolean sorted = TRUE;
3705
3706 mono_class_init_checked (enumc, &error);
3707 if (mono_error_set_pending_exception (&error))
3708 return FALSE;
3709
3710
3711 if (!enumc->enumtype) {
3712 mono_set_pending_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum."));
3713 return TRUE;
3714 }
3715
3716 base_type = mono_class_enum_basetype (enumc)->type;
3717
3718 nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0;
3719 *names = mono_array_new_checked (domain, mono_defaults.string_class, nvalues, &error);
3720 if (mono_error_set_pending_exception (&error))
3721 return FALSE;
3722 *values = mono_array_new_checked (domain, mono_defaults.uint64_class, nvalues, &error);
3723 if (mono_error_set_pending_exception (&error))
3724 return FALSE;
3725
3726 iter = NULL;
3727 while ((field = mono_class_get_fields (enumc, &iter))) {
3728 const char *p;
3729 MonoTypeEnum def_type;
3730
3731 if (!(field->type->attrs & FIELD_ATTRIBUTE_STATIC))
3732 continue;
3733 if (strcmp ("value__", mono_field_get_name (field)) == 0)
3734 continue;
3735 if (mono_field_is_deleted (field))
3736 continue;
3737 mono_array_setref (*names, j, mono_string_new (domain, mono_field_get_name (field)));
3738
3739 p = mono_class_get_field_default_value (field, &def_type);
3740 /* len = */ mono_metadata_decode_blob_size (p, &p);
3741
3742 field_value = read_enum_value (p, base_type);
3743 mono_array_set (*values, guint64, j, field_value);
3744
3745 if (previous_value > field_value)
3746 sorted = FALSE;
3747
3748 previous_value = field_value;
3749 ++j;
3750 }
3751
3752 return sorted;
3753 }
3754
3755 enum {
3756 BFLAGS_IgnoreCase = 1,
3757 BFLAGS_DeclaredOnly = 2,
3758 BFLAGS_Instance = 4,
3759 BFLAGS_Static = 8,
3760 BFLAGS_Public = 0x10,
3761 BFLAGS_NonPublic = 0x20,
3762 BFLAGS_FlattenHierarchy = 0x40,
3763 BFLAGS_InvokeMethod = 0x100,
3764 BFLAGS_CreateInstance = 0x200,
3765 BFLAGS_GetField = 0x400,
3766 BFLAGS_SetField = 0x800,
3767 BFLAGS_GetProperty = 0x1000,
3768 BFLAGS_SetProperty = 0x2000,
3769 BFLAGS_ExactBinding = 0x10000,
3770 BFLAGS_SuppressChangeType = 0x20000,
3771 BFLAGS_OptionalParamBinding = 0x40000
3772 };
3773
3774 ICALL_EXPORT MonoArray*
3775 ves_icall_Type_GetFields_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype)
3776 {
3777 MonoError error;
3778 MonoDomain *domain;
3779 MonoClass *startklass, *klass, *refklass;
3780 MonoArray *res;
3781 MonoObject *member;
3782 int i, match;
3783 gpointer iter;
3784 char *utf8_name = NULL;
3785 int (*compare_func) (const char *s1, const char *s2) = NULL;
3786 MonoClassField *field;
3787 MonoPtrArray tmp_array;
3788
3789 domain = ((MonoObject *)type)->vtable->domain;
3790 if (type->type->byref) {
3791 MonoArray *result = mono_array_new_checked (domain, mono_defaults.field_info_class, 0, &error);
3792 mono_error_set_pending_exception (&error);
3793 return result;
3794 }
3795
3796 klass = startklass = mono_class_from_mono_type (type->type);
3797 refklass = mono_class_from_mono_type (reftype->type);
3798
3799 mono_ptr_array_init (tmp_array, 2, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection fields list");
3800
3801 handle_parent:
3802 if (mono_class_has_failure (klass)) {
3803 mono_ptr_array_destroy (tmp_array);
3804 mono_set_pending_exception (mono_class_get_exception_for_failure (klass));
3805 return NULL;
3806 }
3807
3808 iter = NULL;
3809 while ((field = mono_class_get_fields_lazy (klass, &iter))) {
3810 guint32 flags = mono_field_get_flags (field);
3811 match = 0;
3812 if (mono_field_is_deleted_with_flags (field, flags))
3813 continue;
3814 if ((flags & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) {
3815 if (bflags & BFLAGS_Public)
3816 match++;
3817 } else if ((klass == startklass) || (flags & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) != FIELD_ATTRIBUTE_PRIVATE) {
3818 if (bflags & BFLAGS_NonPublic) {
3819 match++;
3820 }
3821 }
3822 if (!match)
3823 continue;
3824 match = 0;
3825 if (flags & FIELD_ATTRIBUTE_STATIC) {
3826 if (bflags & BFLAGS_Static)
3827 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3828 match++;
3829 } else {
3830 if (bflags & BFLAGS_Instance)
3831 match++;
3832 }
3833
3834 if (!match)
3835 continue;
3836
3837 if (name != NULL) {
3838 if (utf8_name == NULL) {
3839 utf8_name = mono_string_to_utf8 (name);
3840 compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp;
3841 }
3842
3843 if (compare_func (mono_field_get_name (field), utf8_name))
3844 continue;
3845 }
3846
3847 member = (MonoObject*)mono_field_get_object_checked (domain, refklass, field, &error);
3848 if (!mono_error_ok (&error))
3849 goto fail;
3850 mono_ptr_array_append (tmp_array, member);
3851 }
3852 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3853 goto handle_parent;
3854
3855 res = mono_array_new_cached (domain, mono_defaults.field_info_class, mono_ptr_array_size (tmp_array), &error);
3856 if (!is_ok (&error))
3857 goto fail;
3858
3859 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
3860 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
3861
3862 mono_ptr_array_destroy (tmp_array);
3863
3864 if (utf8_name != NULL)
3865 g_free (utf8_name);
3866
3867 return res;
3868 fail:
3869 mono_ptr_array_destroy (tmp_array);
3870 mono_error_set_pending_exception (&error);
3871 return NULL;
3872 }
3873
3874 static gboolean
3875 method_nonpublic (MonoMethod* method, gboolean start_klass)
3876 {
3877 switch (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) {
3878 case METHOD_ATTRIBUTE_ASSEM:
3879 return (start_klass || mono_defaults.generic_ilist_class);
3880 case METHOD_ATTRIBUTE_PRIVATE:
3881 return start_klass;
3882 case METHOD_ATTRIBUTE_PUBLIC:
3883 return FALSE;
3884 default:
3885 return TRUE;
3886 }
3887 }
3888
3889 GPtrArray*
3890 mono_class_get_methods_by_name (MonoClass *klass, const char *name, guint32 bflags, gboolean ignore_case, gboolean allow_ctors, MonoException **ex)
3891 {
3892 GPtrArray *array;
3893 MonoClass *startklass;
3894 MonoMethod *method;
3895 gpointer iter;
3896 int match, nslots;
3897 /*FIXME, use MonoBitSet*/
3898 guint32 method_slots_default [8];
3899 guint32 *method_slots = NULL;
3900 int (*compare_func) (const char *s1, const char *s2) = NULL;
3901
3902 array = g_ptr_array_new ();
3903 startklass = klass;
3904 *ex = NULL;
3905
3906 if (name != NULL)
3907 compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
3908
3909 /* An optimization for calls made from Delegate:CreateDelegate () */
3910 if (klass->delegate && name && !strcmp (name, "Invoke") && (bflags == (BFLAGS_Public | BFLAGS_Static | BFLAGS_Instance))) {
3911 method = mono_get_delegate_invoke (klass);
3912 g_assert (method);
3913
3914 g_ptr_array_add (array, method);
3915 return array;
3916 }
3917
3918 mono_class_setup_methods (klass);
3919 mono_class_setup_vtable (klass);
3920 if (mono_class_has_failure (klass))
3921 goto loader_error;
3922
3923 if (is_generic_parameter (&klass->byval_arg))
3924 nslots = mono_class_get_vtable_size (klass->parent);
3925 else
3926 nslots = MONO_CLASS_IS_INTERFACE (klass) ? mono_class_num_methods (klass) : mono_class_get_vtable_size (klass);
3927 if (nslots >= sizeof (method_slots_default) * 8) {
3928 method_slots = g_new0 (guint32, nslots / 32 + 1);
3929 } else {
3930 method_slots = method_slots_default;
3931 memset (method_slots, 0, sizeof (method_slots_default));
3932 }
3933 handle_parent:
3934 mono_class_setup_methods (klass);
3935 mono_class_setup_vtable (klass);
3936 if (mono_class_has_failure (klass))
3937 goto loader_error;
3938
3939 iter = NULL;
3940 while ((method = mono_class_get_methods (klass, &iter))) {
3941 match = 0;
3942 if (method->slot != -1) {
3943 g_assert (method->slot < nslots);
3944 if (method_slots [method->slot >> 5] & (1 << (method->slot & 0x1f)))
3945 continue;
3946 if (!(method->flags & METHOD_ATTRIBUTE_NEW_SLOT))
3947 method_slots [method->slot >> 5] |= 1 << (method->slot & 0x1f);
3948 }
3949
3950 if (!allow_ctors && method->name [0] == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0))
3951 continue;
3952 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
3953 if (bflags & BFLAGS_Public)
3954 match++;
3955 } else if ((bflags & BFLAGS_NonPublic) && method_nonpublic (method, (klass == startklass))) {
3956 match++;
3957 }
3958 if (!match)
3959 continue;
3960 match = 0;
3961 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
3962 if (bflags & BFLAGS_Static)
3963 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
3964 match++;
3965 } else {
3966 if (bflags & BFLAGS_Instance)
3967 match++;
3968 }
3969
3970 if (!match)
3971 continue;
3972
3973 if (name != NULL) {
3974 if (compare_func (name, method->name))
3975 continue;
3976 }
3977
3978 match = 0;
3979 g_ptr_array_add (array, method);
3980 }
3981 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
3982 goto handle_parent;
3983 if (method_slots != method_slots_default)
3984 g_free (method_slots);
3985
3986 return array;
3987
3988 loader_error:
3989 if (method_slots != method_slots_default)
3990 g_free (method_slots);
3991 g_ptr_array_free (array, TRUE);
3992
3993 if (mono_class_has_failure (klass)) {
3994 *ex = mono_class_get_exception_for_failure (klass);
3995 } else {
3996 *ex = mono_get_exception_execution_engine ("Unknown error");
3997 }
3998 return NULL;
3999 }
4000
4001 ICALL_EXPORT MonoArray*
4002 ves_icall_Type_GetMethodsByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
4003 {
4004 static MonoClass *MethodInfo_array;
4005 MonoError error;
4006 MonoDomain *domain;
4007 MonoArray *res;
4008 MonoVTable *array_vtable;
4009 MonoException *ex = NULL;
4010 const char *mname = NULL;
4011 GPtrArray *method_array;
4012 MonoClass *klass, *refklass;
4013 int i;
4014
4015 mono_error_init (&error);
4016
4017 if (!MethodInfo_array) {
4018 MonoClass *klass = mono_array_class_get (mono_defaults.method_info_class, 1);
4019 mono_memory_barrier ();
4020 MethodInfo_array = klass;
4021 }
4022
4023 klass = mono_class_from_mono_type (type->type);
4024 refklass = mono_class_from_mono_type (reftype->type);
4025 domain = ((MonoObject *)type)->vtable->domain;
4026 array_vtable = mono_class_vtable_full (domain, MethodInfo_array, &error);
4027 if (!is_ok (&error)) {
4028 mono_error_set_pending_exception (&error);
4029 return NULL;
4030 }
4031 if (type->type->byref) {
4032 res = mono_array_new_specific_checked (array_vtable, 0, &error);
4033 mono_error_set_pending_exception (&error);
4034
4035 return res;
4036 }
4037
4038 if (name)
4039 mname = mono_string_to_utf8 (name);
4040
4041 method_array = mono_class_get_methods_by_name (klass, mname, bflags, ignore_case, FALSE, &ex);
4042 g_free ((char*)mname);
4043 if (ex) {
4044 mono_set_pending_exception (ex);
4045 return NULL;
4046 }
4047
4048 res = mono_array_new_specific_checked (array_vtable, method_array->len, &error);
4049 if (!mono_error_ok (&error)) {
4050 mono_error_set_pending_exception (&error);
4051 return NULL;
4052 }
4053
4054 for (i = 0; i < method_array->len; ++i) {
4055 MonoMethod *method = (MonoMethod *)g_ptr_array_index (method_array, i);
4056 MonoReflectionMethod *rm = mono_method_get_object_checked (domain, method, refklass, &error);
4057 if (!mono_error_ok (&error))
4058 goto failure;
4059 mono_array_setref (res, i, rm);
4060 }
4061
4062 failure:
4063 g_ptr_array_free (method_array, TRUE);
4064 if (!mono_error_ok (&error))
4065 mono_set_pending_exception (mono_error_convert_to_exception (&error));
4066 return res;
4067 }
4068
4069 ICALL_EXPORT MonoArray*
4070 ves_icall_Type_GetConstructors_internal (MonoReflectionType *type, guint32 bflags, MonoReflectionType *reftype)
4071 {
4072 MonoDomain *domain;
4073 MonoClass *startklass, *klass, *refklass;
4074 MonoArray *res = NULL;
4075 MonoMethod *method;
4076 MonoObject *member;
4077 int i, match;
4078 gpointer iter = NULL;
4079 MonoPtrArray tmp_array;
4080 MonoError error;
4081
4082 domain = ((MonoObject *)type)->vtable->domain;
4083 if (type->type->byref) {
4084 res = mono_array_new_cached (domain, mono_defaults.method_info_class, 0, &error);
4085 mono_error_set_pending_exception (&error);
4086 return res;
4087 }
4088
4089 mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection constructors list"); /*FIXME, guestimating*/
4090
4091
4092 klass = startklass = mono_class_from_mono_type (type->type);
4093 refklass = mono_class_from_mono_type (reftype->type);
4094
4095 mono_class_setup_methods (klass);
4096 if (mono_class_has_failure (klass)) {
4097 mono_set_pending_exception (mono_class_get_exception_for_failure (klass));
4098 goto leave;
4099 }
4100
4101 iter = NULL;
4102 while ((method = mono_class_get_methods (klass, &iter))) {
4103 match = 0;
4104 if (strcmp (method->name, ".ctor") && strcmp (method->name, ".cctor"))
4105 continue;
4106 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
4107 if (bflags & BFLAGS_Public)
4108 match++;
4109 } else {
4110 if (bflags & BFLAGS_NonPublic)
4111 match++;
4112 }
4113 if (!match)
4114 continue;
4115 match = 0;
4116 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
4117 if (bflags & BFLAGS_Static)
4118 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
4119 match++;
4120 } else {
4121 if (bflags & BFLAGS_Instance)
4122 match++;
4123 }
4124
4125 if (!match)
4126 continue;
4127 member = (MonoObject*)mono_method_get_object_checked (domain, method, refklass, &error);
4128 if (mono_error_set_pending_exception (&error))
4129 goto leave;
4130
4131 mono_ptr_array_append (tmp_array, member);
4132 }
4133
4134 res = mono_array_new_cached (domain, mono_class_get_constructor_info_class (), mono_ptr_array_size (tmp_array), &error);
4135 if (mono_error_set_pending_exception (&error))
4136 goto leave;
4137
4138 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
4139 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
4140
4141 leave:
4142 mono_ptr_array_destroy (tmp_array);
4143
4144 return res;
4145 }
4146
4147 static guint
4148 property_hash (gconstpointer data)
4149 {
4150 MonoProperty *prop = (MonoProperty*)data;
4151
4152 return g_str_hash (prop->name);
4153 }
4154
4155 static gboolean
4156 method_declaring_signatures_equal (MonoMethod *method1, MonoMethod *method2)
4157 {
4158 if (method1->is_inflated)
4159 method1 = ((MonoMethodInflated*) method1)->declaring;
4160 if (method2->is_inflated)
4161 method2 = ((MonoMethodInflated*) method2)->declaring;
4162
4163 return mono_metadata_signature_equal (mono_method_signature (method1), mono_method_signature (method2));
4164 }
4165
4166 static gboolean
4167 property_equal (MonoProperty *prop1, MonoProperty *prop2)
4168 {
4169 // Properties are hide-by-name-and-signature
4170 if (!g_str_equal (prop1->name, prop2->name))
4171 return FALSE;
4172
4173 /* If we see a property in a generic method, we want to
4174 compare the generic signatures, not the inflated signatures
4175 because we might conflate two properties that were
4176 distinct:
4177
4178 class Foo<T,U> {
4179 public T this[T t] { getter { return t; } } // method 1
4180 public U this[U u] { getter { return u; } } // method 2
4181 }
4182
4183 If we see int Foo<int,int>::Item[int] we need to know if
4184 the indexer came from method 1 or from method 2, and we
4185 shouldn't conflate them. (Bugzilla 36283)
4186 */
4187 if (prop1->get && prop2->get && !method_declaring_signatures_equal (prop1->get, prop2->get))
4188 return FALSE;
4189
4190 if (prop1->set && prop2->set && !method_declaring_signatures_equal (prop1->set, prop2->set))
4191 return FALSE;
4192
4193 return TRUE;
4194 }
4195
4196 static gboolean
4197 property_accessor_nonpublic (MonoMethod* accessor, gboolean start_klass)
4198 {
4199 if (!accessor)
4200 return FALSE;
4201
4202 return method_nonpublic (accessor, start_klass);
4203 }
4204
4205 ICALL_EXPORT MonoArray*
4206 ves_icall_Type_GetPropertiesByName (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType *reftype)
4207 {
4208 MonoError error;
4209 MonoDomain *domain;
4210 MonoClass *startklass, *klass;
4211 MonoArray *res;
4212 MonoMethod *method;
4213 MonoProperty *prop;
4214 int i, match;
4215 guint32 flags;
4216 gchar *propname = NULL;
4217 int (*compare_func) (const char *s1, const char *s2) = NULL;
4218 gpointer iter;
4219 GHashTable *properties = NULL;
4220 MonoPtrArray tmp_array;
4221
4222 mono_error_init (&error);
4223
4224 domain = ((MonoObject *)type)->vtable->domain;
4225 if (type->type->byref) {
4226 res = mono_array_new_cached (domain, mono_class_get_property_info_class (), 0, &error);
4227 mono_error_set_pending_exception (&error);
4228 return res;
4229 }
4230
4231 mono_ptr_array_init (tmp_array, 8, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection properties list"); /*This the average for ASP.NET types*/
4232
4233 klass = startklass = mono_class_from_mono_type (type->type);
4234
4235 if (name != NULL) {
4236 propname = mono_string_to_utf8 (name);
4237 compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp;
4238 }
4239
4240 properties = g_hash_table_new (property_hash, (GEqualFunc)property_equal);
4241 handle_parent:
4242 mono_class_setup_methods (klass);
4243 mono_class_setup_vtable (klass);
4244 if (mono_class_has_failure (klass))
4245 goto loader_error;
4246
4247 iter = NULL;
4248 while ((prop = mono_class_get_properties (klass, &iter))) {
4249 match = 0;
4250 method = prop->get;
4251 if (!method)
4252 method = prop->set;
4253 if (method)
4254 flags = method->flags;
4255 else
4256 flags = 0;
4257 if ((prop->get && ((prop->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC)) ||
4258 (prop->set && ((prop->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC))) {
4259 if (bflags & BFLAGS_Public)
4260 match++;
4261 } else if (bflags & BFLAGS_NonPublic) {
4262 if (property_accessor_nonpublic(prop->get, startklass == klass) ||
4263 property_accessor_nonpublic(prop->set, startklass == klass)) {
4264 match++;
4265 }
4266 }
4267 if (!match)
4268 continue;
4269 match = 0;
4270 if (flags & METHOD_ATTRIBUTE_STATIC) {
4271 if (bflags & BFLAGS_Static)
4272 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
4273 match++;
4274 } else {
4275 if (bflags & BFLAGS_Instance)
4276 match++;
4277 }
4278
4279 if (!match)
4280 continue;
4281 match = 0;
4282
4283 if (name != NULL) {
4284 if (compare_func (propname, prop->name))
4285 continue;
4286 }
4287
4288 if (g_hash_table_lookup (properties, prop))
4289 continue;
4290
4291 MonoReflectionProperty *pr = mono_property_get_object_checked (domain, startklass, prop, &error);
4292 if (!pr)
4293 goto failure;
4294 mono_ptr_array_append (tmp_array, pr);
4295
4296 g_hash_table_insert (properties, prop, prop);
4297 }
4298 if ((!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)))
4299 goto handle_parent;
4300
4301 g_hash_table_destroy (properties);
4302 g_free (propname);
4303
4304 res = mono_array_new_cached (domain, mono_class_get_property_info_class (), mono_ptr_array_size (tmp_array), &error);
4305 if (!is_ok (&error))
4306 goto failure;
4307 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
4308 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
4309
4310 mono_ptr_array_destroy (tmp_array);
4311
4312 return res;
4313
4314
4315
4316 loader_error:
4317 if (mono_class_has_failure (klass)) {
4318 mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass));
4319 }
4320
4321 failure:
4322 if (properties)
4323 g_hash_table_destroy (properties);
4324 if (name)
4325 g_free (propname);
4326 mono_ptr_array_destroy (tmp_array);
4327
4328 mono_error_set_pending_exception (&error);
4329
4330 return NULL;
4331 }
4332
4333 static guint
4334 event_hash (gconstpointer data)
4335 {
4336 MonoEvent *event = (MonoEvent*)data;
4337
4338 return g_str_hash (event->name);
4339 }
4340
4341 static gboolean
4342 event_equal (MonoEvent *event1, MonoEvent *event2)
4343 {
4344 // Events are hide-by-name
4345 return g_str_equal (event1->name, event2->name);
4346 }
4347
4348 ICALL_EXPORT MonoArray*
4349 ves_icall_Type_GetEvents_internal (MonoReflectionType *type, MonoString *name, guint32 bflags, MonoReflectionType *reftype)
4350 {
4351 MonoError error;
4352 MonoDomain *domain;
4353 MonoClass *startklass, *klass;
4354 MonoArray *res;
4355 MonoMethod *method;
4356 MonoEvent *event;
4357 int i, match;
4358 gpointer iter;
4359 char *utf8_name = NULL;
4360 int (*compare_func) (const char *s1, const char *s2) = NULL;
4361 GHashTable *events = NULL;
4362 MonoPtrArray tmp_array;
4363
4364 mono_error_init (&error);
4365
4366 domain = mono_object_domain (type);
4367 if (type->type->byref) {
4368 res = mono_array_new_cached (domain, mono_class_get_event_info_class (), 0, &error);
4369 mono_error_set_pending_exception (&error);
4370 return res;
4371 }
4372
4373 mono_ptr_array_init (tmp_array, 4, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection events list");
4374
4375 klass = startklass = mono_class_from_mono_type (type->type);
4376
4377 events = g_hash_table_new (event_hash, (GEqualFunc)event_equal);
4378 handle_parent:
4379 mono_class_setup_methods (klass);
4380 mono_class_setup_vtable (klass);
4381 if (mono_class_has_failure (klass))
4382 goto loader_error;
4383
4384 iter = NULL;
4385 while ((event = mono_class_get_events (klass, &iter))) {
4386 match = 0;
4387 method = event->add;
4388 if (!method)
4389 method = event->remove;
4390 if (!method)
4391 method = event->raise;
4392 if (method) {
4393 if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) {
4394 if (bflags & BFLAGS_Public)
4395 match++;
4396 } else if ((klass == startklass) || (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) {
4397 if (bflags & BFLAGS_NonPublic)
4398 match++;
4399 }
4400 }
4401 else
4402 if (bflags & BFLAGS_NonPublic)
4403 match ++;
4404 if (!match)
4405 continue;
4406 match = 0;
4407 if (method) {
4408 if (method->flags & METHOD_ATTRIBUTE_STATIC) {
4409 if (bflags & BFLAGS_Static)
4410 if ((bflags & BFLAGS_FlattenHierarchy) || (klass == startklass))
4411 match++;
4412 } else {
4413 if (bflags & BFLAGS_Instance)
4414 match++;
4415 }
4416 }
4417 else
4418 if (bflags & BFLAGS_Instance)
4419 match ++;
4420 if (!match)
4421 continue;
4422
4423 if (name != NULL) {
4424 if (utf8_name == NULL) {
4425 utf8_name = mono_string_to_utf8 (name);
4426 compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp;
4427 }
4428
4429 if (compare_func (event->name, utf8_name))
4430 continue;
4431 }
4432
4433 if (g_hash_table_lookup (events, event))
4434 continue;
4435
4436 MonoReflectionEvent *ev_obj;
4437 ev_obj = mono_event_get_object_checked (domain, startklass, event, &error);
4438 if (!ev_obj)
4439 goto failure;
4440 mono_ptr_array_append (tmp_array, ev_obj);
4441
4442 g_hash_table_insert (events, event, event);
4443 }
4444 if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))
4445 goto handle_parent;
4446
4447 g_hash_table_destroy (events);
4448
4449 res = mono_array_new_cached (domain, mono_class_get_event_info_class (), mono_ptr_array_size (tmp_array), &error);
4450 if (!is_ok (&error))
4451 goto failure;
4452
4453 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
4454 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
4455
4456 mono_ptr_array_destroy (tmp_array);
4457
4458 if (utf8_name != NULL)
4459 g_free (utf8_name);
4460
4461 return res;
4462
4463 loader_error:
4464 if (mono_class_has_failure (klass)) {
4465 mono_error_set_exception_instance (&error, mono_class_get_exception_for_failure (klass));
4466 }
4467
4468 failure:
4469
4470 if (events != NULL)
4471 g_hash_table_destroy (events);
4472 if (utf8_name != NULL)
4473 g_free (utf8_name);
4474
4475 mono_ptr_array_destroy (tmp_array);
4476
4477 mono_error_set_pending_exception (&error);
4478 return NULL;
4479 }
4480
4481 ICALL_EXPORT MonoArray*
4482 ves_icall_Type_GetNestedTypes (MonoReflectionType *type, MonoString *name, guint32 bflags)
4483 {
4484 MonoError error;
4485 MonoReflectionType *rt;
4486 MonoDomain *domain;
4487 MonoClass *klass;
4488 MonoArray *res = NULL;
4489 int i, match;
4490 MonoClass *nested;
4491 gpointer iter;
4492 char *str = NULL;
4493 MonoPtrArray tmp_array;
4494
4495 mono_error_init (&error);
4496
4497 domain = ((MonoObject *)type)->vtable->domain;
4498 if (type->type->byref) {
4499 MonoArray *result = mono_array_new_cached (domain, mono_defaults.monotype_class, 0, &error);
4500 mono_error_set_pending_exception (&error);
4501 return result;
4502 }
4503 klass = mono_class_from_mono_type (type->type);
4504
4505 /*
4506 * If a nested type is generic, return its generic type definition.
4507 * Note that this means that the return value is essentially the set
4508 * of nested types of the generic type definition of @klass.
4509 *
4510 * A note in MSDN claims that a generic type definition can have
4511 * nested types that aren't generic. In any case, the container of that
4512 * nested type would be the generic type definition.
4513 */
4514 if (klass->generic_class)
4515 klass = klass->generic_class->container_class;
4516
4517 mono_ptr_array_init (tmp_array, 1, MONO_ROOT_SOURCE_REFLECTION, "temporary reflection nested types list");
4518 iter = NULL;
4519 while ((nested = mono_class_get_nested_types (klass, &iter))) {
4520 match = 0;
4521 if ((nested->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK) == TYPE_ATTRIBUTE_NESTED_PUBLIC) {
4522 if (bflags & BFLAGS_Public)
4523 match++;
4524 } else {
4525 if (bflags & BFLAGS_NonPublic)
4526 match++;
4527 }
4528 if (!match)
4529 continue;
4530
4531 if (name != NULL) {
4532 if (str == NULL) {
4533 str = mono_string_to_utf8 (name);
4534 mono_identifier_unescape_type_name_chars (str);
4535 }
4536
4537 if (strcmp (nested->name, str))
4538 continue;
4539 }
4540
4541 rt = mono_type_get_object_checked (domain, &nested->byval_arg, &error);
4542 if (!is_ok (&error))
4543 goto leave;
4544
4545 mono_ptr_array_append (tmp_array, (MonoObject*) rt);
4546 }
4547
4548 res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array), &error);
4549 if (!is_ok (&error))
4550 goto leave;
4551
4552 for (i = 0; i < mono_ptr_array_size (tmp_array); ++i)
4553 mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i));
4554
4555 leave:
4556 mono_ptr_array_destroy (tmp_array);
4557
4558 g_free (str);
4559
4560 mono_error_set_pending_exception (&error);
4561 return res;
4562 }
4563
4564 ICALL_EXPORT MonoReflectionType*
4565 ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly *assembly, MonoReflectionModule *module, MonoString *name, MonoBoolean throwOnError, MonoBoolean ignoreCase)
4566 {
4567 MonoError error;
4568 MonoReflectionType *ret;
4569 gchar *str;
4570 MonoType *type = NULL;
4571 MonoTypeNameParse info;
4572 gboolean type_resolve;
4573
4574 /* On MS.NET, this does not fire a TypeResolve event */
4575 type_resolve = TRUE;
4576 str = mono_string_to_utf8 (name);
4577 /*g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);*/
4578 if (!mono_reflection_parse_type (str, &info)) {
4579 g_free (str);
4580 mono_reflection_free_type_info (&info);
4581 if (throwOnError) {
4582 mono_set_pending_exception (mono_get_exception_argument("name", "failed parse"));
4583 return NULL;
4584 }
4585 /*g_print ("failed parse\n");*/
4586 return NULL;
4587 }
4588
4589 if (info.assembly.name) {
4590 g_free (str);
4591 mono_reflection_free_type_info (&info);
4592 if (throwOnError) {
4593 /* 1.0 and 2.0 throw different exceptions */
4594 if (mono_defaults.generic_ilist_class)
4595 mono_set_pending_exception (mono_get_exception_argument (NULL, "Type names passed to Assembly.GetType() must not specify an assembly."));
4596 else
4597 mono_set_pending_exception (mono_get_exception_type_load (name, NULL));
4598 return NULL;
4599 }
4600 return NULL;
4601 }
4602
4603 if (module != NULL) {
4604 if (module->image) {
4605 type = mono_reflection_get_type_checked (module->image, module->image, &info, ignoreCase, &type_resolve, &error);
4606 if (!is_ok (&error)) {
4607 g_free (str);
4608 mono_reflection_free_type_info (&info);
4609 mono_error_set_pending_exception (&error);
4610 return NULL;
4611 }
4612 } else
4613 type = NULL;
4614 }
4615 else
4616 if (assembly_is_dynamic (assembly->assembly)) {
4617 /* Enumerate all modules */
4618 MonoReflectionAssemblyBuilder *abuilder = (MonoReflectionAssemblyBuilder*)assembly;
4619 int i;
4620
4621 type = NULL;
4622 if (abuilder->modules) {
4623 for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
4624 MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
4625 type = mono_reflection_get_type_checked (&mb->dynamic_image->image, &mb->dynamic_image->image, &info, ignoreCase, &type_resolve, &error);
4626 if (!is_ok (&error)) {
4627 g_free (str);
4628 mono_reflection_free_type_info (&info);
4629 mono_error_set_pending_exception (&error);
4630 return NULL;
4631 }
4632 if (type)
4633 break;
4634 }
4635 }
4636
4637 if (!type && abuilder->loaded_modules) {
4638 for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
4639 MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
4640 type = mono_reflection_get_type_checked (mod->image, mod->image, &info, ignoreCase, &type_resolve, &error);
4641 if (!is_ok (&error)) {
4642 g_free (str);
4643 mono_reflection_free_type_info (&info);
4644 mono_error_set_pending_exception (&error);
4645 return NULL;
4646 }
4647 if (type)
4648 break;
4649 }
4650 }
4651 }
4652 else {
4653 type = mono_reflection_get_type_checked (assembly->assembly->image, assembly->assembly->image, &info, ignoreCase, &type_resolve, &error);
4654 if (!is_ok (&error)) {
4655 g_free (str);
4656 mono_reflection_free_type_info (&info);
4657 mono_error_set_pending_exception (&error);
4658 return NULL;
4659 }
4660 }
4661 g_free (str);
4662 mono_reflection_free_type_info (&info);
4663 if (!type) {
4664 MonoException *e = NULL;
4665
4666 if (throwOnError)
4667 e = mono_get_exception_type_load (name, NULL);
4668
4669 if (e != NULL)
4670 mono_set_pending_exception (e);
4671 return NULL;
4672 }
4673
4674 if (type->type == MONO_TYPE_CLASS) {
4675 MonoClass *klass = mono_type_get_class (type);
4676
4677 /* need to report exceptions ? */
4678 if (throwOnError && mono_class_has_failure (klass)) {
4679 /* report SecurityException (or others) that occured when loading the assembly */
4680 MonoException *exc = mono_class_get_exception_for_failure (klass);
4681 mono_set_pending_exception (exc);
4682 return NULL;
4683 }
4684 }
4685
4686 /* g_print ("got it\n"); */
4687 ret = mono_type_get_object_checked (mono_object_domain (assembly), type, &error);
4688 mono_error_set_pending_exception (&error);
4689
4690 return ret;
4691 }
4692
4693 static gboolean
4694 replace_shadow_path (MonoDomain *domain, gchar *dirname, gchar **filename)
4695 {
4696 gchar *content;
4697 gchar *shadow_ini_file;
4698 gsize len;
4699
4700 /* Check for shadow-copied assembly */
4701 if (mono_is_shadow_copy_enabled (domain, dirname)) {
4702 shadow_ini_file = g_build_filename (dirname, "__AssemblyInfo__.ini", NULL);
4703 content = NULL;
4704 if (!g_file_get_contents (shadow_ini_file, &content, &len, NULL) ||
4705 !g_file_test (content, G_FILE_TEST_IS_REGULAR)) {
4706 if (content) {
4707 g_free (content);
4708 content = NULL;
4709 }
4710 }
4711 g_free (shadow_ini_file);
4712 if (content != NULL) {
4713 if (*filename)
4714 g_free (*filename);
4715 *filename = content;
4716 return TRUE;
4717 }
4718 }
4719 return FALSE;
4720 }
4721
4722 ICALL_EXPORT MonoString *
4723 ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly *assembly, MonoBoolean escaped)
4724 {
4725 MonoDomain *domain = mono_object_domain (assembly);
4726 MonoAssembly *mass = assembly->assembly;
4727 MonoString *res = NULL;
4728 gchar *uri;
4729 gchar *absolute;
4730 gchar *dirname;
4731
4732 if (g_path_is_absolute (mass->image->name)) {
4733 absolute = g_strdup (mass->image->name);
4734 dirname = g_path_get_dirname (absolute);
4735 } else {
4736 absolute = g_build_filename (mass->basedir, mass->image->name, NULL);
4737 dirname = g_strdup (mass->basedir);
4738 }
4739
4740 replace_shadow_path (domain, dirname, &absolute);
4741 g_free (dirname);
4742 #if HOST_WIN32
4743 {
4744 gint i;
4745 for (i = strlen (absolute) - 1; i >= 0; i--)
4746 if (absolute [i] == '\\')
4747 absolute [i] = '/';
4748 }
4749 #endif
4750 if (escaped) {
4751 uri = g_filename_to_uri (absolute, NULL, NULL);
4752 } else {
4753 const char *prepend = "file://";
4754 #if HOST_WIN32
4755 if (*absolute == '/' && *(absolute + 1) == '/') {
4756 prepend = "file:";
4757 } else {
4758 prepend = "file:///";
4759 }
4760 #endif
4761 uri = g_strconcat (prepend, absolute, NULL);
4762 }
4763
4764 if (uri) {
4765 res = mono_string_new (domain, uri);
4766 g_free (uri);
4767 }
4768 g_free (absolute);
4769 return res;
4770 }
4771
4772 ICALL_EXPORT MonoBoolean
4773 ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAssembly *assembly)
4774 {
4775 MonoAssembly *mass = assembly->assembly;
4776
4777 return mass->in_gac;
4778 }
4779
4780 ICALL_EXPORT MonoReflectionAssembly*
4781 ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoObject *evidence)
4782 {
4783 MonoError error;
4784 gchar *name;
4785 MonoAssembly *res;
4786 MonoImageOpenStatus status;
4787 MonoReflectionAssembly* result = NULL;
4788
4789 name = mono_string_to_utf8 (mname);
4790 res = mono_assembly_load_with_partial_name (name, &status);
4791
4792 g_free (name);
4793
4794 if (res == NULL)
4795 return NULL;
4796 result = mono_assembly_get_object_checked (mono_domain_get (), res, &error);
4797 if (!result)
4798 mono_error_set_pending_exception (&error);
4799 return result;
4800 }
4801
4802 ICALL_EXPORT MonoString *
4803 ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly *assembly)
4804 {
4805 MonoDomain *domain = mono_object_domain (assembly);
4806 MonoString *res;
4807
4808 res = mono_string_new (domain, mono_image_get_filename (assembly->assembly->image));
4809
4810 return res;
4811 }
4812
4813 ICALL_EXPORT MonoBoolean
4814 ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly *assembly)
4815 {
4816 return assembly->assembly->ref_only;
4817 }
4818
4819 ICALL_EXPORT MonoString *
4820 ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflectionAssembly *assembly)
4821 {
4822 MonoDomain *domain = mono_object_domain (assembly);
4823
4824 return mono_string_new (domain, assembly->assembly->image->version);
4825 }
4826
4827 ICALL_EXPORT MonoReflectionMethod*
4828 ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly *assembly)
4829 {
4830 MonoError error;
4831 MonoReflectionMethod *res = NULL;
4832 MonoMethod *method;
4833
4834 guint32 token = mono_image_get_entry_point (assembly->assembly->image);
4835
4836 if (!token)
4837 return NULL;
4838 method = mono_get_method_checked (assembly->assembly->image, token, NULL, NULL, &error);
4839 if (!mono_error_ok (&error))
4840 goto leave;
4841
4842 res = mono_method_get_object_checked (mono_object_domain (assembly), method, NULL, &error);
4843
4844 leave:
4845 if (!mono_error_ok (&error))
4846 mono_error_set_pending_exception (&error);
4847 return res;
4848 }
4849
4850 ICALL_EXPORT MonoReflectionModule*
4851 ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssembly *assembly)
4852 {
4853 MonoError error;
4854 MonoReflectionModule *result = NULL;
4855 result = mono_module_get_object_checked (mono_object_domain (assembly), assembly->assembly->image, &error);
4856 if (!mono_error_ok (&error))
4857 mono_error_set_pending_exception (&error);
4858 return result;
4859 }
4860
4861 ICALL_EXPORT MonoArray*
4862 ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly *assembly)
4863 {
4864 MonoError error;
4865 MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
4866 MonoArray *result = mono_array_new_checked (mono_object_domain (assembly), mono_defaults.string_class, table->rows, &error);
4867 if (mono_error_set_pending_exception (&error))
4868 return NULL;
4869 int i;
4870 const char *val;
4871
4872 for (i = 0; i < table->rows; ++i) {
4873 val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME));
4874 mono_array_setref (result, i, mono_string_new (mono_object_domain (assembly), val));
4875 }
4876 return result;
4877 }
4878
4879 static MonoObject*
4880 create_version (MonoDomain *domain, guint32 major, guint32 minor, guint32 build, guint32 revision, MonoError *error)
4881 {
4882 static MonoMethod *create_version = NULL;
4883 MonoObject *result;
4884 gpointer args [4];
4885
4886 mono_error_init (error);
4887
4888
4889 if (!create_version) {
4890 MonoMethodDesc *desc = mono_method_desc_new (":.ctor(int,int,int,int)", FALSE);
4891 create_version = mono_method_desc_search_in_class (desc, mono_class_get_system_version_class ());
4892 g_assert (create_version);
4893 mono_method_desc_free (desc);
4894 }
4895
4896 args [0] = &major;
4897 args [1] = &minor;
4898 args [2] = &build;
4899 args [3] = &revision;
4900 result = mono_object_new_checked (domain, mono_class_get_system_version_class (), error);
4901 return_val_if_nok (error, NULL);
4902
4903 mono_runtime_invoke_checked (create_version, result, args, error);
4904 return_val_if_nok (error, NULL);
4905
4906 return result;
4907 }
4908
4909 ICALL_EXPORT MonoArray*
4910 ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly *assembly)
4911 {
4912 MonoError error;
4913 MonoArray *result;
4914 MonoDomain *domain = mono_object_domain (assembly);
4915 int i, count = 0;
4916 static MonoMethod *create_culture = NULL;
4917 MonoImage *image = assembly->assembly->image;
4918 MonoTableInfo *t;
4919 MonoObject *o;
4920
4921 t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF];
4922 count = t->rows;
4923
4924 result = mono_array_new_checked (domain, mono_class_get_assembly_name_class (), count, &error);
4925 if (mono_error_set_pending_exception (&error))
4926 return NULL;
4927
4928
4929 if (count > 0 && !create_culture) {
4930 MonoMethodDesc *desc = mono_method_desc_new (
4931 "System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE);
4932 create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib);
4933 g_assert (create_culture);
4934 mono_method_desc_free (desc);
4935 }
4936
4937 for (i = 0; i < count; i++) {
4938 MonoObject *version;
4939 MonoReflectionAssemblyName *aname;
4940 guint32 cols [MONO_ASSEMBLYREF_SIZE];
4941
4942 mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE);
4943
4944 aname = (MonoReflectionAssemblyName *) mono_object_new_checked (
4945 domain, mono_class_get_assembly_name_class (), &error);
4946 if (mono_error_set_pending_exception (&error))
4947 return NULL;
4948
4949 MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME])));
4950
4951 aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION];
4952 aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION];
4953 aname->build = cols [MONO_ASSEMBLYREF_BUILD_NUMBER];
4954 aname->revision = cols [MONO_ASSEMBLYREF_REV_NUMBER];
4955 aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
4956 aname->versioncompat = 1; /* SameMachine (default) */
4957 aname->hashalg = ASSEMBLY_HASH_SHA1; /* SHA1 (default) */
4958
4959 version = create_version (domain, aname->major, aname->minor, aname->build, aname->revision, &error);
4960 if (mono_error_set_pending_exception (&error))
4961 return NULL;
4962
4963 MONO_OBJECT_SETREF (aname, version, version);
4964
4965 if (create_culture) {
4966 gpointer args [2];
4967 MonoBoolean assembly_ref = 1;
4968 args [0] = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE]));
4969 args [1] = &assembly_ref;
4970
4971 o = mono_runtime_invoke_checked (create_culture, NULL, args, &error);
4972 if (mono_error_set_pending_exception (&error))
4973 return NULL;
4974
4975 MONO_OBJECT_SETREF (aname, cultureInfo, o);
4976 }
4977
4978 if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
4979 const gchar *pkey_ptr = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY]);
4980 guint32 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
4981
4982 if ((cols [MONO_ASSEMBLYREF_FLAGS] & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG)) {
4983 /* public key token isn't copied - the class library will
4984 automatically generate it from the public key if required */
4985 MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error);
4986 if (mono_error_set_pending_exception (&error))
4987 return NULL;
4988
4989 MONO_OBJECT_SETREF (aname, publicKey, pkey);
4990 memcpy (mono_array_addr (pkey, guint8, 0), pkey_ptr, pkey_len);
4991 } else {
4992 MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, &error);
4993 if (mono_error_set_pending_exception (&error))
4994 return NULL;
4995
4996 MONO_OBJECT_SETREF (aname, keyToken, keyToken);
4997 memcpy (mono_array_addr (keyToken, guint8, 0), pkey_ptr, pkey_len);
4998 }
4999 } else {
5000 MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, &error);
5001 if (mono_error_set_pending_exception (&error))
5002 return NULL;
5003
5004 MONO_OBJECT_SETREF (aname, keyToken, keyToken);
5005 }
5006
5007 /* note: this function doesn't return the codebase on purpose (i.e. it can
5008 be used under partial trust as path information isn't present). */
5009
5010 mono_array_setref (result, i, aname);
5011 }
5012 return result;
5013 }
5014
5015 /* move this in some file in mono/util/ */
5016 static char *
5017 g_concat_dir_and_file (const char *dir, const char *file)
5018 {
5019 g_return_val_if_fail (dir != NULL, NULL);
5020 g_return_val_if_fail (file != NULL, NULL);
5021
5022 /*
5023 * If the directory name doesn't have a / on the end, we need
5024 * to add one so we get a proper path to the file
5025 */
5026 if (dir [strlen(dir) - 1] != G_DIR_SEPARATOR)
5027 return g_strconcat (dir, G_DIR_SEPARATOR_S, file, NULL);
5028 else
5029 return g_strconcat (dir, file, NULL);
5030 }
5031
5032 ICALL_EXPORT void *
5033 ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly *assembly, MonoString *name, gint32 *size, MonoReflectionModule **ref_module)
5034 {
5035 MonoError error;
5036 char *n = mono_string_to_utf8 (name);
5037 MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
5038 guint32 i;
5039 guint32 cols [MONO_MANIFEST_SIZE];
5040 guint32 impl, file_idx;
5041 const char *val;
5042 MonoImage *module;
5043
5044 for (i = 0; i < table->rows; ++i) {
5045 mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
5046 val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
5047 if (strcmp (val, n) == 0)
5048 break;
5049 }
5050 g_free (n);
5051 if (i == table->rows)
5052 return NULL;
5053 /* FIXME */
5054 impl = cols [MONO_MANIFEST_IMPLEMENTATION];
5055 if (impl) {
5056 /*
5057 * this code should only be called after obtaining the
5058 * ResourceInfo and handling the other cases.
5059 */
5060 g_assert ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE);
5061 file_idx = impl >> MONO_IMPLEMENTATION_BITS;
5062
5063 module = mono_image_load_file_for_image (assembly->assembly->image, file_idx);
5064 if (!module)
5065 return NULL;
5066 }
5067 else
5068 module = assembly->assembly->image;
5069
5070
5071 MonoReflectionModule *rm = mono_module_get_object_checked (mono_domain_get (), module, &error);
5072 if (mono_error_set_pending_exception (&error))
5073 return NULL;
5074 mono_gc_wbarrier_generic_store (ref_module, (MonoObject*) rm);
5075
5076 return (void*)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32*)size);
5077 }
5078
5079 ICALL_EXPORT gboolean
5080 ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoManifestResourceInfo *info)
5081 {
5082 MonoError error;
5083 MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE];
5084 int i;
5085 guint32 cols [MONO_MANIFEST_SIZE];
5086 guint32 file_cols [MONO_FILE_SIZE];
5087 const char *val;
5088 char *n;
5089
5090 n = mono_string_to_utf8 (name);
5091 for (i = 0; i < table->rows; ++i) {
5092 mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE);
5093 val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]);
5094 if (strcmp (val, n) == 0)
5095 break;
5096 }
5097 g_free (n);
5098 if (i == table->rows)
5099 return FALSE;
5100
5101 if (!cols [MONO_MANIFEST_IMPLEMENTATION]) {
5102 info->location = RESOURCE_LOCATION_EMBEDDED | RESOURCE_LOCATION_IN_MANIFEST;
5103 }
5104 else {
5105 switch (cols [MONO_MANIFEST_IMPLEMENTATION] & MONO_IMPLEMENTATION_MASK) {
5106 case MONO_IMPLEMENTATION_FILE:
5107 i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
5108 table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
5109 mono_metadata_decode_row (table, i - 1, file_cols, MONO_FILE_SIZE);
5110 val = mono_metadata_string_heap (assembly->assembly->image, file_cols [MONO_FILE_NAME]);
5111 MONO_OBJECT_SETREF (info, filename, mono_string_new (mono_object_domain (assembly), val));
5112 if (file_cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA)
5113 info->location = 0;
5114 else
5115 info->location = RESOURCE_LOCATION_EMBEDDED;
5116 break;
5117
5118 case MONO_IMPLEMENTATION_ASSEMBLYREF:
5119 i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS;
5120 mono_assembly_load_reference (assembly->assembly->image, i - 1);
5121 if (assembly->assembly->image->references [i - 1] == (gpointer)-1) {
5122 char *msg = g_strdup_printf ("Assembly %d referenced from assembly %s not found ", i - 1, assembly->assembly->image->name);
5123 MonoException *ex = mono_get_exception_file_not_found2 (msg, NULL);
5124 g_free (msg);
5125 mono_set_pending_exception (ex);
5126 return FALSE;
5127 }
5128 MonoReflectionAssembly *assm_obj;
5129 assm_obj = mono_assembly_get_object_checked (mono_domain_get (), assembly->assembly->image->references [i - 1], &error);
5130 if (!assm_obj) {
5131 mono_error_set_pending_exception (&error);
5132 return FALSE;
5133 }
5134 MONO_OBJECT_SETREF (info, assembly, assm_obj);
5135
5136 /* Obtain info recursively */
5137 ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (info->assembly, name, info);
5138 info->location |= RESOURCE_LOCATION_ANOTHER_ASSEMBLY;
5139 break;
5140
5141 case MONO_IMPLEMENTATION_EXP_TYPE:
5142 g_assert_not_reached ();
5143 break;
5144 }
5145 }
5146
5147 return TRUE;
5148 }
5149
5150 ICALL_EXPORT MonoObject*
5151 ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly *assembly, MonoString *name, MonoBoolean resource_modules)
5152 {
5153 MonoError error;
5154 MonoTableInfo *table = &assembly->assembly->image->tables [MONO_TABLE_FILE];
5155 MonoArray *result = NULL;
5156 int i, count;
5157 const char *val;
5158 char *n;
5159
5160 /* check hash if needed */
5161 if (name) {
5162 n = mono_string_to_utf8 (name);
5163 for (i = 0; i < table->rows; ++i) {
5164 val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
5165 if (strcmp (val, n) == 0) {
5166 MonoString *fn;
5167 g_free (n);
5168 n = g_concat_dir_and_file (assembly->assembly->basedir, val);
5169 fn = mono_string_new (mono_object_domain (assembly), n);
5170 g_free (n);
5171 return (MonoObject*)fn;
5172 }
5173 }
5174 g_free (n);
5175 return NULL;
5176 }
5177
5178 count = 0;
5179 for (i = 0; i < table->rows; ++i) {
5180 if (resource_modules || !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA))
5181 count ++;
5182 }
5183
5184 result = mono_array_new_checked (mono_object_domain (assembly), mono_defaults.string_class, count, &error);
5185 if (mono_error_set_pending_exception (&error))
5186 return NULL;
5187
5188
5189 count = 0;
5190 for (i = 0; i < table->rows; ++i) {
5191 if (resource_modules || !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) {
5192 val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME));
5193 n = g_concat_dir_and_file (assembly->assembly->basedir, val);
5194 mono_array_setref (result, count, mono_string_new (mono_object_domain (assembly), n));
5195 g_free (n);
5196 count ++;
5197 }
5198 }
5199 return (MonoObject*)result;
5200 }
5201
5202 ICALL_EXPORT MonoArray*
5203 ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly *assembly)
5204 {
5205 MonoError error;
5206 MonoDomain *domain = mono_domain_get();
5207 MonoArray *res;
5208 MonoClass *klass;
5209 int i, j, file_count = 0;
5210 MonoImage **modules;
5211 guint32 module_count, real_module_count;
5212 MonoTableInfo *table;
5213 guint32 cols [MONO_FILE_SIZE];
5214 MonoImage *image = assembly->assembly->image;
5215
5216 g_assert (image != NULL);
5217 g_assert (!assembly_is_dynamic (assembly->assembly));
5218
5219 table = &image->tables [MONO_TABLE_FILE];
5220 file_count = table->rows;
5221
5222 modules = image->modules;
5223 module_count = image->module_count;
5224
5225 real_module_count = 0;
5226 for (i = 0; i < module_count; ++i)
5227 if (modules [i])
5228 real_module_count ++;
5229
5230 klass = mono_class_get_module_class ();
5231 res = mono_array_new_checked (domain, klass, 1 + real_module_count + file_count, &error);
5232 if (mono_error_set_pending_exception (&error))
5233 return NULL;
5234
5235 MonoReflectionModule *image_obj = mono_module_get_object_checked (domain, image, &error);
5236 if (mono_error_set_pending_exception (&error))
5237 return NULL;
5238
5239 mono_array_setref (res, 0, image_obj);
5240 j = 1;
5241 for (i = 0; i < module_count; ++i)
5242 if (modules [i]) {
5243 MonoReflectionModule *rm = mono_module_get_object_checked (domain, modules[i], &error);
5244 if (mono_error_set_pending_exception (&error))
5245 return NULL;
5246 mono_array_setref (res, j, rm);
5247 ++j;
5248 }
5249
5250 for (i = 0; i < file_count; ++i, ++j) {
5251 mono_metadata_decode_row (table, i, cols, MONO_FILE_SIZE);
5252 if (cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA) {
5253 MonoReflectionModule *rm = mono_module_file_get_object_checked (domain, image, i, &error);
5254 if (mono_error_set_pending_exception (&error))
5255 return NULL;
5256 mono_array_setref (res, j, rm);
5257 }
5258 else {
5259 MonoImage *m = mono_image_load_file_for_image (image, i + 1);
5260 if (!m) {
5261 MonoString *fname = mono_string_new (mono_domain_get (), mono_metadata_string_heap (image, cols [MONO_FILE_NAME]));
5262 mono_set_pending_exception (mono_get_exception_file_not_found2 (NULL, fname));
5263 return NULL;
5264 }
5265 MonoReflectionModule *rm = mono_module_get_object_checked (domain, m, &error);
5266 if (mono_error_set_pending_exception (&error))
5267 return NULL;
5268 mono_array_setref (res, j, rm);
5269 }
5270 }
5271
5272 return res;
5273 }
5274
5275 ICALL_EXPORT MonoReflectionMethod*
5276 ves_icall_GetCurrentMethod (void)
5277 {
5278 MonoReflectionMethod *res = NULL;
5279 MonoError error;
5280
5281 MonoMethod *m = mono_method_get_last_managed ();
5282
5283 if (!m) {
5284 mono_set_pending_exception (mono_get_exception_not_supported ("Stack walks are not supported on this platform."));
5285 return NULL;
5286 }
5287
5288 while (m->is_inflated)
5289 m = ((MonoMethodInflated*)m)->declaring;
5290
5291 res = mono_method_get_object_checked (mono_domain_get (), m, NULL, &error);
5292 mono_error_set_pending_exception (&error);
5293 return res;
5294 }
5295
5296
5297 static MonoMethod*
5298 mono_method_get_equivalent_method (MonoMethod *method, MonoClass *klass)
5299 {
5300 int offset = -1, i;
5301 if (method->is_inflated && ((MonoMethodInflated*)method)->context.method_inst) {
5302 MonoError error;
5303 MonoMethod *result;
5304 MonoMethodInflated *inflated = (MonoMethodInflated*)method;
5305 //method is inflated, we should inflate it on the other class
5306 MonoGenericContext ctx;
5307 ctx.method_inst = inflated->context.method_inst;
5308 ctx.class_inst = inflated->context.class_inst;
5309 if (klass->generic_class)
5310 ctx.class_inst = klass->generic_class->context.class_inst;
5311 else if (klass->generic_container)
5312 ctx.class_inst = klass->generic_container->context.class_inst;
5313 result = mono_class_inflate_generic_method_full_checked (inflated->declaring, klass, &ctx, &error);
5314 g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
5315 return result;
5316 }
5317
5318 mono_class_setup_methods (method->klass);
5319 if (mono_class_has_failure (method->klass))
5320 return NULL;
5321 for (i = 0; i < method->klass->method.count; ++i) {
5322 if (method->klass->methods [i] == method) {
5323 offset = i;
5324 break;
5325 }
5326 }
5327 mono_class_setup_methods (klass);
5328 if (mono_class_has_failure (klass))
5329 return NULL;
5330 g_assert (offset >= 0 && offset < klass->method.count);
5331 return klass->methods [offset];
5332 }
5333
5334 ICALL_EXPORT MonoReflectionMethod*
5335 ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMethod *method, MonoType *type)
5336 {
5337 MonoReflectionMethod *res = NULL;
5338 MonoError error;
5339 MonoClass *klass;
5340 if (type) {
5341 klass = mono_class_from_mono_type (type);
5342 if (mono_class_get_generic_type_definition (method->klass) != mono_class_get_generic_type_definition (klass))
5343 return NULL;
5344 if (method->klass != klass) {
5345 method = mono_method_get_equivalent_method (method, klass);
5346 if (!method)
5347 return NULL;
5348 }
5349 } else
5350 klass = method->klass;
5351 res = mono_method_get_object_checked (mono_domain_get (), method, klass, &error);
5352 mono_error_set_pending_exception (&error);
5353 return res;
5354 }
5355
5356 ICALL_EXPORT MonoReflectionMethodBody*
5357 ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod *method)
5358 {
5359 MonoError error;
5360 MonoReflectionMethodBody *result = mono_method_body_get_object_checked (mono_domain_get (), method, &error);
5361 mono_error_set_pending_exception (&error);
5362 return result;
5363 }
5364
5365 ICALL_EXPORT MonoReflectionAssembly*
5366 ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
5367 {
5368 MonoError error;
5369 MonoReflectionAssembly *result;
5370 MonoMethod *dest = NULL;
5371
5372 mono_stack_walk_no_il (get_executing, &dest);
5373 g_assert (dest);
5374 result = mono_assembly_get_object_checked (mono_domain_get (), dest->klass->image->assembly, &error);
5375 if (!result)
5376 mono_error_set_pending_exception (&error);
5377 return result;
5378 }
5379
5380
5381 ICALL_EXPORT MonoReflectionAssembly*
5382 ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
5383 {
5384 MonoError error;
5385 MonoReflectionAssembly *result;
5386 MonoDomain* domain = mono_domain_get ();
5387
5388 if (!domain->entry_assembly)
5389 return NULL;
5390
5391 result = mono_assembly_get_object_checked (domain, domain->entry_assembly, &error);
5392 if (!result)
5393 mono_error_set_pending_exception (&error);
5394 return result;
5395 }
5396
5397 ICALL_EXPORT MonoReflectionAssembly*
5398 ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
5399 {
5400 MonoError error;
5401 MonoMethod *m;
5402 MonoMethod *dest;
5403 MonoReflectionAssembly *result;
5404
5405 dest = NULL;
5406 mono_stack_walk_no_il (get_executing, &dest);
5407 m = dest;
5408 mono_stack_walk_no_il (get_caller_no_reflection, &dest);
5409 if (!dest)
5410 dest = m;
5411 if (!m) {
5412 mono_set_pending_exception (mono_get_exception_not_supported ("Stack walks are not supported on this platform."));
5413 return NULL;
5414 }
5415 result = mono_assembly_get_object_checked (mono_domain_get (), dest->klass->image->assembly, &error);
5416 if (!result)
5417 mono_error_set_pending_exception (&error);
5418 return result;
5419 }
5420
5421 ICALL_EXPORT MonoString *
5422 ves_icall_System_MonoType_getFullName (MonoReflectionType *object, gboolean full_name,
5423 gboolean assembly_qualified)
5424 {
5425 MonoDomain *domain = mono_object_domain (object);
5426 MonoTypeNameFormat format;
5427 MonoString *res;
5428 gchar *name;
5429
5430 if (full_name)
5431 format = assembly_qualified ?
5432 MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED :
5433 MONO_TYPE_NAME_FORMAT_FULL_NAME;
5434 else
5435 format = MONO_TYPE_NAME_FORMAT_REFLECTION;
5436
5437 name = mono_type_get_name_full (object->type, format);
5438 if (!name)
5439 return NULL;
5440
5441 if (full_name && (object->type->type == MONO_TYPE_VAR || object->type->type == MONO_TYPE_MVAR)) {
5442 g_free (name);
5443 return NULL;
5444 }
5445
5446 res = mono_string_new (domain, name);
5447 g_free (name);
5448
5449 return res;
5450 }
5451
5452 ICALL_EXPORT int
5453 vell_icall_MonoType_get_core_clr_security_level (MonoReflectionType *rfield)
5454 {
5455 MonoError error;
5456 MonoClass *klass = mono_class_from_mono_type (rfield->type);
5457
5458 mono_class_init_checked (klass, &error);
5459 mono_error_set_pending_exception (&error);
5460 return mono_security_core_clr_class_level (klass);
5461 }
5462
5463 ICALL_EXPORT int
5464 ves_icall_MonoField_get_core_clr_security_level (MonoReflectionField *rfield)
5465 {
5466 MonoClassField *field = rfield->field;
5467 return mono_security_core_clr_field_level (field, TRUE);
5468 }
5469
5470 ICALL_EXPORT int
5471 ves_icall_MonoMethod_get_core_clr_security_level (MonoReflectionMethod *rfield)
5472 {
5473 MonoMethod *method = rfield->method;
5474 return mono_security_core_clr_method_level (method, TRUE);
5475 }
5476
5477 static void
5478 fill_reflection_assembly_name (MonoDomain *domain, MonoReflectionAssemblyName *aname, MonoAssemblyName *name, const char *absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token, MonoError *error)
5479 {
5480 static MonoMethod *create_culture = NULL;
5481 MonoObject *obj;
5482 gpointer args [2];
5483 guint32 pkey_len;
5484 const char *pkey_ptr;
5485 gchar *codebase;
5486 MonoBoolean assembly_ref = 0;
5487
5488 mono_error_init (error);
5489
5490 MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name));
5491 aname->major = name->major;
5492 aname->minor = name->minor;
5493 aname->build = name->build;
5494 aname->flags = name->flags;
5495 aname->revision = name->revision;
5496 aname->hashalg = name->hash_alg;
5497 aname->versioncompat = 1; /* SameMachine (default) */
5498 aname->processor_architecture = name->arch;
5499
5500 if (by_default_version) {
5501 MonoObject *version;
5502
5503 version = create_version (domain, name->major, name->minor, name->build, name->revision, error);
5504 return_if_nok (error);
5505
5506 MONO_OBJECT_SETREF (aname, version, version);
5507 }
5508
5509 codebase = NULL;
5510 if (absolute != NULL && *absolute != '\0') {
5511 const gchar *prepend = "file://";
5512 gchar *result;
5513
5514 codebase = g_strdup (absolute);
5515
5516 #if HOST_WIN32
5517 {
5518 gint i;
5519 for (i = strlen (codebase) - 1; i >= 0; i--)
5520 if (codebase [i] == '\\')
5521 codebase [i] = '/';
5522
5523 if (*codebase == '/' && *(codebase + 1) == '/') {
5524 prepend = "file:";
5525 } else {
5526 prepend = "file:///";
5527 }
5528 }
5529 #endif
5530 result = g_strconcat (prepend, codebase, NULL);
5531 g_free (codebase);
5532 codebase = result;
5533 }
5534
5535 if (codebase) {
5536 MONO_OBJECT_SETREF (aname, codebase, mono_string_new (domain, codebase));
5537 g_free (codebase);
5538 }
5539
5540 if (!create_culture) {
5541 MonoMethodDesc *desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE);
5542 create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib);
5543 g_assert (create_culture);
5544 mono_method_desc_free (desc);
5545 }
5546
5547 if (name->culture) {
5548 args [0] = mono_string_new (domain, name->culture);
5549 args [1] = &assembly_ref;
5550
5551 obj = mono_runtime_invoke_checked (create_culture, NULL, args, error);
5552 return_if_nok (error);
5553
5554 MONO_OBJECT_SETREF (aname, cultureInfo, obj);
5555 }
5556
5557 if (name->public_key) {
5558 pkey_ptr = (char*)name->public_key;
5559 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr);
5560
5561 MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, pkey_len, error);
5562 return_if_nok (error);
5563 MONO_OBJECT_SETREF (aname, publicKey, pkey);
5564 memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len);
5565 aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
5566 } else if (default_publickey) {
5567 MonoArray *pkey = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error);
5568 return_if_nok (error);
5569 MONO_OBJECT_SETREF (aname, publicKey, pkey);
5570 aname->flags |= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG;
5571 }
5572
5573 /* MonoAssemblyName keeps the public key token as an hexadecimal string */
5574 if (name->public_key_token [0]) {
5575 int i, j;
5576 char *p;
5577
5578 MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 8, error);
5579 return_if_nok (error);
5580
5581 MONO_OBJECT_SETREF (aname, keyToken, keyToken);
5582 p = mono_array_addr (keyToken, char, 0);
5583
5584 for (i = 0, j = 0; i < 8; i++) {
5585 *p = g_ascii_xdigit_value (name->public_key_token [j++]) << 4;
5586 *p |= g_ascii_xdigit_value (name->public_key_token [j++]);
5587 p++;
5588 }
5589 } else if (default_token) {
5590 MonoArray *keyToken = mono_array_new_checked (domain, mono_defaults.byte_class, 0, error);
5591 return_if_nok (error);
5592 MONO_OBJECT_SETREF (aname, keyToken, keyToken);
5593 }
5594 }
5595
5596 ICALL_EXPORT MonoString *
5597 ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssembly *assembly)
5598 {
5599 MonoDomain *domain = mono_object_domain (assembly);
5600 MonoAssembly *mass = assembly->assembly;
5601 MonoString *res;
5602 gchar *name;
5603
5604 name = mono_stringify_assembly_name (&mass->aname);
5605 res = mono_string_new (domain, name);
5606 g_free (name);
5607
5608 return res;
5609 }
5610
5611 ICALL_EXPORT void
5612 ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly *assembly, MonoReflectionAssemblyName *aname)
5613 {
5614 MonoError error;
5615 gchar *absolute;
5616 MonoAssembly *mass = assembly->assembly;
5617
5618 if (g_path_is_absolute (mass->image->name)) {
5619 fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, mass->image->name, TRUE, TRUE, TRUE, &error);
5620 mono_error_set_pending_exception (&error);
5621 return;
5622 }
5623 absolute = g_build_filename (mass->basedir, mass->image->name, NULL);
5624
5625 fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, absolute, TRUE, TRUE, TRUE, &error);
5626 mono_error_set_pending_exception (&error);
5627
5628 g_free (absolute);
5629 }
5630
5631 ICALL_EXPORT void
5632 ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString *fname, MonoReflectionAssemblyName *aname)
5633 {
5634 MonoError error;
5635 char *filename;
5636 MonoImageOpenStatus status = MONO_IMAGE_OK;
5637 gboolean res;
5638 MonoImage *image;
5639 MonoAssemblyName name;
5640 char *dirname;
5641
5642 filename = mono_string_to_utf8 (fname);
5643
5644 dirname = g_path_get_dirname (filename);
5645 replace_shadow_path (mono_domain_get (), dirname, &filename);
5646 g_free (dirname);
5647
5648 image = mono_image_open (filename, &status);
5649
5650 if (!image){
5651 MonoException *exc;
5652
5653 g_free (filename);
5654 if (status == MONO_IMAGE_IMAGE_INVALID)
5655 exc = mono_get_exception_bad_image_format2 (NULL, fname);
5656 else
5657 exc = mono_get_exception_file_not_found2 (NULL, fname);
5658 mono_set_pending_exception (exc);
5659 return;
5660 }
5661
5662 res = mono_assembly_fill_assembly_name (image, &name);
5663 if (!res) {
5664 mono_image_close (image);
5665 g_free (filename);
5666 mono_set_pending_exception (mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest"));
5667 return;
5668 }
5669
5670 fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename, TRUE, FALSE, TRUE, &error);
5671 mono_error_set_pending_exception (&error);
5672
5673 mono_image_close (image);
5674 g_free (filename);
5675 }
5676
5677 ICALL_EXPORT MonoBoolean
5678 ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssembly *assembly,
5679 char **minimum, guint32 *minLength, char **optional, guint32 *optLength, char **refused, guint32 *refLength)
5680 {
5681 MonoBoolean result = FALSE;
5682 MonoDeclSecurityEntry entry;
5683
5684 /* SecurityAction.RequestMinimum */
5685 if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQMIN, &entry)) {
5686 *minimum = entry.blob;
5687 *minLength = entry.size;
5688 result = TRUE;
5689 }
5690 /* SecurityAction.RequestOptional */
5691 if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQOPT, &entry)) {
5692 *optional = entry.blob;
5693 *optLength = entry.size;
5694 result = TRUE;
5695 }
5696 /* SecurityAction.RequestRefuse */
5697 if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQREFUSE, &entry)) {
5698 *refused = entry.blob;
5699 *refLength = entry.size;
5700 result = TRUE;
5701 }
5702
5703 return result;
5704 }
5705
5706 static gboolean
5707 mono_module_type_is_visible (MonoTableInfo *tdef, MonoImage *image, int type)
5708 {
5709 guint32 attrs, visibility;
5710 do {
5711 attrs = mono_metadata_decode_row_col (tdef, type - 1, MONO_TYPEDEF_FLAGS);
5712 visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK;
5713 if (visibility != TYPE_ATTRIBUTE_PUBLIC && visibility != TYPE_ATTRIBUTE_NESTED_PUBLIC)
5714 return FALSE;
5715
5716 } while ((type = mono_metadata_token_index (mono_metadata_nested_in_typedef (image, type))));
5717
5718 return TRUE;
5719 }
5720
5721 static MonoArray*
5722 mono_module_get_types (MonoDomain *domain, MonoImage *image, MonoArray **exceptions, MonoBoolean exportedOnly, MonoError *error)
5723 {
5724 MonoReflectionType *rt;
5725 MonoArray *res;
5726 MonoClass *klass;
5727 MonoTableInfo *tdef = &image->tables [MONO_TABLE_TYPEDEF];
5728 int i, count;
5729
5730 mono_error_init (error);
5731
5732 /* we start the count from 1 because we skip the special type <Module> */
5733 if (exportedOnly) {
5734 count = 0;
5735 for (i = 1; i < tdef->rows; ++i) {
5736 if (mono_module_type_is_visible (tdef, image, i + 1))
5737 count++;
5738 }
5739 } else {
5740 count = tdef->rows - 1;
5741 }
5742 res = mono_array_new_checked (domain, mono_defaults.monotype_class, count, error);
5743 return_val_if_nok (error, NULL);
5744 *exceptions = mono_array_new_checked (domain, mono_defaults.exception_class, count, error);
5745 return_val_if_nok (error, NULL);
5746 count = 0;
5747 for (i = 1; i < tdef->rows; ++i) {
5748 if (!exportedOnly || mono_module_type_is_visible (tdef, image, i + 1)) {
5749 klass = mono_class_get_checked (image, (i + 1) | MONO_TOKEN_TYPE_DEF, error);
5750
5751 if (klass) {
5752 rt = mono_type_get_object_checked (domain, &klass->byval_arg, error);
5753 return_val_if_nok (error, NULL);
5754
5755 mono_array_setref (res, count, rt);
5756 } else {
5757 MonoException *ex = mono_error_convert_to_exception (error);
5758 mono_array_setref (*exceptions, count, ex);
5759 }
5760 count++;
5761 }
5762 }
5763
5764 return res;
5765 }
5766
5767 ICALL_EXPORT MonoArray*
5768 ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly *assembly, MonoBoolean exportedOnly)
5769 {
5770 MonoError error;
5771 MonoArray *res = NULL;
5772 MonoArray *exceptions = NULL;
5773 MonoImage *image = NULL;
5774 MonoTableInfo *table = NULL;
5775 MonoDomain *domain;
5776 GList *list = NULL;
5777 int i, len, ex_count;
5778
5779 domain = mono_object_domain (assembly);
5780
5781 g_assert (!assembly_is_dynamic (assembly->assembly));
5782 image = assembly->assembly->image;
5783 table = &image->tables [MONO_TABLE_FILE];
5784 res = mono_module_get_types (domain, image, &exceptions, exportedOnly, &error);
5785 if (mono_error_set_pending_exception (&error))
5786 return NULL;
5787
5788 /* Append data from all modules in the assembly */
5789 for (i = 0; i < table->rows; ++i) {
5790 if (!(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) {
5791 MonoImage *loaded_image = mono_assembly_load_module (image->assembly, i + 1);
5792 if (loaded_image) {
5793 MonoArray *ex2;
5794 MonoArray *res2;
5795
5796 res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly, &error);
5797 if (mono_error_set_pending_exception (&error))
5798 return NULL;
5799
5800
5801 /* Append the new types to the end of the array */
5802 if (mono_array_length (res2) > 0) {
5803 guint32 len1, len2;
5804 MonoArray *res3, *ex3;
5805
5806 len1 = mono_array_length (res);
5807 len2 = mono_array_length (res2);
5808
5809 res3 = mono_array_new_checked (domain, mono_defaults.monotype_class, len1 + len2, &error);
5810 if (mono_error_set_pending_exception (&error))
5811 return NULL;
5812 mono_array_memcpy_refs (res3, 0, res, 0, len1);
5813 mono_array_memcpy_refs (res3, len1, res2, 0, len2);
5814 res = res3;
5815
5816 ex3 = mono_array_new_checked (domain, mono_defaults.monotype_class, len1 + len2, &error);
5817 if (mono_error_set_pending_exception (&error))
5818 return NULL;
5819 mono_array_memcpy_refs (ex3, 0, exceptions, 0, len1);
5820 mono_array_memcpy_refs (ex3, len1, ex2, 0, len2);
5821 exceptions = ex3;
5822 }
5823 }
5824 }
5825 }
5826
5827 /* the ReflectionTypeLoadException must have all the types (Types property),
5828 * NULL replacing types which throws an exception. The LoaderException must
5829 * contain all exceptions for NULL items.
5830 */
5831
5832 len = mono_array_length (res);
5833
5834 ex_count = 0;
5835 for (i = 0; i < len; i++) {
5836 MonoReflectionType *t = (MonoReflectionType *)mono_array_get (res, gpointer, i);
5837 MonoClass *klass;
5838
5839 if (t) {
5840 klass = mono_type_get_class (t->type);
5841 if ((klass != NULL) && mono_class_has_failure (klass)) {
5842 /* keep the class in the list */
5843 list = g_list_append (list, klass);
5844 /* and replace Type with NULL */
5845 mono_array_setref (res, i, NULL);
5846 }
5847 } else {
5848 ex_count ++;
5849 }
5850 }
5851
5852 if (list || ex_count) {
5853 GList *tmp = NULL;
5854 MonoException *exc = NULL;
5855 MonoArray *exl = NULL;
5856 int j, length = g_list_length (list) + ex_count;
5857
5858 exl = mono_array_new_checked (domain, mono_defaults.exception_class, length, &error);
5859 if (mono_error_set_pending_exception (&error)) {
5860 g_list_free (list);
5861 return NULL;
5862 }
5863 /* Types for which mono_class_get_checked () succeeded */
5864 for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) {
5865 MonoException *exc = mono_class_get_exception_for_failure ((MonoClass *)tmp->data);
5866 mono_array_setref (exl, i, exc);
5867 }
5868 /* Types for which it don't */
5869 for (j = 0; j < mono_array_length (exceptions); ++j) {
5870 MonoException *exc = mono_array_get (exceptions, MonoException*, j);
5871 if (exc) {
5872 g_assert (i < length);
5873 mono_array_setref (exl, i, exc);
5874 i ++;
5875 }
5876 }
5877 g_list_free (list);
5878 list = NULL;
5879
5880 exc = mono_get_exception_reflection_type_load_checked (res, exl, &error);
5881 if (!is_ok (&error)) {
5882 mono_error_set_pending_exception (&error);
5883 return NULL;
5884 }
5885 mono_set_pending_exception (exc);
5886 return NULL;
5887 }
5888
5889 return res;
5890 }
5891
5892 ICALL_EXPORT gboolean
5893 ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName *name, MonoString *assname)
5894 {
5895 MonoError error;
5896 MonoAssemblyName aname;
5897 MonoDomain *domain = mono_object_domain (name);
5898 char *val;
5899 gboolean is_version_defined;
5900 gboolean is_token_defined;
5901
5902 aname.public_key = NULL;
5903 val = mono_string_to_utf8 (assname);
5904 if (!mono_assembly_name_parse_full (val, &aname, TRUE, &is_version_defined, &is_token_defined)) {
5905 g_free ((guint8*) aname.public_key);
5906 g_free (val);
5907 return FALSE;
5908 }
5909
5910 fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined, FALSE, is_token_defined, &error);
5911 mono_error_set_pending_exception (&error);
5912
5913 mono_assembly_name_free (&aname);
5914 g_free ((guint8*) aname.public_key);
5915 g_free (val);
5916
5917 return TRUE;
5918 }
5919
5920 ICALL_EXPORT MonoReflectionType*
5921 ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule *module)
5922 {
5923 MonoError error;
5924 MonoReflectionType *ret;
5925 MonoDomain *domain = mono_object_domain (module);
5926 MonoClass *klass;
5927
5928 g_assert (module->image);
5929
5930 if (image_is_dynamic (module->image) && ((MonoDynamicImage*)(module->image))->initial_image)
5931 /* These images do not have a global type */
5932 return NULL;
5933
5934 klass = mono_class_get_checked (module->image, 1 | MONO_TOKEN_TYPE_DEF, &error);
5935 if (!mono_error_ok (&error)) {
5936 mono_error_set_pending_exception (&error);
5937 return NULL;
5938 }
5939
5940 ret = mono_type_get_object_checked (domain, &klass->byval_arg, &error);
5941 if (!mono_error_ok (&error)) {
5942 mono_error_set_pending_exception (&error);
5943 return NULL;
5944 }
5945
5946 return ret;
5947 }
5948
5949 ICALL_EXPORT void
5950 ves_icall_System_Reflection_Module_Close (MonoReflectionModule *module)
5951 {
5952 /*if (module->image)
5953 mono_image_close (module->image);*/
5954 }
5955
5956 ICALL_EXPORT MonoString*
5957 ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModule *module)
5958 {
5959 MonoDomain *domain = mono_object_domain (module);
5960
5961 g_assert (module->image);
5962 return mono_string_new (domain, module->image->guid);
5963 }
5964
5965 ICALL_EXPORT gpointer
5966 ves_icall_System_Reflection_Module_GetHINSTANCE (MonoReflectionModule *module)
5967 {
5968 #ifdef HOST_WIN32
5969 if (module->image && module->image->is_module_handle)
5970 return module->image->raw_data;
5971 #endif
5972
5973 return (gpointer) (-1);
5974 }
5975
5976 ICALL_EXPORT void
5977 ves_icall_System_Reflection_Module_GetPEKind (MonoImage *image, gint32 *pe_kind, gint32 *machine)
5978 {
5979 if (image_is_dynamic (image)) {
5980 MonoDynamicImage *dyn = (MonoDynamicImage*)image;
5981 *pe_kind = dyn->pe_kind;
5982 *machine = dyn->machine;
5983 }
5984 else {
5985 *pe_kind = ((MonoCLIImageInfo*)(image->image_info))->cli_cli_header.ch_flags & 0x3;
5986 *machine = ((MonoCLIImageInfo*)(image->image_info))->cli_header.coff.coff_machine;
5987 }
5988 }
5989
5990 ICALL_EXPORT gint32
5991 ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage *image)
5992 {
5993 return (image->md_version_major << 16) | (image->md_version_minor);
5994 }
5995
5996 ICALL_EXPORT MonoArray*
5997 ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule *module)
5998 {
5999 MonoError error;
6000 MonoArray *exceptions;
6001 int i;
6002
6003 if (!module->image) {
6004 MonoArray *arr = mono_array_new_checked (mono_object_domain (module), mono_defaults.monotype_class, 0, &error);
6005 mono_error_set_pending_exception (&error);
6006 return arr;
6007 } else {
6008 MonoArray *res;
6009
6010 res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE, &error);
6011 if (mono_error_set_pending_exception (&error))
6012 return NULL;
6013
6014 for (i = 0; i < mono_array_length (exceptions); ++i) {
6015 MonoException *ex = mono_array_get (exceptions, MonoException *, i);
6016 if (ex) {
6017 mono_set_pending_exception (ex);
6018 return NULL;
6019 }
6020 }
6021 return res;
6022 }
6023 }
6024
6025 static gboolean
6026 mono_memberref_is_method (MonoImage *image, guint32 token)
6027 {
6028 if (!image_is_dynamic (image)) {
6029 guint32 cols [MONO_MEMBERREF_SIZE];
6030 const char *sig;
6031 mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE);
6032 sig = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]);
6033 mono_metadata_decode_blob_size (sig, &sig);
6034 return (*sig != 0x6);
6035 } else {
6036 MonoError error;
6037 MonoClass *handle_class;
6038
6039 if (!mono_lookup_dynamic_token_class (image, token, FALSE, &handle_class, NULL, &error)) {
6040 mono_error_cleanup (&error); /* just probing, ignore error */
6041 return FALSE;
6042 }
6043
6044 return mono_defaults.methodhandle_class == handle_class;
6045 }
6046 }
6047
6048 static void
6049 init_generic_context_from_args (MonoGenericContext *context, MonoArray *type_args, MonoArray *method_args)
6050 {
6051 if (type_args)
6052 context->class_inst = mono_metadata_get_generic_inst (mono_array_length (type_args),
6053 mono_array_addr (type_args, MonoType*, 0));
6054 else
6055 context->class_inst = NULL;
6056 if (method_args)
6057 context->method_inst = mono_metadata_get_generic_inst (mono_array_length (method_args),
6058 mono_array_addr (method_args, MonoType*, 0));
6059 else
6060 context->method_inst = NULL;
6061 }
6062
6063 ICALL_EXPORT MonoType*
6064 ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *resolve_error)
6065 {
6066 MonoClass *klass;
6067 int table = mono_metadata_token_table (token);
6068 int index = mono_metadata_token_index (token);
6069 MonoGenericContext context;
6070 MonoError error;
6071
6072 *resolve_error = ResolveTokenError_Other;
6073
6074 /* Validate token */
6075 if ((table != MONO_TABLE_TYPEDEF) && (table != MONO_TABLE_TYPEREF) &&
6076 (table != MONO_TABLE_TYPESPEC)) {
6077 *resolve_error = ResolveTokenError_BadTable;
6078 return NULL;
6079 }
6080
6081 if (image_is_dynamic (image)) {
6082 if ((table == MONO_TABLE_TYPEDEF) || (table == MONO_TABLE_TYPEREF)) {
6083 klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
6084 mono_error_cleanup (&error);
6085 return klass ? &klass->byval_arg : NULL;
6086 }
6087
6088 init_generic_context_from_args (&context, type_args, method_args);
6089 klass = (MonoClass *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
6090 mono_error_cleanup (&error);
6091 return klass ? &klass->byval_arg : NULL;
6092 }
6093
6094 if ((index <= 0) || (index > image->tables [table].rows)) {
6095 *resolve_error = ResolveTokenError_OutOfRange;
6096 return NULL;
6097 }
6098
6099 init_generic_context_from_args (&context, type_args, method_args);
6100 klass = mono_class_get_checked (image, token, &error);
6101 if (klass)
6102 klass = mono_class_inflate_generic_class_checked (klass, &context, &error);
6103 if (!mono_error_ok (&error)) {
6104 mono_error_set_pending_exception (&error);
6105 return NULL;
6106 }
6107
6108 if (klass)
6109 return &klass->byval_arg;
6110 else
6111 return NULL;
6112 }
6113
6114 ICALL_EXPORT MonoMethod*
6115 ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *resolve_error)
6116 {
6117 MonoError error;
6118 int table = mono_metadata_token_table (token);
6119 int index = mono_metadata_token_index (token);
6120 MonoGenericContext context;
6121 MonoMethod *method;
6122
6123 *resolve_error = ResolveTokenError_Other;
6124
6125 /* Validate token */
6126 if ((table != MONO_TABLE_METHOD) && (table != MONO_TABLE_METHODSPEC) &&
6127 (table != MONO_TABLE_MEMBERREF)) {
6128 *resolve_error = ResolveTokenError_BadTable;
6129 return NULL;
6130 }
6131
6132 if (image_is_dynamic (image)) {
6133 if (table == MONO_TABLE_METHOD) {
6134 method = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
6135 mono_error_cleanup (&error);
6136 return method;
6137 }
6138
6139 if ((table == MONO_TABLE_MEMBERREF) && !(mono_memberref_is_method (image, token))) {
6140 *resolve_error = ResolveTokenError_BadTable;
6141 return NULL;
6142 }
6143
6144 init_generic_context_from_args (&context, type_args, method_args);
6145 method = (MonoMethod *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
6146 mono_error_cleanup (&error);
6147 return method;
6148 }
6149
6150 if ((index <= 0) || (index > image->tables [table].rows)) {
6151 *resolve_error = ResolveTokenError_OutOfRange;
6152 return NULL;
6153 }
6154 if ((table == MONO_TABLE_MEMBERREF) && (!mono_memberref_is_method (image, token))) {
6155 *resolve_error = ResolveTokenError_BadTable;
6156 return NULL;
6157 }
6158
6159 init_generic_context_from_args (&context, type_args, method_args);
6160 method = mono_get_method_checked (image, token, NULL, &context, &error);
6161 mono_error_set_pending_exception (&error);
6162
6163 return method;
6164 }
6165
6166 ICALL_EXPORT MonoString*
6167 ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error)
6168 {
6169 MonoError error;
6170 int index = mono_metadata_token_index (token);
6171
6172 *resolve_error = ResolveTokenError_Other;
6173
6174 /* Validate token */
6175 if (mono_metadata_token_code (token) != MONO_TOKEN_STRING) {
6176 *resolve_error = ResolveTokenError_BadTable;
6177 return NULL;
6178 }
6179
6180 if (image_is_dynamic (image)) {
6181 MonoString * result = (MonoString *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
6182 mono_error_cleanup (&error);
6183 return result;
6184 }
6185
6186 if ((index <= 0) || (index >= image->heap_us.size)) {
6187 *resolve_error = ResolveTokenError_OutOfRange;
6188 return NULL;
6189 }
6190
6191 /* FIXME: What to do if the index points into the middle of a string ? */
6192
6193 return mono_ldstr (mono_domain_get (), image, index);
6194 }
6195
6196 ICALL_EXPORT MonoClassField*
6197 ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *resolve_error)
6198 {
6199 MonoError error;
6200 MonoClass *klass;
6201 int table = mono_metadata_token_table (token);
6202 int index = mono_metadata_token_index (token);
6203 MonoGenericContext context;
6204 MonoClassField *field;
6205
6206 *resolve_error = ResolveTokenError_Other;
6207
6208 /* Validate token */
6209 if ((table != MONO_TABLE_FIELD) && (table != MONO_TABLE_MEMBERREF)) {
6210 *resolve_error = ResolveTokenError_BadTable;
6211 return NULL;
6212 }
6213
6214 if (image_is_dynamic (image)) {
6215 if (table == MONO_TABLE_FIELD) {
6216 field = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL, &error);
6217 mono_error_cleanup (&error);
6218 return field;
6219 }
6220
6221 if (mono_memberref_is_method (image, token)) {
6222 *resolve_error = ResolveTokenError_BadTable;
6223 return NULL;
6224 }
6225
6226 init_generic_context_from_args (&context, type_args, method_args);
6227 field = (MonoClassField *)mono_lookup_dynamic_token_class (image, token, FALSE, NULL, &context, &error);
6228 mono_error_cleanup (&error);
6229 return field;
6230 }
6231
6232 if ((index <= 0) || (index > image->tables [table].rows)) {
6233 *resolve_error = ResolveTokenError_OutOfRange;
6234 return NULL;
6235 }
6236 if ((table == MONO_TABLE_MEMBERREF) && (mono_memberref_is_method (image, token))) {
6237 *resolve_error = ResolveTokenError_BadTable;
6238 return NULL;
6239 }
6240
6241 init_generic_context_from_args (&context, type_args, method_args);
6242 field = mono_field_from_token_checked (image, token, &klass, &context, &error);
6243 mono_error_set_pending_exception (&error);
6244
6245 return field;
6246 }
6247
6248
6249 ICALL_EXPORT MonoObject*
6250 ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage *image, guint32 token, MonoArray *type_args, MonoArray *method_args, MonoResolveTokenError *error)
6251 {
6252 MonoError merror;
6253 MonoObject *ret;
6254 int table = mono_metadata_token_table (token);
6255
6256 *error = ResolveTokenError_Other;
6257
6258 switch (table) {
6259 case MONO_TABLE_TYPEDEF:
6260 case MONO_TABLE_TYPEREF:
6261 case MONO_TABLE_TYPESPEC: {
6262 MonoType *t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error);
6263 if (t) {
6264 ret = (MonoObject*) mono_type_get_object_checked (mono_domain_get (), t, &merror);
6265 mono_error_set_pending_exception (&merror);
6266
6267 return ret;
6268 }
6269 else
6270 return NULL;
6271 }
6272 case MONO_TABLE_METHOD:
6273 case MONO_TABLE_METHODSPEC: {
6274 MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
6275 if (m) {
6276 ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror);
6277 mono_error_set_pending_exception (&merror);
6278
6279 return ret;
6280 } else
6281 return NULL;
6282 }
6283 case MONO_TABLE_FIELD: {
6284 MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
6285 if (f) {
6286 ret =(MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror);
6287 mono_error_set_pending_exception (&merror);
6288 return ret;
6289 }
6290 else
6291 return NULL;
6292 }
6293 case MONO_TABLE_MEMBERREF:
6294 if (mono_memberref_is_method (image, token)) {
6295 MonoMethod *m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error);
6296 if (m) {
6297 ret = (MonoObject*)mono_method_get_object_checked (mono_domain_get (), m, m->klass, &merror);
6298 mono_error_set_pending_exception (&merror);
6299
6300 return ret;
6301 } else
6302 return NULL;
6303 }
6304 else {
6305 MonoClassField *f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error);
6306 if (f) {
6307 ret = (MonoObject*)mono_field_get_object_checked (mono_domain_get (), f->parent, f, &merror);
6308 mono_error_set_pending_exception (&merror);
6309 return ret;
6310 }
6311 else
6312 return NULL;
6313 }
6314 break;
6315
6316 default:
6317 *error = ResolveTokenError_BadTable;
6318 }
6319
6320 return NULL;
6321 }
6322
6323 ICALL_EXPORT MonoArray*
6324 ves_icall_System_Reflection_Module_ResolveSignature (MonoImage *image, guint32 token, MonoResolveTokenError *resolve_error)
6325 {
6326 MonoError error;
6327 int table = mono_metadata_token_table (token);
6328 int idx = mono_metadata_token_index (token);
6329 MonoTableInfo *tables = image->tables;
6330 guint32 sig, len;
6331 const char *ptr;
6332 MonoArray *res;
6333
6334 *resolve_error = ResolveTokenError_OutOfRange;
6335
6336 /* FIXME: Support other tables ? */
6337 if (table != MONO_TABLE_STANDALONESIG)
6338 return NULL;
6339
6340 if (image_is_dynamic (image))
6341 return NULL;
6342
6343 if ((idx == 0) || (idx > tables [MONO_TABLE_STANDALONESIG].rows))
6344 return NULL;
6345
6346 sig = mono_metadata_decode_row_col (&tables [MONO_TABLE_STANDALONESIG], idx - 1, 0);
6347
6348 ptr = mono_metadata_blob_heap (image, sig);
6349 len = mono_metadata_decode_blob_size (ptr, &ptr);
6350
6351 res = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, len, &error);
6352 if (mono_error_set_pending_exception (&error))
6353 return NULL;
6354 memcpy (mono_array_addr (res, guint8, 0), ptr, len);
6355 return res;
6356 }
6357
6358 ICALL_EXPORT MonoReflectionType*
6359 ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder *tb, MonoString *smodifiers)
6360 {
6361 MonoError error;
6362 MonoReflectionType *ret;
6363 MonoClass *klass;
6364 int isbyref = 0, rank;
6365 char *str = mono_string_to_utf8 (smodifiers);
6366 char *p;
6367
6368 klass = mono_class_from_mono_type (tb->type.type);
6369 p = str;
6370 /* logic taken from mono_reflection_parse_type(): keep in sync */
6371 while (*p) {
6372 switch (*p) {
6373 case '&':
6374 if (isbyref) { /* only one level allowed by the spec */
6375 g_free (str);
6376 return NULL;
6377 }
6378 isbyref = 1;
6379 p++;
6380
6381 g_free (str);
6382
6383 ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->this_arg, &error);
6384 mono_error_set_pending_exception (&error);
6385
6386 return ret;
6387 case '*':
6388 klass = mono_ptr_class_get (&klass->byval_arg);
6389 mono_class_init (klass);
6390 p++;
6391 break;
6392 case '[':
6393 rank = 1;
6394 p++;
6395 while (*p) {
6396 if (*p == ']')
6397 break;
6398 if (*p == ',')
6399 rank++;
6400 else if (*p != '*') { /* '*' means unknown lower bound */
6401 g_free (str);
6402 return NULL;
6403 }
6404 ++p;
6405 }
6406 if (*p != ']') {
6407 g_free (str);
6408 return NULL;
6409 }
6410 p++;
6411 klass = mono_array_class_get (klass, rank);
6412 mono_class_init (klass);
6413 break;
6414 default:
6415 break;
6416 }
6417 }
6418
6419 g_free (str);
6420
6421 ret = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
6422 mono_error_set_pending_exception (&error);
6423
6424 return ret;
6425 }
6426
6427 ICALL_EXPORT MonoBoolean
6428 ves_icall_RuntimeTypeHandle_IsArray (MonoReflectionType *t)
6429 {
6430 MonoType *type;
6431 MonoBoolean res;
6432
6433 type = t->type;
6434 res = !type->byref && (type->type == MONO_TYPE_ARRAY || type->type == MONO_TYPE_SZARRAY);
6435
6436 return res;
6437 }
6438
6439 static void
6440 check_for_invalid_type (MonoClass *klass, MonoError *error)
6441 {
6442 char *name;
6443 MonoString *str;
6444
6445 mono_error_init (error);
6446
6447 if (klass->byval_arg.type != MONO_TYPE_TYPEDBYREF)
6448 return;
6449
6450 name = mono_type_get_full_name (klass);
6451 str = mono_string_new (mono_domain_get (), name);
6452 g_free (name);
6453 mono_error_set_exception_instance (error, mono_get_exception_type_load (str, NULL));
6454
6455 }
6456 ICALL_EXPORT MonoReflectionType *
6457 ves_icall_Type_make_array_type (MonoReflectionType *type, int rank)
6458 {
6459 MonoError error;
6460 MonoReflectionType *ret;
6461 MonoClass *klass, *aklass;
6462
6463 klass = mono_class_from_mono_type (type->type);
6464 check_for_invalid_type (klass, &error);
6465 mono_error_set_pending_exception (&error);
6466
6467 if (rank == 0) //single dimentional array
6468 aklass = mono_array_class_get (klass, 1);
6469 else
6470 aklass = mono_bounded_array_class_get (klass, rank, TRUE);
6471
6472 ret = mono_type_get_object_checked (mono_object_domain (type), &aklass->byval_arg, &error);
6473 mono_error_set_pending_exception (&error);
6474
6475 return ret;
6476 }
6477
6478 ICALL_EXPORT MonoReflectionType *
6479 ves_icall_Type_make_byref_type (MonoReflectionType *type)
6480 {
6481 MonoError error;
6482 MonoReflectionType *ret;
6483 MonoClass *klass;
6484
6485 klass = mono_class_from_mono_type (type->type);
6486 mono_class_init_checked (klass, &error);
6487 if (mono_error_set_pending_exception (&error))
6488 return NULL;
6489
6490 check_for_invalid_type (klass, &error);
6491 if (mono_error_set_pending_exception (&error))
6492 return NULL;
6493
6494 ret = mono_type_get_object_checked (mono_object_domain (type), &klass->this_arg, &error);
6495 mono_error_set_pending_exception (&error);
6496
6497 return ret;
6498 }
6499
6500 ICALL_EXPORT MonoReflectionType *
6501 ves_icall_Type_MakePointerType (MonoReflectionType *type)
6502 {
6503 MonoError error;
6504 MonoReflectionType *ret;
6505 MonoClass *klass, *pklass;
6506
6507 klass = mono_class_from_mono_type (type->type);
6508 mono_class_init_checked (klass, &error);
6509 if (mono_error_set_pending_exception (&error))
6510 return NULL;
6511 check_for_invalid_type (klass, &error);
6512 if (mono_error_set_pending_exception (&error))
6513 return NULL;
6514
6515 pklass = mono_ptr_class_get (type->type);
6516
6517 ret = mono_type_get_object_checked (mono_object_domain (type), &pklass->byval_arg, &error);
6518 mono_error_set_pending_exception (&error);
6519
6520 return ret;
6521 }
6522
6523 ICALL_EXPORT MonoObject *
6524 ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType *type, MonoObject *target,
6525 MonoReflectionMethod *info, MonoBoolean throwOnBindFailure)
6526 {
6527 MonoError error;
6528 MonoClass *delegate_class = mono_class_from_mono_type (type->type);
6529 MonoObject *delegate;
6530 gpointer func;
6531 MonoMethod *method = info->method;
6532
6533 mono_class_init_checked (delegate_class, &error);
6534 if (mono_error_set_pending_exception (&error))
6535 return NULL;
6536
6537 if (!(delegate_class->parent == mono_defaults.multicastdelegate_class)) {
6538 /* FIXME improve this exception message */
6539 mono_error_set_execution_engine (&error, "file %s: line %d (%s): assertion failed: (%s)", __FILE__, __LINE__,
6540 __func__,
6541 "delegate_class->parent == mono_defaults.multicastdelegate_class");
6542 mono_error_set_pending_exception (&error);
6543 return NULL;
6544 }
6545
6546 if (mono_security_core_clr_enabled ()) {
6547 if (!mono_security_core_clr_ensure_delegate_creation (method, &error)) {
6548 if (throwOnBindFailure)
6549 mono_error_set_pending_exception (&error);
6550 else
6551 mono_error_cleanup (&error);
6552 return NULL;
6553 }
6554 }
6555
6556 delegate = mono_object_new_checked (mono_object_domain (type), delegate_class, &error);
6557 if (mono_error_set_pending_exception (&error))
6558 return NULL;
6559
6560 if (method_is_dynamic (method)) {
6561 /* Creating a trampoline would leak memory */
6562 func = mono_compile_method_checked (method, &error);
6563 if (mono_error_set_pending_exception (&error))
6564 return NULL;
6565 } else {
6566 if (target && method->flags & METHOD_ATTRIBUTE_VIRTUAL && method->klass != mono_object_class (target))
6567 method = mono_object_get_virtual_method (target, method);
6568 gpointer trampoline = mono_runtime_create_jump_trampoline (mono_domain_get (), method, TRUE, &error);
6569 if (mono_error_set_pending_exception (&error))
6570 return NULL;
6571 func = mono_create_ftnptr (mono_domain_get (), trampoline);
6572 }
6573
6574 mono_delegate_ctor_with_method (delegate, target, func, method);
6575
6576 return delegate;
6577 }
6578
6579 ICALL_EXPORT MonoMulticastDelegate *
6580 ves_icall_System_Delegate_AllocDelegateLike_internal (MonoDelegate *delegate)
6581 {
6582 MonoError error;
6583 MonoMulticastDelegate *ret;
6584
6585 g_assert (mono_class_has_parent (mono_object_class (delegate), mono_defaults.multicastdelegate_class));
6586
6587 ret = (MonoMulticastDelegate*) mono_object_new_checked (mono_object_domain (delegate), mono_object_class (delegate), &error);
6588 if (mono_error_set_pending_exception (&error))
6589 return NULL;
6590
6591 ret->delegate.invoke_impl = mono_runtime_create_delegate_trampoline (mono_object_class (delegate));
6592
6593 return ret;
6594 }
6595
6596 ICALL_EXPORT MonoReflectionMethod*
6597 ves_icall_System_Delegate_GetVirtualMethod_internal (MonoDelegate *delegate)
6598 {
6599 MonoReflectionMethod *ret = NULL;
6600 MonoError error;
6601 ret = mono_method_get_object_checked (mono_domain_get (), mono_object_get_virtual_method (delegate->target, delegate->method), mono_object_class (delegate->target), &error);
6602 mono_error_set_pending_exception (&error);
6603 return ret;
6604 }
6605
6606 /* System.Buffer */
6607
6608 static inline gint32
6609 mono_array_get_byte_length (MonoArray *array)
6610 {
6611 MonoClass *klass;
6612 int length;
6613 int i;
6614
6615 klass = array->obj.vtable->klass;
6616
6617 if (array->bounds == NULL)
6618 length = array->max_length;
6619 else {
6620 length = 1;
6621 for (i = 0; i < klass->rank; ++ i)
6622 length *= array->bounds [i].length;
6623 }
6624
6625 switch (klass->element_class->byval_arg.type) {
6626 case MONO_TYPE_I1:
6627 case MONO_TYPE_U1:
6628 case MONO_TYPE_BOOLEAN:
6629 return length;
6630 case MONO_TYPE_I2:
6631 case MONO_TYPE_U2:
6632 case MONO_TYPE_CHAR:
6633 return length << 1;
6634 case MONO_TYPE_I4:
6635 case MONO_TYPE_U4:
6636 case MONO_TYPE_R4:
6637 return length << 2;
6638 case MONO_TYPE_I:
6639 case MONO_TYPE_U:
6640 return length * sizeof (gpointer);
6641 case MONO_TYPE_I8:
6642 case MONO_TYPE_U8:
6643 case MONO_TYPE_R8:
6644 return length << 3;
6645 default:
6646 return -1;
6647 }
6648 }
6649
6650 ICALL_EXPORT gint32
6651 ves_icall_System_Buffer_ByteLengthInternal (MonoArray *array)
6652 {
6653 return mono_array_get_byte_length (array);
6654 }
6655
6656 ICALL_EXPORT gint8
6657 ves_icall_System_Buffer_GetByteInternal (MonoArray *array, gint32 idx)
6658 {
6659 return mono_array_get (array, gint8, idx);
6660 }
6661
6662 ICALL_EXPORT void
6663 ves_icall_System_Buffer_SetByteInternal (MonoArray *array, gint32 idx, gint8 value)
6664 {
6665 mono_array_set (array, gint8, idx, value);
6666 }
6667
6668 ICALL_EXPORT MonoBoolean
6669 ves_icall_System_Buffer_BlockCopyInternal (MonoArray *src, gint32 src_offset, MonoArray *dest, gint32 dest_offset, gint32 count)
6670 {
6671 guint8 *src_buf, *dest_buf;
6672
6673 if (count < 0) {
6674 mono_set_pending_exception (mono_get_exception_argument ("count", "is negative"));
6675 return FALSE;
6676 }
6677
6678 g_assert (count >= 0);
6679
6680 /* This is called directly from the class libraries without going through the managed wrapper */
6681 MONO_CHECK_ARG_NULL (src, FALSE);
6682 MONO_CHECK_ARG_NULL (dest, FALSE);
6683
6684 /* watch out for integer overflow */
6685 if ((src_offset > mono_array_get_byte_length (src) - count) || (dest_offset > mono_array_get_byte_length (dest) - count))
6686 return FALSE;
6687
6688 src_buf = (guint8 *)src->vector + src_offset;
6689 dest_buf = (guint8 *)dest->vector + dest_offset;
6690
6691 if (src != dest)
6692 memcpy (dest_buf, src_buf, count);
6693 else
6694 memmove (dest_buf, src_buf, count); /* Source and dest are the same array */
6695
6696 return TRUE;
6697 }
6698
6699 #ifndef DISABLE_REMOTING
6700 ICALL_EXPORT MonoObject *
6701 ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject *this_obj, MonoString *class_name)
6702 {
6703 MonoError error;
6704 MonoDomain *domain = mono_object_domain (this_obj);
6705 MonoObject *res;
6706 MonoRealProxy *rp = ((MonoRealProxy *)this_obj);
6707 MonoTransparentProxy *tp;
6708 MonoType *type;
6709 MonoClass *klass;
6710
6711 res = mono_object_new_checked (domain, mono_defaults.transparent_proxy_class, &error);
6712 if (mono_error_set_pending_exception (&error))
6713 return NULL;
6714
6715 tp = (MonoTransparentProxy*) res;
6716
6717 MONO_OBJECT_SETREF (tp, rp, rp);
6718 type = ((MonoReflectionType *)rp->class_to_proxy)->type;
6719 klass = mono_class_from_mono_type (type);
6720
6721 // mono_remote_class_vtable cannot handle errors well, so force any loading error to occur early
6722 mono_class_setup_vtable (klass);
6723 if (mono_class_has_failure (klass)) {
6724 mono_set_pending_exception (mono_class_get_exception_for_failure (klass));
6725 return NULL;
6726 }
6727
6728 tp->custom_type_info = (mono_object_isinst_checked (this_obj, mono_defaults.iremotingtypeinfo_class, &error) != NULL);
6729 if (!is_ok (&error)) {
6730 mono_error_set_pending_exception (&error);
6731 return NULL;
6732 }
6733 tp->remote_class = mono_remote_class (domain, class_name, klass, &error);
6734 if (!is_ok (&error)) {
6735 mono_error_set_pending_exception (&error);
6736 return NULL;
6737 }
6738
6739 res->vtable = (MonoVTable *)mono_remote_class_vtable (domain, tp->remote_class, rp);
6740 return res;
6741 }
6742
6743 ICALL_EXPORT MonoReflectionType *
6744 ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy *tp)
6745 {
6746 MonoError error;
6747 MonoReflectionType *ret = mono_type_get_object_checked (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg, &error);
6748 mono_error_set_pending_exception (&error);
6749
6750 return ret;
6751 }
6752 #endif
6753
6754 /* System.Environment */
6755
6756 MonoString*
6757 ves_icall_System_Environment_get_UserName (void)
6758 {
6759 /* using glib is more portable */
6760 return mono_string_new (mono_domain_get (), g_get_user_name ());
6761 }
6762
6763
6764 ICALL_EXPORT MonoString *
6765 ves_icall_System_Environment_get_MachineName (void)
6766 {
6767 #if defined (HOST_WIN32)
6768 gunichar2 *buf;
6769 guint32 len;
6770 MonoString *result;
6771
6772 len = MAX_COMPUTERNAME_LENGTH + 1;
6773 buf = g_new (gunichar2, len);
6774
6775 result = NULL;
6776 if (GetComputerName (buf, (PDWORD) &len)) {
6777 MonoError error;
6778 result = mono_string_new_utf16_checked (mono_domain_get (), buf, len, &error);
6779 mono_error_set_pending_exception (&error);
6780 }
6781
6782 g_free (buf);
6783 return result;
6784 #elif !defined(DISABLE_SOCKETS)
6785 MonoString *result;
6786 char *buf;
6787 int n;
6788 #if defined _SC_HOST_NAME_MAX
6789 n = sysconf (_SC_HOST_NAME_MAX);
6790 if (n == -1)
6791 #endif
6792 n = 512;
6793 buf = g_malloc (n+1);
6794
6795 if (gethostname (buf, n) == 0){
6796 buf [n] = 0;
6797 result = mono_string_new (mono_domain_get (), buf);
6798 } else
6799 result = NULL;
6800 g_free (buf);
6801
6802 return result;
6803 #else
6804 return mono_string_new (mono_domain_get (), "mono");
6805 #endif
6806 }
6807
6808 ICALL_EXPORT int
6809 ves_icall_System_Environment_get_Platform (void)
6810 {
6811 #if defined (TARGET_WIN32)
6812 /* Win32NT */
6813 return 2;
6814 #elif defined(__MACH__)
6815 /* OSX */
6816 //
6817 // Notice that the value is hidden from user code, and only exposed
6818 // to mscorlib. This is due to Mono's Unix/MacOS code predating the
6819 // define and making assumptions based on Unix/128/4 values before there
6820 // was a MacOS define. Lots of code would assume that not-Unix meant
6821 // Windows, but in this case, it would be OSX.
6822 //
6823 return 6;
6824 #else
6825 /* Unix */
6826 return 4;
6827 #endif
6828 }
6829
6830 ICALL_EXPORT MonoString *
6831 ves_icall_System_Environment_get_NewLine (void)
6832 {
6833 #if defined (HOST_WIN32)
6834 return mono_string_new (mono_domain_get (), "\r\n");
6835 #else
6836 return mono_string_new (mono_domain_get (), "\n");
6837 #endif
6838 }
6839
6840 ICALL_EXPORT MonoBoolean
6841 ves_icall_System_Environment_GetIs64BitOperatingSystem (void)
6842 {
6843 #if SIZEOF_VOID_P == 8
6844 return TRUE;
6845 #else
6846 #ifdef HOST_WIN32
6847 gboolean isWow64Process = FALSE;
6848 if (IsWow64Process (GetCurrentProcess (), &isWow64Process)) {
6849 return (MonoBoolean)isWow64Process;
6850 }
6851 #elif defined(HAVE_SYS_UTSNAME_H)
6852 struct utsname name;
6853
6854 if (uname (&name) >= 0) {
6855 return strcmp (name.machine, "x86_64") == 0 || strncmp (name.machine, "aarch64", 7) == 0 || strncmp (name.machine, "ppc64", 5) == 0;
6856 }
6857 #endif
6858 return FALSE;
6859 #endif
6860 }
6861
6862 ICALL_EXPORT MonoString *
6863 ves_icall_System_Environment_GetEnvironmentVariable (MonoString *name)
6864 {
6865 const gchar *value;
6866 gchar *utf8_name;
6867
6868 if (name == NULL)
6869 return NULL;
6870
6871 utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
6872 value = g_getenv (utf8_name);
6873
6874 g_free (utf8_name);
6875
6876 if (value == 0)
6877 return NULL;
6878
6879 return mono_string_new (mono_domain_get (), value);
6880 }
6881
6882 /*
6883 * There is no standard way to get at environ.
6884 */
6885 #ifndef _MSC_VER
6886 #ifndef __MINGW32_VERSION
6887 #if defined(__APPLE__)
6888 #if defined (TARGET_OSX)
6889 /* Apple defines this in crt_externs.h but doesn't provide that header for
6890 * arm-apple-darwin9. We'll manually define the symbol on Apple as it does
6891 * in fact exist on all implementations (so far)
6892 */
6893 gchar ***_NSGetEnviron(void);
6894 #define environ (*_NSGetEnviron())
6895 #else
6896 static char *mono_environ[1] = { NULL };
6897 #define environ mono_environ
6898 #endif /* defined (TARGET_OSX) */
6899 #else
6900 extern
6901 char **environ;
6902 #endif
6903 #endif
6904 #endif
6905
6906 ICALL_EXPORT MonoArray *
6907 ves_icall_System_Environment_GetCoomandLineArgs (void)
6908 {
6909 MonoError error;
6910 MonoArray *result = mono_runtime_get_main_args_checked (&error);
6911 mono_error_set_pending_exception (&error);
6912 return result;
6913 }
6914
6915 ICALL_EXPORT MonoArray *
6916 ves_icall_System_Environment_GetEnvironmentVariableNames (void)
6917 {
6918 #ifdef HOST_WIN32
6919 MonoError error;
6920 MonoArray *names;
6921 MonoDomain *domain;
6922 MonoString *str;
6923 WCHAR* env_strings;
6924 WCHAR* env_string;
6925 WCHAR* equal_str;
6926 int n = 0;
6927
6928 env_strings = GetEnvironmentStrings();
6929
6930 if (env_strings) {
6931 env_string = env_strings;
6932 while (*env_string != '\0') {
6933 /* weird case that MS seems to skip */
6934 if (*env_string != '=')
6935 n++;
6936 while (*env_string != '\0')
6937 env_string++;
6938 env_string++;
6939 }
6940 }
6941
6942 domain = mono_domain_get ();
6943 names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error);
6944 if (mono_error_set_pending_exception (&error))
6945 return NULL;
6946
6947 if (env_strings) {
6948 n = 0;
6949 env_string = env_strings;
6950 while (*env_string != '\0') {
6951 /* weird case that MS seems to skip */
6952 if (*env_string != '=') {
6953 equal_str = wcschr(env_string, '=');
6954 g_assert(equal_str);
6955 MonoError error;
6956 str = mono_string_new_utf16_checked (domain, env_string, equal_str-env_string, &error);
6957 if (mono_error_set_pending_exception (&error))
6958 return NULL;
6959
6960 mono_array_setref (names, n, str);
6961 n++;
6962 }
6963 while (*env_string != '\0')
6964 env_string++;
6965 env_string++;
6966 }
6967
6968 FreeEnvironmentStrings (env_strings);
6969 }
6970
6971 return names;
6972
6973 #else
6974 MonoError error;
6975 MonoArray *names;
6976 MonoDomain *domain;
6977 MonoString *str;
6978 gchar **e, **parts;
6979 int n;
6980
6981 n = 0;
6982 for (e = environ; *e != 0; ++ e)
6983 ++ n;
6984
6985 domain = mono_domain_get ();
6986 names = mono_array_new_checked (domain, mono_defaults.string_class, n, &error);
6987 if (mono_error_set_pending_exception (&error))
6988 return NULL;
6989
6990 n = 0;
6991 for (e = environ; *e != 0; ++ e) {
6992 parts = g_strsplit (*e, "=", 2);
6993 if (*parts != 0) {
6994 str = mono_string_new (domain, *parts);
6995 mono_array_setref (names, n, str);
6996 }
6997
6998 g_strfreev (parts);
6999
7000 ++ n;
7001 }
7002
7003 return names;
7004 #endif
7005 }
7006
7007 /*
7008 * If your platform lacks setenv/unsetenv, you must upgrade your glib.
7009 */
7010 #if !GLIB_CHECK_VERSION(2,4,0)
7011 #define g_setenv(a,b,c) setenv(a,b,c)
7012 #define g_unsetenv(a) unsetenv(a)
7013 #endif
7014
7015 ICALL_EXPORT void
7016 ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString *name, MonoString *value)
7017 {
7018 #ifdef HOST_WIN32
7019 gunichar2 *utf16_name, *utf16_value;
7020 #else
7021 gchar *utf8_name, *utf8_value;
7022 MonoError error;
7023 #endif
7024
7025 #ifdef HOST_WIN32
7026 utf16_name = mono_string_to_utf16 (name);
7027 if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
7028 SetEnvironmentVariable (utf16_name, NULL);
7029 g_free (utf16_name);
7030 return;
7031 }
7032
7033 utf16_value = mono_string_to_utf16 (value);
7034
7035 SetEnvironmentVariable (utf16_name, utf16_value);
7036
7037 g_free (utf16_name);
7038 g_free (utf16_value);
7039 #else
7040 utf8_name = mono_string_to_utf8 (name); /* FIXME: this should be ascii */
7041
7042 if ((value == NULL) || (mono_string_length (value) == 0) || (mono_string_chars (value)[0] == 0)) {
7043 g_unsetenv (utf8_name);
7044 g_free (utf8_name);
7045 return;
7046 }
7047
7048 utf8_value = mono_string_to_utf8_checked (value, &error);
7049 if (!mono_error_ok (&error)) {
7050 g_free (utf8_name);
7051 mono_error_set_pending_exception (&error);
7052 return;
7053 }
7054 g_setenv (utf8_name, utf8_value, TRUE);
7055
7056 g_free (utf8_name);
7057 g_free (utf8_value);
7058 #endif
7059 }
7060
7061 ICALL_EXPORT void
7062 ves_icall_System_Environment_Exit (int result)
7063 {
7064 mono_environment_exitcode_set (result);
7065
7066 /* FIXME: There are some cleanup hangs that should be worked out, but
7067 * if the program is going to exit, everything will be cleaned up when
7068 * NaCl exits anyway.
7069 */
7070 #ifndef __native_client__
7071 if (!mono_runtime_try_shutdown ())
7072 mono_thread_exit ();
7073
7074 /* Suspend all managed threads since the runtime is going away */
7075 mono_thread_suspend_all_other_threads ();
7076
7077 mono_runtime_quit ();
7078 #endif
7079
7080 /* we may need to do some cleanup here... */
7081 exit (result);
7082 }
7083
7084 ICALL_EXPORT MonoString*
7085 ves_icall_System_Environment_GetGacPath (void)
7086 {
7087 return mono_string_new (mono_domain_get (), mono_assembly_getrootdir ());
7088 }
7089
7090 ICALL_EXPORT MonoString*
7091 ves_icall_System_Environment_GetWindowsFolderPath (int folder)
7092 {
7093 #if defined (HOST_WIN32)
7094 #ifndef CSIDL_FLAG_CREATE
7095 #define CSIDL_FLAG_CREATE 0x8000
7096 #endif
7097
7098 WCHAR path [MAX_PATH];
7099 /* Create directory if no existing */
7100 if (SUCCEEDED (SHGetFolderPathW (NULL, folder | CSIDL_FLAG_CREATE, NULL, 0, path))) {
7101 int len = 0;
7102 while (path [len])
7103 ++ len;
7104 MonoError error;
7105 MonoString *res = mono_string_new_utf16_checked (mono_domain_get (), path, len, &error);
7106 mono_error_set_pending_exception (&error);
7107 return res;
7108 }
7109 #else
7110 g_warning ("ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!");
7111 #endif
7112 return mono_string_new (mono_domain_get (), "");
7113 }
7114
7115 ICALL_EXPORT MonoArray *
7116 ves_icall_System_Environment_GetLogicalDrives (void)
7117 {
7118 MonoError error;
7119 gunichar2 buf [256], *ptr, *dname;
7120 gunichar2 *u16;
7121 guint initial_size = 127, size = 128;
7122 gint ndrives;
7123 MonoArray *result;
7124 MonoString *drivestr;
7125 MonoDomain *domain = mono_domain_get ();
7126 gint len;
7127
7128 buf [0] = '\0';
7129 ptr = buf;
7130
7131 while (size > initial_size) {
7132 size = (guint) GetLogicalDriveStrings (initial_size, ptr);
7133 if (size > initial_size) {
7134 if (ptr != buf)
7135 g_free (ptr);
7136 ptr = (gunichar2 *)g_malloc0 ((size + 1) * sizeof (gunichar2));
7137 initial_size = size;
7138 size++;
7139 }
7140 }
7141
7142 /* Count strings */
7143 dname = ptr;
7144 ndrives = 0;
7145 do {
7146 while (*dname++);
7147 ndrives++;
7148 } while (*dname);
7149
7150 dname = ptr;
7151 result = mono_array_new_checked (domain, mono_defaults.string_class, ndrives, &error);
7152 if (mono_error_set_pending_exception (&error))
7153 goto leave;
7154
7155 ndrives = 0;
7156 do {
7157 len = 0;
7158 u16 = dname;
7159 while (*u16) { u16++; len ++; }
7160 drivestr = mono_string_new_utf16_checked (domain, dname, len, &error);
7161 if (mono_error_set_pending_exception (&error))
7162 goto leave;
7163
7164 mono_array_setref (result, ndrives++, drivestr);
7165 while (*dname++);
7166 } while (*dname);
7167
7168 leave:
7169 if (ptr != buf)
7170 g_free (ptr);
7171
7172 return result;
7173 }
7174
7175 ICALL_EXPORT MonoString *
7176 ves_icall_System_IO_DriveInfo_GetDriveFormat (MonoString *path)
7177 {
7178 MonoError error;
7179 gunichar2 volume_name [MAX_PATH + 1];
7180
7181 if (GetVolumeInformation (mono_string_chars (path), NULL, 0, NULL, NULL, NULL, volume_name, MAX_PATH + 1) == FALSE)
7182 return NULL;
7183 MonoString *result = mono_string_from_utf16_checked (volume_name, &error);
7184 mono_error_set_pending_exception (&error);
7185 return result;
7186 }
7187
7188 ICALL_EXPORT MonoString *
7189 ves_icall_System_Environment_InternalGetHome (void)
7190 {
7191 return mono_string_new (mono_domain_get (), g_get_home_dir ());
7192 }
7193
7194 static const char *encodings [] = {
7195 (char *) 1,
7196 "ascii", "us_ascii", "us", "ansi_x3.4_1968",
7197 "ansi_x3.4_1986", "cp367", "csascii", "ibm367",
7198 "iso_ir_6", "iso646_us", "iso_646.irv:1991",
7199 (char *) 2,
7200 "utf_7", "csunicode11utf7", "unicode_1_1_utf_7",
7201 "unicode_2_0_utf_7", "x_unicode_1_1_utf_7",
7202 "x_unicode_2_0_utf_7",
7203 (char *) 3,
7204 "utf_8", "unicode_1_1_utf_8", "unicode_2_0_utf_8",
7205 "x_unicode_1_1_utf_8", "x_unicode_2_0_utf_8",
7206 (char *) 4,
7207 "utf_16", "UTF_16LE", "ucs_2", "unicode",
7208 "iso_10646_ucs2",
7209 (char *) 5,
7210 "unicodefffe", "utf_16be",
7211 (char *) 6,
7212 "iso_8859_1",
7213 (char *) 0
7214 };
7215
7216 /*
7217 * Returns the internal codepage, if the value of "int_code_page" is
7218 * 1 at entry, and we can not compute a suitable code page number,
7219 * returns the code page as a string
7220 */
7221 ICALL_EXPORT MonoString*
7222 ves_icall_System_Text_EncodingHelper_InternalCodePage (gint32 *int_code_page)
7223 {
7224 const char *cset;
7225 const char *p;
7226 char *c;
7227 char *codepage = NULL;
7228 int code;
7229 int want_name = *int_code_page;
7230 int i;
7231
7232 *int_code_page = -1;
7233
7234 g_get_charset (&cset);
7235 c = codepage = strdup (cset);
7236 for (c = codepage; *c; c++){
7237 if (isascii (*c) && isalpha (*c))
7238 *c = tolower (*c);
7239 if (*c == '-')
7240 *c = '_';
7241 }
7242 /* g_print ("charset: %s\n", cset); */
7243
7244 /* handle some common aliases */
7245 p = encodings [0];
7246 code = 0;
7247 for (i = 0; p != 0; ){
7248 if ((gsize) p < 7){
7249 code = (gssize) p;
7250 p = encodings [++i];
7251 continue;
7252 }
7253 if (strcmp (p, codepage) == 0){
7254 *int_code_page = code;
7255 break;
7256 }
7257 p = encodings [++i];
7258 }
7259
7260 if (strstr (codepage, "utf_8") != NULL)
7261 *int_code_page |= 0x10000000;
7262 free (codepage);
7263
7264 if (want_name && *int_code_page == -1)
7265 return mono_string_new (mono_domain_get (), cset);
7266 else
7267 return NULL;
7268 }
7269
7270 ICALL_EXPORT MonoBoolean
7271 ves_icall_System_Environment_get_HasShutdownStarted (void)
7272 {
7273 if (mono_runtime_is_shutting_down ())
7274 return TRUE;
7275
7276 if (mono_domain_is_unloading (mono_domain_get ()))
7277 return TRUE;
7278
7279 return FALSE;
7280 }
7281
7282 ICALL_EXPORT void
7283 ves_icall_System_Environment_BroadcastSettingChange (void)
7284 {
7285 #ifdef HOST_WIN32
7286 SendMessageTimeout (HWND_BROADCAST, WM_SETTINGCHANGE, (WPARAM)NULL, (LPARAM)L"Environment", SMTO_ABORTIFHUNG, 2000, 0);
7287 #endif
7288 }
7289
7290 ICALL_EXPORT
7291 gint32
7292 ves_icall_System_Environment_get_TickCount (void)
7293 {
7294 /* this will overflow after ~24 days */
7295 return (gint32) (mono_msec_boottime () & 0xffffffff);
7296 }
7297
7298 ICALL_EXPORT gint32
7299 ves_icall_System_Runtime_Versioning_VersioningHelper_GetRuntimeId (void)
7300 {
7301 return 9;
7302 }
7303
7304 ICALL_EXPORT void
7305 ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage *this_obj,
7306 MonoReflectionMethod *method,
7307 MonoArray *out_args)
7308 {
7309 mono_message_init (mono_object_domain (this_obj), this_obj, method, out_args);
7310 }
7311
7312 #ifndef DISABLE_REMOTING
7313 ICALL_EXPORT MonoBoolean
7314 ves_icall_IsTransparentProxy (MonoObject *proxy)
7315 {
7316 if (!proxy)
7317 return 0;
7318
7319 if (proxy->vtable->klass == mono_defaults.transparent_proxy_class)
7320 return 1;
7321
7322 return 0;
7323 }
7324
7325 ICALL_EXPORT MonoReflectionMethod *
7326 ves_icall_Remoting_RemotingServices_GetVirtualMethod (
7327 MonoReflectionType *rtype, MonoReflectionMethod *rmethod)
7328 {
7329 MonoReflectionMethod *ret = NULL;
7330 MonoError error;
7331
7332 MonoClass *klass;
7333 MonoMethod *method;
7334 MonoMethod **vtable;
7335 MonoMethod *res = NULL;
7336
7337 MONO_CHECK_ARG_NULL (rtype, NULL);
7338 MONO_CHECK_ARG_NULL (rmethod, NULL);
7339
7340 method = rmethod->method;
7341 klass = mono_class_from_mono_type (rtype->type);
7342 mono_class_init_checked (klass, &error);
7343 if (mono_error_set_pending_exception (&error))
7344 return NULL;
7345
7346 if (MONO_CLASS_IS_INTERFACE (klass))
7347 return NULL;
7348
7349 if (method->flags & METHOD_ATTRIBUTE_STATIC)
7350 return NULL;
7351
7352 if ((method->flags & METHOD_ATTRIBUTE_FINAL) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
7353 if (klass == method->klass || mono_class_is_subclass_of (klass, method->klass, FALSE))
7354 return rmethod;
7355 else
7356 return NULL;
7357 }
7358
7359 mono_class_setup_vtable (klass);
7360 vtable = klass->vtable;
7361
7362 if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
7363 gboolean variance_used = FALSE;
7364 /*MS fails with variant interfaces but it's the right thing to do anyway.*/
7365 int offs = mono_class_interface_offset_with_variance (klass, method->klass, &variance_used);
7366 if (offs >= 0)
7367 res = vtable [offs + method->slot];
7368 } else {
7369 if (!(klass == method->klass || mono_class_is_subclass_of (klass, method->klass, FALSE)))
7370 return NULL;
7371
7372 if (method->slot != -1)
7373 res = vtable [method->slot];
7374 }
7375
7376 if (!res)
7377 return NULL;
7378
7379 ret = mono_method_get_object_checked (mono_domain_get (), res, NULL, &error);
7380 mono_error_set_pending_exception (&error);
7381 return ret;
7382 }
7383
7384 ICALL_EXPORT void
7385 ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionType *type, MonoBoolean enable)
7386 {
7387 MonoError error;
7388 MonoClass *klass;
7389 MonoVTable* vtable;
7390
7391 klass = mono_class_from_mono_type (type->type);
7392 vtable = mono_class_vtable_full (mono_domain_get (), klass, &error);
7393 if (!is_ok (&error)) {
7394 mono_error_set_pending_exception (&error);
7395 return;
7396 }
7397
7398 mono_vtable_set_is_remote (vtable, enable);
7399 }
7400
7401 #else /* DISABLE_REMOTING */
7402
7403 ICALL_EXPORT void
7404 ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionType *type, MonoBoolean enable)
7405 {
7406 g_assert_not_reached ();
7407 }
7408
7409 #endif
7410
7411 ICALL_EXPORT MonoObject *
7412 ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (MonoReflectionType *type)
7413 {
7414 MonoError error;
7415 MonoClass *klass;
7416 MonoDomain *domain;
7417 MonoObject *ret;
7418
7419 domain = mono_object_domain (type);
7420 klass = mono_class_from_mono_type (type->type);
7421 mono_class_init_checked (klass, &error);
7422 if (mono_error_set_pending_exception (&error))
7423 return NULL;
7424
7425 if (MONO_CLASS_IS_INTERFACE (klass) || (klass->flags & TYPE_ATTRIBUTE_ABSTRACT)) {
7426 mono_set_pending_exception (mono_get_exception_argument ("type", "Type cannot be instantiated"));
7427 return NULL;
7428 }
7429
7430 if (klass->rank >= 1) {
7431 g_assert (klass->rank == 1);
7432 ret = (MonoObject *) mono_array_new_checked (domain, klass->element_class, 0, &error);
7433 mono_error_set_pending_exception (&error);
7434 return ret;
7435 } else {
7436 MonoVTable *vtable = mono_class_vtable_full (domain, klass, &error);
7437 if (!is_ok (&error)) {
7438 mono_error_set_pending_exception (&error);
7439 return NULL;
7440 }
7441 /* Bypass remoting object creation check */
7442 ret = mono_object_new_alloc_specific_checked (vtable, &error);
7443 mono_error_set_pending_exception (&error);
7444
7445 return ret;
7446 }
7447 }
7448
7449 ICALL_EXPORT MonoString *
7450 ves_icall_System_IO_get_temp_path (void)
7451 {
7452 return mono_string_new (mono_domain_get (), g_get_tmp_dir ());
7453 }
7454
7455 #ifndef PLATFORM_NO_DRIVEINFO
7456 ICALL_EXPORT MonoBoolean
7457 ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (MonoString *path_name, guint64 *free_bytes_avail,
7458 guint64 *total_number_of_bytes, guint64 *total_number_of_free_bytes,
7459 gint32 *error)
7460 {
7461 gboolean result;
7462 ULARGE_INTEGER wapi_free_bytes_avail;
7463 ULARGE_INTEGER wapi_total_number_of_bytes;
7464 ULARGE_INTEGER wapi_total_number_of_free_bytes;
7465
7466 *error = ERROR_SUCCESS;
7467 result = GetDiskFreeSpaceEx (mono_string_chars (path_name), &wapi_free_bytes_avail, &wapi_total_number_of_bytes,
7468 &wapi_total_number_of_free_bytes);
7469
7470 if (result) {
7471 *free_bytes_avail = wapi_free_bytes_avail.QuadPart;
7472 *total_number_of_bytes = wapi_total_number_of_bytes.QuadPart;
7473 *total_number_of_free_bytes = wapi_total_number_of_free_bytes.QuadPart;
7474 } else {
7475 *free_bytes_avail = 0;
7476 *total_number_of_bytes = 0;
7477 *total_number_of_free_bytes = 0;
7478 *error = GetLastError ();
7479 }
7480
7481 return result;
7482 }
7483
7484 ICALL_EXPORT guint32
7485 ves_icall_System_IO_DriveInfo_GetDriveType (MonoString *root_path_name)
7486 {
7487 return GetDriveType (mono_string_chars (root_path_name));
7488 }
7489 #endif
7490
7491 ICALL_EXPORT gpointer
7492 ves_icall_RuntimeMethodHandle_GetFunctionPointer (MonoMethod *method)
7493 {
7494 MonoError error;
7495 gpointer result = mono_compile_method_checked (method, &error);
7496 mono_error_set_pending_exception (&error);
7497 return result;
7498 }
7499
7500 ICALL_EXPORT MonoString *
7501 ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void)
7502 {
7503 MonoString *mcpath;
7504 gchar *path;
7505
7506 path = g_build_path (G_DIR_SEPARATOR_S, mono_get_config_dir (), "mono", mono_get_runtime_info ()->framework_version, "machine.config", NULL);
7507
7508 #if defined (HOST_WIN32)
7509 /* Avoid mixing '/' and '\\' */
7510 {
7511 gint i;
7512 for (i = strlen (path) - 1; i >= 0; i--)
7513 if (path [i] == '/')
7514 path [i] = '\\';
7515 }
7516 #endif
7517 mcpath = mono_string_new (mono_domain_get (), path);
7518 g_free (path);
7519
7520 return mcpath;
7521 }
7522
7523 static MonoString *
7524 get_bundled_app_config (void)
7525 {
7526 const gchar *app_config;
7527 MonoDomain *domain;
7528 MonoString *file;
7529 gchar *config_file_name, *config_file_path;
7530 gsize len, config_file_path_length, config_ext_length;
7531 gchar *module;
7532
7533 domain = mono_domain_get ();
7534 file = domain->setup->configuration_file;
7535 if (!file || file->length == 0)
7536 return NULL;
7537
7538 // Retrieve config file and remove the extension
7539 config_file_name = mono_string_to_utf8 (file);
7540 config_file_path = mono_portability_find_file (config_file_name, TRUE);
7541 if (!config_file_path)
7542 config_file_path = config_file_name;
7543
7544 config_file_path_length = strlen (config_file_path);
7545 config_ext_length = strlen (".config");
7546 if (config_file_path_length <= config_ext_length)
7547 return NULL;
7548
7549 len = config_file_path_length - config_ext_length;
7550 module = (gchar *)g_malloc0 (len + 1);
7551 memcpy (module, config_file_path, len);
7552 // Get the config file from the module name
7553 app_config = mono_config_string_for_assembly_file (module);
7554 // Clean-up
7555 g_free (module);
7556 if (config_file_name != config_file_path)
7557 g_free (config_file_name);
7558 g_free (config_file_path);
7559
7560 if (!app_config)
7561 return NULL;
7562
7563 return mono_string_new (mono_domain_get (), app_config);
7564 }
7565
7566 static MonoString *
7567 get_bundled_machine_config (void)
7568 {
7569 const gchar *machine_config;
7570
7571 machine_config = mono_get_machine_config ();
7572
7573 if (!machine_config)
7574 return NULL;
7575
7576 return mono_string_new (mono_domain_get (), machine_config);
7577 }
7578
7579 ICALL_EXPORT MonoString *
7580 ves_icall_System_Web_Util_ICalls_get_machine_install_dir (void)
7581 {
7582 MonoString *ipath;
7583 gchar *path;
7584
7585 path = g_path_get_dirname (mono_get_config_dir ());
7586
7587 #if defined (HOST_WIN32)
7588 /* Avoid mixing '/' and '\\' */
7589 {
7590 gint i;
7591 for (i = strlen (path) - 1; i >= 0; i--)
7592 if (path [i] == '/')
7593 path [i] = '\\';
7594 }
7595 #endif
7596 ipath = mono_string_new (mono_domain_get (), path);
7597 g_free (path);
7598
7599 return ipath;
7600 }
7601
7602 ICALL_EXPORT gboolean
7603 ves_icall_get_resources_ptr (MonoReflectionAssembly *assembly, gpointer *result, gint32 *size)
7604 {
7605 MonoPEResourceDataEntry *entry;
7606 MonoImage *image;
7607
7608 if (!assembly || !result || !size)
7609 return FALSE;
7610
7611 *result = NULL;
7612 *size = 0;
7613 image = assembly->assembly->image;
7614 entry = (MonoPEResourceDataEntry *)mono_image_lookup_resource (image, MONO_PE_RESOURCE_ID_ASPNET_STRING, 0, NULL);
7615 if (!entry)
7616 return FALSE;
7617
7618 *result = mono_image_rva_map (image, entry->rde_data_offset);
7619 if (!(*result)) {
7620 g_free (entry);
7621 return FALSE;
7622 }
7623 *size = entry->rde_size;
7624 g_free (entry);
7625 return TRUE;
7626 }
7627
7628 ICALL_EXPORT MonoBoolean
7629 ves_icall_System_Diagnostics_Debugger_IsAttached_internal (void)
7630 {
7631 return mono_is_debugger_attached ();
7632 }
7633
7634 ICALL_EXPORT MonoBoolean
7635 ves_icall_System_Diagnostics_Debugger_IsLogging (void)
7636 {
7637 if (mono_get_runtime_callbacks ()->debug_log_is_enabled)
7638 return mono_get_runtime_callbacks ()->debug_log_is_enabled ();
7639 else
7640 return FALSE;
7641 }
7642
7643 ICALL_EXPORT void
7644 ves_icall_System_Diagnostics_Debugger_Log (int level, MonoString *category, MonoString *message)
7645 {
7646 if (mono_get_runtime_callbacks ()->debug_log)
7647 mono_get_runtime_callbacks ()->debug_log (level, category, message);
7648 }
7649
7650 ICALL_EXPORT void
7651 ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (MonoString *message)
7652 {
7653 #if defined (HOST_WIN32)
7654 OutputDebugString (mono_string_chars (message));
7655 #else
7656 g_warning ("WriteWindowsDebugString called and HOST_WIN32 not defined!\n");
7657 #endif
7658 }
7659
7660 /* Only used for value types */
7661 ICALL_EXPORT MonoObject *
7662 ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType *type)
7663 {
7664 MonoError error;
7665 MonoObject *result;
7666 MonoClass *klass;
7667 MonoDomain *domain;
7668
7669 domain = mono_object_domain (type);
7670 klass = mono_class_from_mono_type (type->type);
7671 mono_class_init_checked (klass, &error);
7672 if (mono_error_set_pending_exception (&error))
7673 return NULL;
7674
7675 if (mono_class_is_nullable (klass))
7676 /* No arguments -> null */
7677 return NULL;
7678
7679 result = mono_object_new_checked (domain, klass, &error);
7680 mono_error_set_pending_exception (&error);
7681 return result;
7682 }
7683
7684 ICALL_EXPORT MonoReflectionMethod *
7685 ves_icall_MonoMethod_get_base_method (MonoReflectionMethod *m, gboolean definition)
7686 {
7687 MonoReflectionMethod *ret = NULL;
7688 MonoError error;
7689
7690 MonoClass *klass, *parent;
7691 MonoGenericContext *generic_inst = NULL;
7692 MonoMethod *method = m->method;
7693 MonoMethod *result = NULL;
7694 int slot;
7695
7696 if (method->klass == NULL)
7697 return m;
7698
7699 if (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) ||
7700 MONO_CLASS_IS_INTERFACE (method->klass) ||
7701 method->flags & METHOD_ATTRIBUTE_NEW_SLOT)
7702 return m;
7703
7704 slot = mono_method_get_vtable_slot (method);
7705 if (slot == -1)
7706 return m;
7707
7708 klass = method->klass;
7709 if (klass->generic_class) {
7710 generic_inst = mono_class_get_context (klass);
7711 klass = klass->generic_class->container_class;
7712 }
7713
7714 if (definition) {
7715 /* At the end of the loop, klass points to the eldest class that has this virtual function slot. */
7716 for (parent = klass->parent; parent != NULL; parent = parent->parent) {
7717 /* on entry, klass is either a plain old non-generic class and generic_inst == NULL
7718 or klass is the generic container class and generic_inst is the instantiation.
7719
7720 when we go to the parent, if the parent is an open constructed type, we need to
7721 replace the type parameters by the definitions from the generic_inst, and then take it
7722 apart again into the klass and the generic_inst.
7723
7724 For cases like this:
7725 class C<T> : B<T, int> {
7726 public override void Foo () { ... }
7727 }
7728 class B<U,V> : A<HashMap<U,V>> {
7729 public override void Foo () { ... }
7730 }
7731 class A<X> {
7732 public virtual void Foo () { ... }
7733 }
7734
7735 if at each iteration the parent isn't open, we can skip inflating it. if at some
7736 iteration the parent isn't generic (after possible inflation), we set generic_inst to
7737 NULL;
7738 */
7739 MonoGenericContext *parent_inst = NULL;
7740 if (mono_class_is_open_constructed_type (mono_class_get_type (parent))) {
7741 parent = mono_class_inflate_generic_class_checked (parent, generic_inst, &error);
7742 if (!mono_error_ok (&error)) {
7743 mono_error_set_pending_exception (&error);
7744 return NULL;
7745 }
7746 }
7747 if (parent->generic_class) {
7748 parent_inst = mono_class_get_context (parent);
7749 parent = parent->generic_class->container_class;
7750 }
7751
7752 mono_class_setup_vtable (parent);
7753 if (parent->vtable_size <= slot)
7754 break;
7755 klass = parent;
7756 generic_inst = parent_inst;
7757 }
7758 } else {
7759 klass = klass->parent;
7760 if (!klass)
7761 return m;
7762 if (mono_class_is_open_constructed_type (mono_class_get_type (klass))) {
7763 klass = mono_class_inflate_generic_class_checked (klass, generic_inst, &error);
7764 if (!mono_error_ok (&error)) {
7765 mono_error_set_pending_exception (&error);
7766 return NULL;
7767 }
7768
7769 generic_inst = NULL;
7770 }
7771 if (klass->generic_class) {
7772 generic_inst = mono_class_get_context (klass);
7773 klass = klass->generic_class->container_class;
7774 }
7775
7776 }
7777
7778 if (generic_inst) {
7779 klass = mono_class_inflate_generic_class_checked (klass, generic_inst, &error);
7780 if (!mono_error_ok (&error)) {
7781 mono_error_set_pending_exception (&error);
7782 return NULL;
7783 }
7784 }
7785
7786 if (klass == method->klass)
7787 return m;
7788
7789 /*This is possible if definition == FALSE.
7790 * Do it here to be really sure we don't read invalid memory.
7791 */
7792 if (slot >= klass->vtable_size)
7793 return m;
7794
7795 mono_class_setup_vtable (klass);
7796
7797 result = klass->vtable [slot];
7798 if (result == NULL) {
7799 /* It is an abstract method */
7800 gpointer iter = NULL;
7801 while ((result = mono_class_get_methods (klass, &iter)))
7802 if (result->slot == slot)
7803 break;
7804 }
7805
7806 if (result == NULL)
7807 return m;
7808
7809 ret = mono_method_get_object_checked (mono_domain_get (), result, NULL, &error);
7810 mono_error_set_pending_exception (&error);
7811 return ret;
7812 }
7813
7814 ICALL_EXPORT MonoString*
7815 ves_icall_MonoMethod_get_name (MonoReflectionMethod *m)
7816 {
7817 MonoMethod *method = m->method;
7818
7819 MONO_OBJECT_SETREF (m, name, mono_string_new (mono_object_domain (m), method->name));
7820 return m->name;
7821 }
7822
7823 ICALL_EXPORT void
7824 mono_ArgIterator_Setup (MonoArgIterator *iter, char* argsp, char* start)
7825 {
7826 iter->sig = *(MonoMethodSignature**)argsp;
7827
7828 g_assert (iter->sig->sentinelpos <= iter->sig->param_count);
7829 g_assert (iter->sig->call_convention == MONO_CALL_VARARG);
7830
7831 iter->next_arg = 0;
7832 /* FIXME: it's not documented what start is exactly... */
7833 if (start) {
7834 iter->args = start;
7835 } else {
7836 iter->args = argsp + sizeof (gpointer);
7837 }
7838 iter->num_args = iter->sig->param_count - iter->sig->sentinelpos;
7839
7840 /* g_print ("sig %p, param_count: %d, sent: %d\n", iter->sig, iter->sig->param_count, iter->sig->sentinelpos); */
7841 }
7842
7843 ICALL_EXPORT MonoTypedRef
7844 mono_ArgIterator_IntGetNextArg (MonoArgIterator *iter)
7845 {
7846 guint32 i, arg_size;
7847 gint32 align;
7848 MonoTypedRef res;
7849
7850 i = iter->sig->sentinelpos + iter->next_arg;
7851
7852 g_assert (i < iter->sig->param_count);
7853
7854 res.type = iter->sig->params [i];
7855 res.klass = mono_class_from_mono_type (res.type);
7856 arg_size = mono_type_stack_size (res.type, &align);
7857 #if defined(__arm__) || defined(__mips__)
7858 iter->args = (guint8*)(((gsize)iter->args + (align) - 1) & ~(align - 1));
7859 #endif
7860 res.value = iter->args;
7861 #if defined(__native_client__) && SIZEOF_REGISTER == 8
7862 /* Values are stored as 8 byte register sized objects, but 'value'
7863 * is dereferenced as a pointer in other routines.
7864 */
7865 res.value = (char*)res.value + 4;
7866 #endif
7867 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
7868 if (arg_size <= sizeof (gpointer)) {
7869 int dummy;
7870 int padding = arg_size - mono_type_size (res.type, &dummy);
7871 res.value = (guint8*)res.value + padding;
7872 }
7873 #endif
7874 iter->args = (char*)iter->args + arg_size;
7875 iter->next_arg++;
7876
7877 /* g_print ("returning arg %d, type 0x%02x of size %d at %p\n", i, res.type->type, arg_size, res.value); */
7878
7879 return res;
7880 }
7881
7882 ICALL_EXPORT MonoTypedRef
7883 mono_ArgIterator_IntGetNextArgT (MonoArgIterator *iter, MonoType *type)
7884 {
7885 guint32 i, arg_size;
7886 gint32 align;
7887 MonoTypedRef res;
7888
7889 i = iter->sig->sentinelpos + iter->next_arg;
7890
7891 g_assert (i < iter->sig->param_count);
7892
7893 while (i < iter->sig->param_count) {
7894 if (!mono_metadata_type_equal (type, iter->sig->params [i]))
7895 continue;
7896 res.type = iter->sig->params [i];
7897 res.klass = mono_class_from_mono_type (res.type);
7898 /* FIXME: endianess issue... */
7899 arg_size = mono_type_stack_size (res.type, &align);
7900 #if defined(__arm__) || defined(__mips__)
7901 iter->args = (guint8*)(((gsize)iter->args + (align) - 1) & ~(align - 1));
7902 #endif
7903 res.value = iter->args;
7904 iter->args = (char*)iter->args + arg_size;
7905 iter->next_arg++;
7906 /* g_print ("returning arg %d, type 0x%02x of size %d at %p\n", i, res.type->type, arg_size, res.value); */
7907 return res;
7908 }
7909 /* g_print ("arg type 0x%02x not found\n", res.type->type); */
7910
7911 res.type = NULL;
7912 res.value = NULL;
7913 res.klass = NULL;
7914 return res;
7915 }
7916
7917 ICALL_EXPORT MonoType*
7918 mono_ArgIterator_IntGetNextArgType (MonoArgIterator *iter)
7919 {
7920 gint i;
7921
7922 i = iter->sig->sentinelpos + iter->next_arg;
7923
7924 g_assert (i < iter->sig->param_count);
7925
7926 return iter->sig->params [i];
7927 }
7928
7929 ICALL_EXPORT MonoObject*
7930 mono_TypedReference_ToObject (MonoTypedRef* tref)
7931 {
7932 MonoError error;
7933 MonoObject *result = NULL;
7934 if (MONO_TYPE_IS_REFERENCE (tref->type)) {
7935 MonoObject** objp = (MonoObject **)tref->value;
7936 return *objp;
7937 }
7938
7939 result = mono_value_box_checked (mono_domain_get (), tref->klass, tref->value, &error);
7940 mono_error_set_pending_exception (&error);
7941 return result;
7942 }
7943
7944 ICALL_EXPORT MonoTypedRef
7945 mono_TypedReference_MakeTypedReferenceInternal (MonoObject *target, MonoArray *fields)
7946 {
7947 MonoTypedRef res;
7948 MonoReflectionField *f;
7949 MonoClass *klass;
7950 MonoType *ftype = NULL;
7951 guint8 *p = NULL;
7952 int i;
7953
7954 memset (&res, 0, sizeof (res));
7955
7956 g_assert (fields);
7957 g_assert (mono_array_length (fields) > 0);
7958
7959 klass = target->vtable->klass;
7960
7961 for (i = 0; i < mono_array_length (fields); ++i) {
7962 f = mono_array_get (fields, MonoReflectionField*, i);
7963 if (f == NULL) {
7964 mono_set_pending_exception (mono_get_exception_argument_null ("field"));
7965 return res;
7966 }
7967 if (f->field->parent != klass) {
7968 mono_set_pending_exception (mono_get_exception_argument ("field", ""));
7969 return res;
7970 }
7971 if (i == 0)
7972 p = (guint8*)target + f->field->offset;
7973 else
7974 p += f->field->offset - sizeof (MonoObject);
7975 klass = mono_class_from_mono_type (f->field->type);
7976 ftype = f->field->type;
7977 }
7978
7979 res.type = ftype;
7980 res.klass = mono_class_from_mono_type (ftype);
7981 res.value = p;
7982
7983 return res;
7984 }
7985
7986 static void
7987 prelink_method (MonoMethod *method, MonoError *error)
7988 {
7989 const char *exc_class, *exc_arg;
7990
7991 mono_error_init (error);
7992 if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
7993 return;
7994 mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
7995 if (exc_class) {
7996 mono_error_set_exception_instance (error,
7997 mono_exception_from_name_msg (mono_defaults.corlib, "System", exc_class, exc_arg));
7998 return;
7999 }
8000 /* create the wrapper, too? */
8001 }
8002
8003 ICALL_EXPORT void
8004 ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod *method)
8005 {
8006 MonoError error;
8007
8008 prelink_method (method->method, &error);
8009 mono_error_set_pending_exception (&error);
8010 }
8011
8012 ICALL_EXPORT void
8013 ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType *type)
8014 {
8015 MonoError error;
8016 MonoClass *klass = mono_class_from_mono_type (type->type);
8017 MonoMethod* m;
8018 gpointer iter = NULL;
8019
8020 mono_class_init_checked (klass, &error);
8021 if (mono_error_set_pending_exception (&error))
8022 return;
8023
8024 while ((m = mono_class_get_methods (klass, &iter))) {
8025 prelink_method (m, &error);
8026 if (mono_error_set_pending_exception (&error))
8027 return;
8028 }
8029 }
8030
8031 /* These parameters are "readonly" in corlib/System/NumberFormatter.cs */
8032 ICALL_EXPORT void
8033 ves_icall_System_NumberFormatter_GetFormatterTables (guint64 const **mantissas,
8034 gint32 const **exponents,
8035 gunichar2 const **digitLowerTable,
8036 gunichar2 const **digitUpperTable,
8037 gint64 const **tenPowersList,
8038 gint32 const **decHexDigits)
8039 {
8040 *mantissas = Formatter_MantissaBitsTable;
8041 *exponents = Formatter_TensExponentTable;
8042 *digitLowerTable = Formatter_DigitLowerTable;
8043 *digitUpperTable = Formatter_DigitUpperTable;
8044 *tenPowersList = Formatter_TenPowersList;
8045 *decHexDigits = Formatter_DecHexDigits;
8046 }
8047
8048 /*
8049 * We return NULL for no modifiers so the corlib code can return Type.EmptyTypes
8050 * and avoid useless allocations.
8051 */
8052 static MonoArray*
8053 type_array_from_modifiers (MonoImage *image, MonoType *type, int optional, MonoError *error)
8054 {
8055 MonoReflectionType *rt;
8056 MonoArray *res;
8057 int i, count = 0;
8058
8059 mono_error_init (error);
8060 for (i = 0; i < type->num_mods; ++i) {
8061 if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required))
8062 count++;
8063 }
8064 if (!count)
8065 return NULL;
8066 res = mono_array_new_checked (mono_domain_get (), mono_defaults.systemtype_class, count, error);
8067 return_val_if_nok (error, NULL);
8068 count = 0;
8069 for (i = 0; i < type->num_mods; ++i) {
8070 if ((optional && !type->modifiers [i].required) || (!optional && type->modifiers [i].required)) {
8071 MonoClass *klass = mono_class_get_checked (image, type->modifiers [i].token, error);
8072 return_val_if_nok (error, NULL);
8073
8074 rt = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, error);
8075 return_val_if_nok (error, NULL);
8076
8077 mono_array_setref (res, count, rt);
8078 count++;
8079 }
8080 }
8081 return res;
8082 }
8083
8084 ICALL_EXPORT MonoArray*
8085 ves_icall_ParameterInfo_GetTypeModifiers (MonoReflectionParameter *param, MonoBoolean optional)
8086 {
8087 MonoError error;
8088 MonoType *type = param->ClassImpl->type;
8089 MonoClass *member_class = mono_object_class (param->MemberImpl);
8090 MonoMethod *method = NULL;
8091 MonoImage *image;
8092 int pos;
8093 MonoMethodSignature *sig;
8094 MonoArray *res;
8095
8096 if (mono_class_is_reflection_method_or_constructor (member_class)) {
8097 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)param->MemberImpl;
8098 method = rmethod->method;
8099 } else if (member_class->image == mono_defaults.corlib && !strcmp ("MonoProperty", member_class->name)) {
8100 MonoReflectionProperty *prop = (MonoReflectionProperty *)param->MemberImpl;
8101 if (!(method = prop->property->get))
8102 method = prop->property->set;
8103 g_assert (method);
8104 } else {
8105 char *type_name = mono_type_get_full_name (member_class);
8106 char *msg = g_strdup_printf ("Custom modifiers on a ParamInfo with member %s are not supported", type_name);
8107 MonoException *ex = mono_get_exception_not_supported (msg);
8108 g_free (type_name);
8109 g_free (msg);
8110 mono_set_pending_exception (ex);
8111 return NULL;
8112 }
8113
8114 image = method->klass->image;
8115 pos = param->PositionImpl;
8116 sig = mono_method_signature (method);
8117 if (pos == -1)
8118 type = sig->ret;
8119 else
8120 type = sig->params [pos];
8121
8122 res = type_array_from_modifiers (image, type, optional, &error);
8123 mono_error_set_pending_exception (&error);
8124 return res;
8125 }
8126
8127 static MonoType*
8128 get_property_type (MonoProperty *prop)
8129 {
8130 MonoMethodSignature *sig;
8131 if (prop->get) {
8132 sig = mono_method_signature (prop->get);
8133 return sig->ret;
8134 } else if (prop->set) {
8135 sig = mono_method_signature (prop->set);
8136 return sig->params [sig->param_count - 1];
8137 }
8138 return NULL;
8139 }
8140
8141 ICALL_EXPORT MonoArray*
8142 ves_icall_MonoPropertyInfo_GetTypeModifiers (MonoReflectionProperty *property, MonoBoolean optional)
8143 {
8144 MonoError error;
8145 MonoType *type = get_property_type (property->property);
8146 MonoImage *image = property->klass->image;
8147 MonoArray *res;
8148
8149 if (!type)
8150 return NULL;
8151 res = type_array_from_modifiers (image, type, optional, &error);
8152 mono_error_set_pending_exception (&error);
8153 return res;
8154 }
8155
8156 /*
8157 *Construct a MonoType suited to be used to decode a constant blob object.
8158 *
8159 * @type is the target type which will be constructed
8160 * @blob_type is the blob type, for example, that comes from the constant table
8161 * @real_type is the expected constructed type.
8162 */
8163 static void
8164 mono_type_from_blob_type (MonoType *type, MonoTypeEnum blob_type, MonoType *real_type)
8165 {
8166 type->type = blob_type;
8167 type->data.klass = NULL;
8168 if (blob_type == MONO_TYPE_CLASS)
8169 type->data.klass = mono_defaults.object_class;
8170 else if (real_type->type == MONO_TYPE_VALUETYPE && real_type->data.klass->enumtype) {
8171 /* For enums, we need to use the base type */
8172 type->type = MONO_TYPE_VALUETYPE;
8173 type->data.klass = mono_class_from_mono_type (real_type);
8174 } else
8175 type->data.klass = mono_class_from_mono_type (real_type);
8176 }
8177
8178 ICALL_EXPORT MonoObject*
8179 property_info_get_default_value (MonoReflectionProperty *property)
8180 {
8181 MonoError error;
8182 MonoType blob_type;
8183 MonoProperty *prop = property->property;
8184 MonoType *type = get_property_type (prop);
8185 MonoDomain *domain = mono_object_domain (property);
8186 MonoTypeEnum def_type;
8187 const char *def_value;
8188 MonoObject *o;
8189
8190 mono_class_init (prop->parent);
8191
8192 if (!(prop->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT)) {
8193 mono_set_pending_exception (mono_get_exception_invalid_operation (NULL));
8194 return NULL;
8195 }
8196
8197 def_value = mono_class_get_property_default_value (prop, &def_type);
8198
8199 mono_type_from_blob_type (&blob_type, def_type, type);
8200 o = mono_get_object_from_blob (domain, &blob_type, def_value, &error);
8201
8202 mono_error_set_pending_exception (&error);
8203 return o;
8204 }
8205
8206 ICALL_EXPORT MonoBoolean
8207 custom_attrs_defined_internal (MonoObject *obj, MonoReflectionType *attr_type)
8208 {
8209 MonoError error;
8210 MonoClass *attr_class = mono_class_from_mono_type (attr_type->type);
8211 MonoCustomAttrInfo *cinfo;
8212 gboolean found;
8213
8214 mono_class_init_checked (attr_class, &error);
8215 if (mono_error_set_pending_exception (&error))
8216 return FALSE;
8217
8218 cinfo = mono_reflection_get_custom_attrs_info_checked (obj, &error);
8219 if (!is_ok (&error)) {
8220 mono_error_set_pending_exception (&error);
8221 return FALSE;
8222 }
8223 if (!cinfo)
8224 return FALSE;
8225 found = mono_custom_attrs_has_attr (cinfo, attr_class);
8226 if (!cinfo->cached)
8227 mono_custom_attrs_free (cinfo);
8228 return found;
8229 }
8230
8231 ICALL_EXPORT MonoArray*
8232 custom_attrs_get_by_type (MonoObject *obj, MonoReflectionType *attr_type)
8233 {
8234 MonoClass *attr_class = attr_type ? mono_class_from_mono_type (attr_type->type) : NULL;
8235 MonoArray *res;
8236 MonoError error;
8237
8238 if (attr_class) {
8239 mono_class_init_checked (attr_class, &error);
8240 if (mono_error_set_pending_exception (&error))
8241 return NULL;
8242 }
8243
8244 res = mono_reflection_get_custom_attrs_by_type (obj, attr_class, &error);
8245 if (!mono_error_ok (&error)) {
8246 mono_error_set_pending_exception (&error);
8247 return NULL;
8248 }
8249
8250 return res;
8251 }
8252
8253 ICALL_EXPORT MonoArray*
8254 ves_icall_MonoCustomAttrs_GetCustomAttributesDataInternal (MonoObject *obj)
8255 {
8256 MonoError error;
8257 MonoArray *result;
8258 result = mono_reflection_get_custom_attrs_data_checked (obj, &error);
8259 mono_error_set_pending_exception (&error);
8260 return result;
8261 }
8262
8263
8264 ICALL_EXPORT MonoString*
8265 ves_icall_Mono_Runtime_GetDisplayName (void)
8266 {
8267 char *info;
8268 MonoString *display_name;
8269
8270 info = mono_get_runtime_callbacks ()->get_runtime_build_info ();
8271 display_name = mono_string_new (mono_domain_get (), info);
8272 g_free (info);
8273 return display_name;
8274 }
8275
8276 ICALL_EXPORT MonoString*
8277 ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code)
8278 {
8279 MonoError error;
8280 MonoString *message;
8281 guint32 ret;
8282 gunichar2 buf[256];
8283
8284 ret = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
8285 FORMAT_MESSAGE_IGNORE_INSERTS, NULL, code, 0,
8286 buf, 255, NULL);
8287 if (ret == 0) {
8288 message = mono_string_new (mono_domain_get (), "Error looking up error string");
8289 } else {
8290 message = mono_string_new_utf16_checked (mono_domain_get (), buf, ret, &error);
8291 if (mono_error_set_pending_exception (&error))
8292 return NULL;
8293 }
8294
8295 return message;
8296 }
8297
8298 ICALL_EXPORT gpointer
8299 ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcess (void)
8300 {
8301 return GetCurrentProcess ();
8302 }
8303
8304 ICALL_EXPORT MonoBoolean
8305 ves_icall_Microsoft_Win32_NativeMethods_GetExitCodeProcess (gpointer handle, gint32 *exitcode)
8306 {
8307 return GetExitCodeProcess (handle, (guint32*) exitcode);
8308 }
8309
8310 ICALL_EXPORT MonoBoolean
8311 ves_icall_Microsoft_Win32_NativeMethods_CloseProcess (gpointer handle)
8312 {
8313 #if defined(TARGET_WIN32) || defined(HOST_WIN32)
8314 return CloseHandle (handle);
8315 #else
8316 return CloseProcess (handle);
8317 #endif
8318 }
8319
8320 ICALL_EXPORT MonoBoolean
8321 ves_icall_Microsoft_Win32_NativeMethods_TerminateProcess (gpointer handle, gint32 exitcode)
8322 {
8323 return TerminateProcess (handle, exitcode);
8324 }
8325
8326 ICALL_EXPORT gint32
8327 ves_icall_Microsoft_Win32_NativeMethods_WaitForInputIdle (gpointer handle, gint32 milliseconds)
8328 {
8329 return WaitForInputIdle (handle, milliseconds);
8330 }
8331
8332 ICALL_EXPORT MonoBoolean
8333 ves_icall_Microsoft_Win32_NativeMethods_GetProcessWorkingSetSize (gpointer handle, gsize *min, gsize *max)
8334 {
8335 return GetProcessWorkingSetSize (handle, min, max);
8336 }
8337
8338 ICALL_EXPORT MonoBoolean
8339 ves_icall_Microsoft_Win32_NativeMethods_SetProcessWorkingSetSize (gpointer handle, gsize min, gsize max)
8340 {
8341 return SetProcessWorkingSetSize (handle, min, max);
8342 }
8343
8344 ICALL_EXPORT MonoBoolean
8345 ves_icall_Microsoft_Win32_NativeMethods_GetProcessTimes (gpointer handle, gint64 *creationtime, gint64 *exittime, gint64 *kerneltime, gint64 *usertime)
8346 {
8347 return GetProcessTimes (handle, (LPFILETIME) creationtime, (LPFILETIME) exittime, (LPFILETIME) kerneltime, (LPFILETIME) usertime);
8348 }
8349
8350 ICALL_EXPORT gint32
8351 ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcessId (void)
8352 {
8353 return mono_process_current_pid ();
8354 }
8355
8356 ICALL_EXPORT gint32
8357 ves_icall_Microsoft_Win32_NativeMethods_GetPriorityClass (gpointer handle)
8358 {
8359 return GetPriorityClass (handle);
8360 }
8361
8362 ICALL_EXPORT MonoBoolean
8363 ves_icall_Microsoft_Win32_NativeMethods_SetPriorityClass (gpointer handle, gint32 priorityClass)
8364 {
8365 return SetPriorityClass (handle, priorityClass);
8366 }
8367
8368 #ifndef DISABLE_ICALL_TABLES
8369
8370 #define ICALL_TYPE(id,name,first)
8371 #define ICALL(id,name,func) Icall_ ## id,
8372
8373 enum {
8374 #include "metadata/icall-def.h"
8375 Icall_last
8376 };
8377
8378 #undef ICALL_TYPE
8379 #undef ICALL
8380 #define ICALL_TYPE(id,name,first) Icall_type_ ## id,
8381 #define ICALL(id,name,func)
8382 enum {
8383 #include "metadata/icall-def.h"
8384 Icall_type_num
8385 };
8386
8387 #undef ICALL_TYPE
8388 #undef ICALL
8389 #define ICALL_TYPE(id,name,firstic) {(Icall_ ## firstic)},
8390 #define ICALL(id,name,func)
8391 typedef struct {
8392 guint16 first_icall;
8393 } IcallTypeDesc;
8394
8395 static const IcallTypeDesc
8396 icall_type_descs [] = {
8397 #include "metadata/icall-def.h"
8398 {Icall_last}
8399 };
8400
8401 #define icall_desc_num_icalls(desc) ((desc) [1].first_icall - (desc) [0].first_icall)
8402
8403 #undef ICALL_TYPE
8404 #define ICALL_TYPE(id,name,first)
8405 #undef ICALL
8406
8407 #ifdef HAVE_ARRAY_ELEM_INIT
8408 #define MSGSTRFIELD(line) MSGSTRFIELD1(line)
8409 #define MSGSTRFIELD1(line) str##line
8410
8411 static const struct msgstrtn_t {
8412 #define ICALL(id,name,func)
8413 #undef ICALL_TYPE
8414 #define ICALL_TYPE(id,name,first) char MSGSTRFIELD(__LINE__) [sizeof (name)];
8415 #include "metadata/icall-def.h"
8416 #undef ICALL_TYPE
8417 } icall_type_names_str = {
8418 #define ICALL_TYPE(id,name,first) (name),
8419 #include "metadata/icall-def.h"
8420 #undef ICALL_TYPE
8421 };
8422 static const guint16 icall_type_names_idx [] = {
8423 #define ICALL_TYPE(id,name,first) [Icall_type_ ## id] = offsetof (struct msgstrtn_t, MSGSTRFIELD(__LINE__)),
8424 #include "metadata/icall-def.h"
8425 #undef ICALL_TYPE
8426 };
8427 #define icall_type_name_get(id) ((const char*)&icall_type_names_str + icall_type_names_idx [(id)])
8428
8429 static const struct msgstr_t {
8430 #undef ICALL
8431 #define ICALL_TYPE(id,name,first)
8432 #define ICALL(id,name,func) char MSGSTRFIELD(__LINE__) [sizeof (name)];
8433 #include "metadata/icall-def.h"
8434 #undef ICALL
8435 } icall_names_str = {
8436 #define ICALL(id,name,func) (name),
8437 #include "metadata/icall-def.h"
8438 #undef ICALL
8439 };
8440 static const guint16 icall_names_idx [] = {
8441 #define ICALL(id,name,func) [Icall_ ## id] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)),
8442 #include "metadata/icall-def.h"
8443 #undef ICALL
8444 };
8445 #define icall_name_get(id) ((const char*)&icall_names_str + icall_names_idx [(id)])
8446
8447 #else
8448
8449 #undef ICALL_TYPE
8450 #undef ICALL
8451 #define ICALL_TYPE(id,name,first) name,
8452 #define ICALL(id,name,func)
8453 static const char* const
8454 icall_type_names [] = {
8455 #include "metadata/icall-def.h"
8456 NULL
8457 };
8458
8459 #define icall_type_name_get(id) (icall_type_names [(id)])
8460
8461 #undef ICALL_TYPE
8462 #undef ICALL
8463 #define ICALL_TYPE(id,name,first)
8464 #define ICALL(id,name,func) name,
8465 static const char* const
8466 icall_names [] = {
8467 #include "metadata/icall-def.h"
8468 NULL
8469 };
8470 #define icall_name_get(id) icall_names [(id)]
8471
8472 #endif /* !HAVE_ARRAY_ELEM_INIT */
8473
8474 #undef ICALL_TYPE
8475 #undef ICALL
8476 #define ICALL_TYPE(id,name,first)
8477 #define ICALL(id,name,func) func,
8478 static const gconstpointer
8479 icall_functions [] = {
8480 #include "metadata/icall-def.h"
8481 NULL
8482 };
8483
8484 #ifdef ENABLE_ICALL_SYMBOL_MAP
8485 #undef ICALL_TYPE
8486 #undef ICALL
8487 #define ICALL_TYPE(id,name,first)
8488 #define ICALL(id,name,func) #func,
8489 static const gconstpointer
8490 icall_symbols [] = {
8491 #include "metadata/icall-def.h"
8492 NULL
8493 };
8494 #endif
8495
8496 #endif /* DISABLE_ICALL_TABLES */
8497
8498 static mono_mutex_t icall_mutex;
8499 static GHashTable *icall_hash = NULL;
8500 static GHashTable *jit_icall_hash_name = NULL;
8501 static GHashTable *jit_icall_hash_addr = NULL;
8502
8503 void
8504 mono_icall_init (void)
8505 {
8506 #ifndef DISABLE_ICALL_TABLES
8507 int i = 0;
8508
8509 /* check that tables are sorted: disable in release */
8510 if (TRUE) {
8511 int j;
8512 const char *prev_class = NULL;
8513 const char *prev_method;
8514
8515 for (i = 0; i < Icall_type_num; ++i) {
8516 const IcallTypeDesc *desc;
8517 int num_icalls;
8518 prev_method = NULL;
8519 if (prev_class && strcmp (prev_class, icall_type_name_get (i)) >= 0)
8520 g_print ("class %s should come before class %s\n", icall_type_name_get (i), prev_class);
8521 prev_class = icall_type_name_get (i);
8522 desc = &icall_type_descs [i];
8523 num_icalls = icall_desc_num_icalls (desc);
8524 /*g_print ("class %s has %d icalls starting at %d\n", prev_class, num_icalls, desc->first_icall);*/
8525 for (j = 0; j < num_icalls; ++j) {
8526 const char *methodn = icall_name_get (desc->first_icall + j);
8527 if (prev_method && strcmp (prev_method, methodn) >= 0)
8528 g_print ("method %s should come before method %s\n", methodn, prev_method);
8529 prev_method = methodn;
8530 }
8531 }
8532 }
8533 #endif
8534
8535 icall_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
8536 mono_os_mutex_init (&icall_mutex);
8537 }
8538
8539 static void
8540 mono_icall_lock (void)
8541 {
8542 mono_locks_os_acquire (&icall_mutex, IcallLock);
8543 }
8544
8545 static void
8546 mono_icall_unlock (void)
8547 {
8548 mono_locks_os_release (&icall_mutex, IcallLock);
8549 }
8550
8551 void
8552 mono_icall_cleanup (void)
8553 {
8554 g_hash_table_destroy (icall_hash);
8555 g_hash_table_destroy (jit_icall_hash_name);
8556 g_hash_table_destroy (jit_icall_hash_addr);
8557 mono_os_mutex_destroy (&icall_mutex);
8558 }
8559
8560 /**
8561 * mono_add_internal_call:
8562 * @name: method specification to surface to the managed world
8563 * @method: pointer to a C method to invoke when the method is called
8564 *
8565 * This method surfaces the C function pointed by @method as a method
8566 * that has been surfaced in managed code with the method specified in
8567 * @name as an internal call.
8568 *
8569 * Internal calls are surfaced to all app domains loaded and they are
8570 * accessibly by a type with the specified name.
8571 *
8572 * You must provide a fully qualified type name, that is namespaces
8573 * and type name, followed by a colon and the method name, with an
8574 * optional signature to bind.
8575 *
8576 * For example, the following are all valid declarations:
8577 *
8578 * "MyApp.Services.ScriptService:Accelerate"
8579 * "MyApp.Services.ScriptService:Slowdown(int,bool)"
8580 *
8581 * You use method parameters in cases where there might be more than
8582 * one surface method to managed code. That way you can register different
8583 * internal calls for different method overloads.
8584 *
8585 * The internal calls are invoked with no marshalling. This means that .NET
8586 * types like System.String are exposed as `MonoString *` parameters. This is
8587 * different than the way that strings are surfaced in P/Invoke.
8588 *
8589 * For more information on how the parameters are marshalled, see the
8590 * <a href="http://www.mono-project.com/docs/advanced/embedding/">Mono Embedding</a>
8591 * page.
8592 *
8593 * See the <a href="mono-api-methods.html#method-desc">Method Description</a>
8594 * reference for more information on the format of method descriptions.
8595 */
8596 void
8597 mono_add_internal_call (const char *name, gconstpointer method)
8598 {
8599 mono_icall_lock ();
8600
8601 g_hash_table_insert (icall_hash, g_strdup (name), (gpointer) method);
8602
8603 mono_icall_unlock ();
8604 }
8605
8606 #ifndef DISABLE_ICALL_TABLES
8607
8608 #ifdef HAVE_ARRAY_ELEM_INIT
8609 static int
8610 compare_method_imap (const void *key, const void *elem)
8611 {
8612 const char* method_name = (const char*)&icall_names_str + (*(guint16*)elem);
8613 return strcmp (key, method_name);
8614 }
8615
8616 static gpointer
8617 find_method_icall (const IcallTypeDesc *imap, const char *name)
8618 {
8619 const guint16 *nameslot = (const guint16 *)mono_binary_search (name, icall_names_idx + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names_idx [0]), compare_method_imap);
8620 if (!nameslot)
8621 return NULL;
8622 return (gpointer)icall_functions [(nameslot - &icall_names_idx [0])];
8623 }
8624
8625 static int
8626 compare_class_imap (const void *key, const void *elem)
8627 {
8628 const char* class_name = (const char*)&icall_type_names_str + (*(guint16*)elem);
8629 return strcmp (key, class_name);
8630 }
8631
8632 static const IcallTypeDesc*
8633 find_class_icalls (const char *name)
8634 {
8635 const guint16 *nameslot = (const guint16 *)mono_binary_search (name, icall_type_names_idx, Icall_type_num, sizeof (icall_type_names_idx [0]), compare_class_imap);
8636 if (!nameslot)
8637 return NULL;
8638 return &icall_type_descs [nameslot - &icall_type_names_idx [0]];
8639 }
8640
8641 #else /* HAVE_ARRAY_ELEM_INIT */
8642
8643 static int
8644 compare_method_imap (const void *key, const void *elem)
8645 {
8646 const char** method_name = (const char**)elem;
8647 return strcmp (key, *method_name);
8648 }
8649
8650 static gpointer
8651 find_method_icall (const IcallTypeDesc *imap, const char *name)
8652 {
8653 const char **nameslot = mono_binary_search (name, icall_names + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names [0]), compare_method_imap);
8654 if (!nameslot)
8655 return NULL;
8656 return (gpointer)icall_functions [(nameslot - icall_names)];
8657 }
8658
8659 static int
8660 compare_class_imap (const void *key, const void *elem)
8661 {
8662 const char** class_name = (const char**)elem;
8663 return strcmp (key, *class_name);
8664 }
8665
8666 static const IcallTypeDesc*
8667 find_class_icalls (const char *name)
8668 {
8669 const char **nameslot = mono_binary_search (name, icall_type_names, Icall_type_num, sizeof (icall_type_names [0]), compare_class_imap);
8670 if (!nameslot)
8671 return NULL;
8672 return &icall_type_descs [nameslot - icall_type_names];
8673 }
8674
8675 #endif /* HAVE_ARRAY_ELEM_INIT */
8676
8677 #endif /* DISABLE_ICALL_TABLES */
8678
8679 /*
8680 * we should probably export this as an helper (handle nested types).
8681 * Returns the number of chars written in buf.
8682 */
8683 static int
8684 concat_class_name (char *buf, int bufsize, MonoClass *klass)
8685 {
8686 int nspacelen, cnamelen;
8687 nspacelen = strlen (klass->name_space);
8688 cnamelen = strlen (klass->name);
8689 if (nspacelen + cnamelen + 2 > bufsize)
8690 return 0;
8691 if (nspacelen) {
8692 memcpy (buf, klass->name_space, nspacelen);
8693 buf [nspacelen ++] = '.';
8694 }
8695 memcpy (buf + nspacelen, klass->name, cnamelen);
8696 buf [nspacelen + cnamelen] = 0;
8697 return nspacelen + cnamelen;
8698 }
8699
8700 #ifdef DISABLE_ICALL_TABLES
8701 static void
8702 no_icall_table (void)
8703 {
8704 g_assert_not_reached ();
8705 }
8706 #endif
8707
8708 gpointer
8709 mono_lookup_internal_call (MonoMethod *method)
8710 {
8711 char *sigstart;
8712 char *tmpsig;
8713 char mname [2048];
8714 int typelen = 0, mlen, siglen;
8715 gpointer res;
8716 #ifndef DISABLE_ICALL_TABLES
8717 const IcallTypeDesc *imap = NULL;
8718 #endif
8719
8720 g_assert (method != NULL);
8721
8722 if (method->is_inflated)
8723 method = ((MonoMethodInflated *) method)->declaring;
8724
8725 if (method->klass->nested_in) {
8726 int pos = concat_class_name (mname, sizeof (mname)-2, method->klass->nested_in);
8727 if (!pos)
8728 return NULL;
8729
8730 mname [pos++] = '/';
8731 mname [pos] = 0;
8732
8733 typelen = concat_class_name (mname+pos, sizeof (mname)-pos-1, method->klass);
8734 if (!typelen)
8735 return NULL;
8736
8737 typelen += pos;
8738 } else {
8739 typelen = concat_class_name (mname, sizeof (mname), method->klass);
8740 if (!typelen)
8741 return NULL;
8742 }
8743
8744 #ifndef DISABLE_ICALL_TABLES
8745 imap = find_class_icalls (mname);
8746 #endif
8747
8748 mname [typelen] = ':';
8749 mname [typelen + 1] = ':';
8750
8751 mlen = strlen (method->name);
8752 memcpy (mname + typelen + 2, method->name, mlen);
8753 sigstart = mname + typelen + 2 + mlen;
8754 *sigstart = 0;
8755
8756 tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE);
8757 siglen = strlen (tmpsig);
8758 if (typelen + mlen + siglen + 6 > sizeof (mname))
8759 return NULL;
8760 sigstart [0] = '(';
8761 memcpy (sigstart + 1, tmpsig, siglen);
8762 sigstart [siglen + 1] = ')';
8763 sigstart [siglen + 2] = 0;
8764 g_free (tmpsig);
8765
8766 mono_icall_lock ();
8767
8768 res = g_hash_table_lookup (icall_hash, mname);
8769 if (res) {
8770 mono_icall_unlock ();;
8771 return res;
8772 }
8773 /* try without signature */
8774 *sigstart = 0;
8775 res = g_hash_table_lookup (icall_hash, mname);
8776 if (res) {
8777 mono_icall_unlock ();
8778 return res;
8779 }
8780
8781 #ifdef DISABLE_ICALL_TABLES
8782 mono_icall_unlock ();
8783 /* Fail only when the result is actually used */
8784 /* mono_marshal_get_native_wrapper () depends on this */
8785 if (method->klass == mono_defaults.string_class && !strcmp (method->name, ".ctor"))
8786 return ves_icall_System_String_ctor_RedirectToCreateString;
8787 else
8788 return no_icall_table;
8789 #else
8790 /* it wasn't found in the static call tables */
8791 if (!imap) {
8792 mono_icall_unlock ();
8793 return NULL;
8794 }
8795 res = find_method_icall (imap, sigstart - mlen);
8796 if (res) {
8797 mono_icall_unlock ();
8798 return res;
8799 }
8800 /* try _with_ signature */
8801 *sigstart = '(';
8802 res = find_method_icall (imap, sigstart - mlen);
8803 if (res) {
8804 mono_icall_unlock ();
8805 return res;
8806 }
8807
8808 g_warning ("cant resolve internal call to \"%s\" (tested without signature also)", mname);
8809 g_print ("\nYour mono runtime and class libraries are out of sync.\n");
8810 g_print ("The out of sync library is: %s\n", method->klass->image->name);
8811 g_print ("\nWhen you update one from git you need to update, compile and install\nthe other too.\n");
8812 g_print ("Do not report this as a bug unless you're sure you have updated correctly:\nyou probably have a broken mono install.\n");
8813 g_print ("If you see other errors or faults after this message they are probably related\n");
8814 g_print ("and you need to fix your mono install first.\n");
8815
8816 mono_icall_unlock ();
8817
8818 return NULL;
8819 #endif
8820 }
8821
8822 #ifdef ENABLE_ICALL_SYMBOL_MAP
8823 static int
8824 func_cmp (gconstpointer key, gconstpointer p)
8825 {
8826 return (gsize)key - (gsize)*(gsize*)p;
8827 }
8828 #endif
8829
8830 /*
8831 * mono_lookup_icall_symbol:
8832 *
8833 * Given the icall METHOD, returns its C symbol.
8834 */
8835 const char*
8836 mono_lookup_icall_symbol (MonoMethod *m)
8837 {
8838 #ifdef DISABLE_ICALL_TABLES
8839 g_assert_not_reached ();
8840 return NULL;
8841 #else
8842 #ifdef ENABLE_ICALL_SYMBOL_MAP
8843 gpointer func;
8844 int i;
8845 gpointer slot;
8846 static gconstpointer *functions_sorted;
8847 static const char**symbols_sorted;
8848 static gboolean inited;
8849
8850 if (!inited) {
8851 gboolean changed;
8852
8853 functions_sorted = g_malloc (G_N_ELEMENTS (icall_functions) * sizeof (gpointer));
8854 memcpy (functions_sorted, icall_functions, G_N_ELEMENTS (icall_functions) * sizeof (gpointer));
8855 symbols_sorted = g_malloc (G_N_ELEMENTS (icall_functions) * sizeof (gpointer));
8856 memcpy (symbols_sorted, icall_symbols, G_N_ELEMENTS (icall_functions) * sizeof (gpointer));
8857 /* Bubble sort the two arrays */
8858 changed = TRUE;
8859 while (changed) {
8860 changed = FALSE;
8861 for (i = 0; i < G_N_ELEMENTS (icall_functions) - 1; ++i) {
8862 if (functions_sorted [i] > functions_sorted [i + 1]) {
8863 gconstpointer tmp;
8864
8865 tmp = functions_sorted [i];
8866 functions_sorted [i] = functions_sorted [i + 1];
8867 functions_sorted [i + 1] = tmp;
8868 tmp = symbols_sorted [i];
8869 symbols_sorted [i] = symbols_sorted [i + 1];
8870 symbols_sorted [i + 1] = tmp;
8871 changed = TRUE;
8872 }
8873 }
8874 }
8875 }
8876
8877 func = mono_lookup_internal_call (m);
8878 if (!func)
8879 return NULL;
8880 slot = mono_binary_search (func, functions_sorted, G_N_ELEMENTS (icall_functions), sizeof (gpointer), func_cmp);
8881 if (!slot)
8882 return NULL;
8883 g_assert (slot);
8884 return symbols_sorted [(gpointer*)slot - (gpointer*)functions_sorted];
8885 #else
8886 fprintf (stderr, "icall symbol maps not enabled, pass --enable-icall-symbol-map to configure.\n");
8887 g_assert_not_reached ();
8888 return 0;
8889 #endif
8890 #endif
8891 }
8892
8893 static MonoType*
8894 type_from_typename (char *type_name)
8895 {
8896 MonoClass *klass = NULL; /* assignment to shut GCC warning up */
8897
8898 if (!strcmp (type_name, "int"))
8899 klass = mono_defaults.int_class;
8900 else if (!strcmp (type_name, "ptr"))
8901 klass = mono_defaults.int_class;
8902 else if (!strcmp (type_name, "void"))
8903 klass = mono_defaults.void_class;
8904 else if (!strcmp (type_name, "int32"))
8905 klass = mono_defaults.int32_class;
8906 else if (!strcmp (type_name, "uint32"))
8907 klass = mono_defaults.uint32_class;
8908 else if (!strcmp (type_name, "int8"))
8909 klass = mono_defaults.sbyte_class;
8910 else if (!strcmp (type_name, "uint8"))
8911 klass = mono_defaults.byte_class;
8912 else if (!strcmp (type_name, "int16"))
8913 klass = mono_defaults.int16_class;
8914 else if (!strcmp (type_name, "uint16"))
8915 klass = mono_defaults.uint16_class;
8916 else if (!strcmp (type_name, "long"))
8917 klass = mono_defaults.int64_class;
8918 else if (!strcmp (type_name, "ulong"))
8919 klass = mono_defaults.uint64_class;
8920 else if (!strcmp (type_name, "float"))
8921 klass = mono_defaults.single_class;
8922 else if (!strcmp (type_name, "double"))
8923 klass = mono_defaults.double_class;
8924 else if (!strcmp (type_name, "object"))
8925 klass = mono_defaults.object_class;
8926 else if (!strcmp (type_name, "obj"))
8927 klass = mono_defaults.object_class;
8928 else if (!strcmp (type_name, "string"))
8929 klass = mono_defaults.string_class;
8930 else if (!strcmp (type_name, "bool"))
8931 klass = mono_defaults.boolean_class;
8932 else if (!strcmp (type_name, "boolean"))
8933 klass = mono_defaults.boolean_class;
8934 else {
8935 g_error ("%s", type_name);
8936 g_assert_not_reached ();
8937 }
8938 return &klass->byval_arg;
8939 }
8940
8941 /**
8942 * LOCKING: Take the corlib image lock.
8943 */
8944 MonoMethodSignature*
8945 mono_create_icall_signature (const char *sigstr)
8946 {
8947 gchar **parts;
8948 int i, len;
8949 gchar **tmp;
8950 MonoMethodSignature *res, *res2;
8951 MonoImage *corlib = mono_defaults.corlib;
8952
8953 mono_image_lock (corlib);
8954 res = (MonoMethodSignature *)g_hash_table_lookup (corlib->helper_signatures, sigstr);
8955 mono_image_unlock (corlib);
8956
8957 if (res)
8958 return res;
8959
8960 parts = g_strsplit (sigstr, " ", 256);
8961
8962 tmp = parts;
8963 len = 0;
8964 while (*tmp) {
8965 len ++;
8966 tmp ++;
8967 }
8968
8969 res = mono_metadata_signature_alloc (corlib, len - 1);
8970 res->pinvoke = 1;
8971
8972 #ifdef HOST_WIN32
8973 /*
8974 * Under windows, the default pinvoke calling convention is STDCALL but
8975 * we need CDECL.
8976 */
8977 res->call_convention = MONO_CALL_C;
8978 #endif
8979
8980 res->ret = type_from_typename (parts [0]);
8981 for (i = 1; i < len; ++i) {
8982 res->params [i - 1] = type_from_typename (parts [i]);
8983 }
8984
8985 g_strfreev (parts);
8986
8987 mono_image_lock (corlib);
8988 res2 = (MonoMethodSignature *)g_hash_table_lookup (corlib->helper_signatures, sigstr);
8989 if (res2)
8990 res = res2; /*Value is allocated in the image pool*/
8991 else
8992 g_hash_table_insert (corlib->helper_signatures, (gpointer)sigstr, res);
8993 mono_image_unlock (corlib);
8994
8995 return res;
8996 }
8997
8998 MonoJitICallInfo *
8999 mono_find_jit_icall_by_name (const char *name)
9000 {
9001 MonoJitICallInfo *info;
9002 g_assert (jit_icall_hash_name);
9003
9004 mono_icall_lock ();
9005 info = (MonoJitICallInfo *)g_hash_table_lookup (jit_icall_hash_name, name);
9006 mono_icall_unlock ();
9007 return info;
9008 }
9009
9010 MonoJitICallInfo *
9011 mono_find_jit_icall_by_addr (gconstpointer addr)
9012 {
9013 MonoJitICallInfo *info;
9014 g_assert (jit_icall_hash_addr);
9015
9016 mono_icall_lock ();
9017 info = (MonoJitICallInfo *)g_hash_table_lookup (jit_icall_hash_addr, (gpointer)addr);
9018 mono_icall_unlock ();
9019
9020 return info;
9021 }
9022
9023 /*
9024 * mono_get_jit_icall_info:
9025 *
9026 * Return the hashtable mapping JIT icall names to MonoJitICallInfo structures. The
9027 * caller should access it while holding the icall lock.
9028 */
9029 GHashTable*
9030 mono_get_jit_icall_info (void)
9031 {
9032 return jit_icall_hash_name;
9033 }
9034
9035 /*
9036 * mono_lookup_jit_icall_symbol:
9037 *
9038 * Given the jit icall NAME, returns its C symbol if possible, or NULL.
9039 */
9040 const char*
9041 mono_lookup_jit_icall_symbol (const char *name)
9042 {
9043 MonoJitICallInfo *info;
9044 const char *res = NULL;
9045
9046 mono_icall_lock ();
9047 info = (MonoJitICallInfo *)g_hash_table_lookup (jit_icall_hash_name, name);
9048 if (info)
9049 res = info->c_symbol;
9050 mono_icall_unlock ();
9051 return res;
9052 }
9053
9054 void
9055 mono_register_jit_icall_wrapper (MonoJitICallInfo *info, gconstpointer wrapper)
9056 {
9057 mono_icall_lock ();
9058 g_hash_table_insert (jit_icall_hash_addr, (gpointer)wrapper, info);
9059 mono_icall_unlock ();
9060 }
9061
9062 /*
9063 * If NO_RAISE is set, that means the icall is not calling mono_raise_exception () directly or indirectly. The JIT might be able to call these
9064 * icalls without wrappers in some cases.
9065 */
9066 MonoJitICallInfo *
9067 mono_register_jit_icall_full (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save, gboolean no_raise, const char *c_symbol)
9068 {
9069 MonoJitICallInfo *info;
9070
9071 g_assert (func);
9072 g_assert (name);
9073
9074 mono_icall_lock ();
9075
9076 if (!jit_icall_hash_name) {
9077 jit_icall_hash_name = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
9078 jit_icall_hash_addr = g_hash_table_new (NULL, NULL);
9079 }
9080
9081 if (g_hash_table_lookup (jit_icall_hash_name, name)) {
9082 g_warning ("jit icall already defined \"%s\"\n", name);
9083 g_assert_not_reached ();
9084 }
9085
9086 info = g_new0 (MonoJitICallInfo, 1);
9087
9088 info->name = name;
9089 info->func = func;
9090 info->sig = sig;
9091 info->c_symbol = c_symbol;
9092 info->no_raise = no_raise;
9093
9094 if (is_save) {
9095 info->wrapper = func;
9096 } else {
9097 info->wrapper = NULL;
9098 }
9099
9100 g_hash_table_insert (jit_icall_hash_name, (gpointer)info->name, info);
9101 g_hash_table_insert (jit_icall_hash_addr, (gpointer)func, info);
9102
9103 mono_icall_unlock ();
9104 return info;
9105 }
9106
9107 MonoJitICallInfo *
9108 mono_register_jit_icall (gconstpointer func, const char *name, MonoMethodSignature *sig, gboolean is_save)
9109 {
9110 return mono_register_jit_icall_full (func, name, sig, is_save, FALSE, NULL);
9111 }
9112
Mirror of the official Mono project git repository