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