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