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