?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-06-11 Zoltan Varga <vargaz@gmail.com>
[mono.git] / mono / metadata / reflection.c
blob1e8fe1234bbcb83da788b143b1ea2386a1298b87
1 /*
2 * reflection.c: Routines for creating an image at runtime.
3 *
4 * Author:
5 * Paolo Molaro (lupus@ximian.com)
6 *
7 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
8 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
9 *
10 */
11 #include <config.h>
12 #include "mono/utils/mono-digest.h"
13 #include "mono/utils/mono-membar.h"
14 #include "mono/metadata/reflection.h"
15 #include "mono/metadata/tabledefs.h"
16 #include "mono/metadata/metadata-internals.h"
17 #include <mono/metadata/profiler-private.h>
18 #include "mono/metadata/class-internals.h"
19 #include "mono/metadata/gc-internal.h"
20 #include "mono/metadata/tokentype.h"
21 #include "mono/metadata/domain-internals.h"
22 #include "mono/metadata/opcodes.h"
23 #include "mono/metadata/assembly.h"
24 #include "mono/metadata/object-internals.h"
25 #include <mono/metadata/exception.h>
26 #include <mono/metadata/marshal.h>
27 #include <mono/metadata/security-manager.h>
28 #include <stdio.h>
29 #include <glib.h>
30 #include <errno.h>
31 #include <time.h>
32 #include <string.h>
33 #include <ctype.h>
34 #include "image.h"
35 #include "cil-coff.h"
36 #include "mono-endian.h"
37 #include <mono/metadata/gc-internal.h>
38 #include <mono/metadata/mempool-internals.h>
39 #include <mono/metadata/security-core-clr.h>
40
41 #if HAVE_SGEN_GC
42 static void* reflection_info_desc = NULL;
43 #define MOVING_GC_REGISTER(addr) do { \
44 if (!reflection_info_desc) { \
45 gsize bmap = 1; \
46 reflection_info_desc = mono_gc_make_descr_from_bitmap (&bmap, 1); \
47 } \
48 mono_gc_register_root ((char*)(addr), sizeof (gpointer), reflection_info_desc); \
49 } while (0)
50 #else
51 #define MOVING_GC_REGISTER(addr)
52 #endif
53
54 typedef struct {
55 char *p;
56 char *buf;
57 char *end;
58 } SigBuffer;
59
60 #define TEXT_OFFSET 512
61 #define CLI_H_SIZE 136
62 #define FILE_ALIGN 512
63 #define VIRT_ALIGN 8192
64 #define START_TEXT_RVA 0x00002000
65
66 typedef struct {
67 MonoReflectionILGen *ilgen;
68 MonoReflectionType *rtype;
69 MonoArray *parameters;
70 MonoArray *generic_params;
71 MonoGenericContainer *generic_container;
72 MonoArray *pinfo;
73 MonoArray *opt_types;
74 guint32 attrs;
75 guint32 iattrs;
76 guint32 call_conv;
77 guint32 *table_idx; /* note: it's a pointer */
78 MonoArray *code;
79 MonoObject *type;
80 MonoString *name;
81 MonoBoolean init_locals;
82 MonoBoolean skip_visibility;
83 MonoArray *return_modreq;
84 MonoArray *return_modopt;
85 MonoArray *param_modreq;
86 MonoArray *param_modopt;
87 MonoArray *permissions;
88 MonoMethod *mhandle;
89 guint32 nrefs;
90 gpointer *refs;
91 /* for PInvoke */
92 int charset, extra_flags, native_cc;
93 MonoString *dll, *dllentry;
94 } ReflectionMethodBuilder;
95
96 typedef struct {
97 guint32 owner;
98 MonoReflectionGenericParam *gparam;
99 } GenericParamTableEntry;
100
101 const unsigned char table_sizes [MONO_TABLE_NUM] = {
102 MONO_MODULE_SIZE,
103 MONO_TYPEREF_SIZE,
104 MONO_TYPEDEF_SIZE,
105 0,
106 MONO_FIELD_SIZE,
107 0,
108 MONO_METHOD_SIZE,
109 0,
110 MONO_PARAM_SIZE,
111 MONO_INTERFACEIMPL_SIZE,
112 MONO_MEMBERREF_SIZE, /* 0x0A */
113 MONO_CONSTANT_SIZE,
114 MONO_CUSTOM_ATTR_SIZE,
115 MONO_FIELD_MARSHAL_SIZE,
116 MONO_DECL_SECURITY_SIZE,
117 MONO_CLASS_LAYOUT_SIZE,
118 MONO_FIELD_LAYOUT_SIZE, /* 0x10 */
119 MONO_STAND_ALONE_SIGNATURE_SIZE,
120 MONO_EVENT_MAP_SIZE,
121 0,
122 MONO_EVENT_SIZE,
123 MONO_PROPERTY_MAP_SIZE,
124 0,
125 MONO_PROPERTY_SIZE,
126 MONO_METHOD_SEMA_SIZE,
127 MONO_METHODIMPL_SIZE,
128 MONO_MODULEREF_SIZE, /* 0x1A */
129 MONO_TYPESPEC_SIZE,
130 MONO_IMPLMAP_SIZE,
131 MONO_FIELD_RVA_SIZE,
132 0,
133 0,
134 MONO_ASSEMBLY_SIZE, /* 0x20 */
135 MONO_ASSEMBLY_PROCESSOR_SIZE,
136 MONO_ASSEMBLYOS_SIZE,
137 MONO_ASSEMBLYREF_SIZE,
138 MONO_ASSEMBLYREFPROC_SIZE,
139 MONO_ASSEMBLYREFOS_SIZE,
140 MONO_FILE_SIZE,
141 MONO_EXP_TYPE_SIZE,
142 MONO_MANIFEST_SIZE,
143 MONO_NESTED_CLASS_SIZE,
144
145 MONO_GENERICPARAM_SIZE, /* 0x2A */
146 MONO_METHODSPEC_SIZE,
147 MONO_GENPARCONSTRAINT_SIZE
148
149 };
150
151 #ifndef DISABLE_REFLECTION_EMIT
152 static guint32 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec);
153 static guint32 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_methodspec);
154 static guint32 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *cb);
155 static guint32 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper);
156 static void ensure_runtime_vtable (MonoClass *klass);
157 static gpointer resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context);
158 static guint32 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method);
159 static guint32 encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context);
160 static gpointer register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly);
161 #endif
162
163 static void reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb);
164 static void reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb);
165 static guint32 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type);
166 static guint32 mono_image_typedef_or_ref_full (MonoDynamicImage *assembly, MonoType *type, gboolean try_typespec);
167 static void mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly);
168 static guint32 encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo);
169 static guint32 encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type);
170 static char* type_get_qualified_name (MonoType *type, MonoAssembly *ass);
171 static void encode_type (MonoDynamicImage *assembly, MonoType *type, SigBuffer *buf);
172 static void get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types);
173 static MonoObject *mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob);
174 static MonoReflectionType *mono_reflection_type_get_underlying_system_type (MonoReflectionType* t);
175 static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve);
176
177 void
178 mono_reflection_init (void)
179 {
180 }
181
182 static void
183 sigbuffer_init (SigBuffer *buf, int size)
184 {
185 buf->buf = g_malloc (size);
186 buf->p = buf->buf;
187 buf->end = buf->buf + size;
188 }
189
190 static void
191 sigbuffer_make_room (SigBuffer *buf, int size)
192 {
193 if (buf->end - buf->p < size) {
194 int new_size = buf->end - buf->buf + size + 32;
195 char *p = g_realloc (buf->buf, new_size);
196 size = buf->p - buf->buf;
197 buf->buf = p;
198 buf->p = p + size;
199 buf->end = buf->buf + new_size;
200 }
201 }
202
203 static void
204 sigbuffer_add_value (SigBuffer *buf, guint32 val)
205 {
206 sigbuffer_make_room (buf, 6);
207 mono_metadata_encode_value (val, buf->p, &buf->p);
208 }
209
210 static void
211 sigbuffer_add_byte (SigBuffer *buf, guint8 val)
212 {
213 sigbuffer_make_room (buf, 1);
214 buf->p [0] = val;
215 buf->p++;
216 }
217
218 static void
219 sigbuffer_add_mem (SigBuffer *buf, char *p, guint32 size)
220 {
221 sigbuffer_make_room (buf, size);
222 memcpy (buf->p, p, size);
223 buf->p += size;
224 }
225
226 static void
227 sigbuffer_free (SigBuffer *buf)
228 {
229 g_free (buf->buf);
230 }
231
232 #ifndef DISABLE_REFLECTION_EMIT
233 /**
234 * mp_g_alloc:
235 *
236 * Allocate memory from the @image mempool if it is non-NULL. Otherwise, allocate memory
237 * from the C heap.
238 */
239 static gpointer
240 image_g_malloc (MonoImage *image, guint size)
241 {
242 if (image)
243 return mono_image_alloc (image, size);
244 else
245 return g_malloc (size);
246 }
247 #endif /* !DISABLE_REFLECTION_EMIT */
248
249 /**
250 * image_g_alloc0:
251 *
252 * Allocate memory from the @image mempool if it is non-NULL. Otherwise, allocate memory
253 * from the C heap.
254 */
255 static gpointer
256 image_g_malloc0 (MonoImage *image, guint size)
257 {
258 if (image)
259 return mono_image_alloc0 (image, size);
260 else
261 return g_malloc0 (size);
262 }
263
264 #ifndef DISABLE_REFLECTION_EMIT
265 static char*
266 image_strdup (MonoImage *image, const char *s)
267 {
268 if (image)
269 return mono_image_strdup (image, s);
270 else
271 return g_strdup (s);
272 }
273 #endif
274
275 #define image_g_new(image,struct_type, n_structs) \
276 ((struct_type *) image_g_malloc (image, ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
277
278 #define image_g_new0(image,struct_type, n_structs) \
279 ((struct_type *) image_g_malloc0 (image, ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
280
281
282 static void
283 alloc_table (MonoDynamicTable *table, guint nrows)
284 {
285 table->rows = nrows;
286 g_assert (table->columns);
287 if (nrows + 1 >= table->alloc_rows) {
288 while (nrows + 1 >= table->alloc_rows) {
289 if (table->alloc_rows == 0)
290 table->alloc_rows = 16;
291 else
292 table->alloc_rows *= 2;
293 }
294
295 table->values = g_renew (guint32, table->values, (table->alloc_rows) * table->columns);
296 }
297 }
298
299 static void
300 make_room_in_stream (MonoDynamicStream *stream, int size)
301 {
302 if (size <= stream->alloc_size)
303 return;
304
305 while (stream->alloc_size <= size) {
306 if (stream->alloc_size < 4096)
307 stream->alloc_size = 4096;
308 else
309 stream->alloc_size *= 2;
310 }
311
312 stream->data = g_realloc (stream->data, stream->alloc_size);
313 }
314
315 static guint32
316 string_heap_insert (MonoDynamicStream *sh, const char *str)
317 {
318 guint32 idx;
319 guint32 len;
320 gpointer oldkey, oldval;
321
322 if (g_hash_table_lookup_extended (sh->hash, str, &oldkey, &oldval))
323 return GPOINTER_TO_UINT (oldval);
324
325 len = strlen (str) + 1;
326 idx = sh->index;
327
328 make_room_in_stream (sh, idx + len);
329
330 /*
331 * We strdup the string even if we already copy them in sh->data
332 * so that the string pointers in the hash remain valid even if
333 * we need to realloc sh->data. We may want to avoid that later.
334 */
335 g_hash_table_insert (sh->hash, g_strdup (str), GUINT_TO_POINTER (idx));
336 memcpy (sh->data + idx, str, len);
337 sh->index += len;
338 return idx;
339 }
340
341 static guint32
342 string_heap_insert_mstring (MonoDynamicStream *sh, MonoString *str)
343 {
344 char *name = mono_string_to_utf8 (str);
345 guint32 idx;
346 idx = string_heap_insert (sh, name);
347 g_free (name);
348 return idx;
349 }
350
351 #ifndef DISABLE_REFLECTION_EMIT
352 static void
353 string_heap_init (MonoDynamicStream *sh)
354 {
355 sh->index = 0;
356 sh->alloc_size = 4096;
357 sh->data = g_malloc (4096);
358 sh->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
359 string_heap_insert (sh, "");
360 }
361 #endif
362
363 static guint32
364 mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
365 {
366 guint32 idx;
367
368 make_room_in_stream (stream, stream->index + len);
369 memcpy (stream->data + stream->index, data, len);
370 idx = stream->index;
371 stream->index += len;
372 /*
373 * align index? Not without adding an additional param that controls it since
374 * we may store a blob value in pieces.
375 */
376 return idx;
377 }
378
379 static guint32
380 mono_image_add_stream_zero (MonoDynamicStream *stream, guint32 len)
381 {
382 guint32 idx;
383
384 make_room_in_stream (stream, stream->index + len);
385 memset (stream->data + stream->index, 0, len);
386 idx = stream->index;
387 stream->index += len;
388 return idx;
389 }
390
391 static void
392 stream_data_align (MonoDynamicStream *stream)
393 {
394 char buf [4] = {0};
395 guint32 count = stream->index % 4;
396
397 /* we assume the stream data will be aligned */
398 if (count)
399 mono_image_add_stream_data (stream, buf, 4 - count);
400 }
401
402 #ifndef DISABLE_REFLECTION_EMIT
403 static int
404 mono_blob_entry_hash (const char* str)
405 {
406 guint len, h;
407 const char *end;
408 len = mono_metadata_decode_blob_size (str, &str);
409 if (len > 0) {
410 end = str + len;
411 h = *str;
412 for (str += 1; str < end; str++)
413 h = (h << 5) - h + *str;
414 return h;
415 } else {
416 return 0;
417 }
418 }
419
420 static gboolean
421 mono_blob_entry_equal (const char *str1, const char *str2) {
422 int len, len2;
423 const char *end1;
424 const char *end2;
425 len = mono_metadata_decode_blob_size (str1, &end1);
426 len2 = mono_metadata_decode_blob_size (str2, &end2);
427 if (len != len2)
428 return 0;
429 return memcmp (end1, end2, len) == 0;
430 }
431 #endif
432 static guint32
433 add_to_blob_cached (MonoDynamicImage *assembly, char *b1, int s1, char *b2, int s2)
434 {
435 guint32 idx;
436 char *copy;
437 gpointer oldkey, oldval;
438
439 copy = g_malloc (s1+s2);
440 memcpy (copy, b1, s1);
441 memcpy (copy + s1, b2, s2);
442 if (g_hash_table_lookup_extended (assembly->blob_cache, copy, &oldkey, &oldval)) {
443 g_free (copy);
444 idx = GPOINTER_TO_UINT (oldval);
445 } else {
446 idx = mono_image_add_stream_data (&assembly->blob, b1, s1);
447 mono_image_add_stream_data (&assembly->blob, b2, s2);
448 g_hash_table_insert (assembly->blob_cache, copy, GUINT_TO_POINTER (idx));
449 }
450 return idx;
451 }
452
453 static guint32
454 sigbuffer_add_to_blob_cached (MonoDynamicImage *assembly, SigBuffer *buf)
455 {
456 char blob_size [8];
457 char *b = blob_size;
458 guint32 size = buf->p - buf->buf;
459 /* store length */
460 g_assert (size <= (buf->end - buf->buf));
461 mono_metadata_encode_value (size, b, &b);
462 return add_to_blob_cached (assembly, blob_size, b-blob_size, buf->buf, size);
463 }
464
465 /*
466 * Copy len * nelem bytes from val to dest, swapping bytes to LE if necessary.
467 * dest may be misaligned.
468 */
469 static void
470 swap_with_size (char *dest, const char* val, int len, int nelem) {
471 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
472 int elem;
473
474 for (elem = 0; elem < nelem; ++elem) {
475 switch (len) {
476 case 1:
477 *dest = *val;
478 break;
479 case 2:
480 dest [0] = val [1];
481 dest [1] = val [0];
482 break;
483 case 4:
484 dest [0] = val [3];
485 dest [1] = val [2];
486 dest [2] = val [1];
487 dest [3] = val [0];
488 break;
489 case 8:
490 dest [0] = val [7];
491 dest [1] = val [6];
492 dest [2] = val [5];
493 dest [3] = val [4];
494 dest [4] = val [3];
495 dest [5] = val [2];
496 dest [6] = val [1];
497 dest [7] = val [0];
498 break;
499 default:
500 g_assert_not_reached ();
501 }
502 dest += len;
503 val += len;
504 }
505 #else
506 memcpy (dest, val, len * nelem);
507 #endif
508 }
509
510 static guint32
511 add_mono_string_to_blob_cached (MonoDynamicImage *assembly, MonoString *str)
512 {
513 char blob_size [64];
514 char *b = blob_size;
515 guint32 idx = 0, len;
516
517 len = str->length * 2;
518 mono_metadata_encode_value (len, b, &b);
519 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
520 {
521 char *swapped = g_malloc (2 * mono_string_length (str));
522 const char *p = (const char*)mono_string_chars (str);
523
524 swap_with_size (swapped, p, 2, mono_string_length (str));
525 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, swapped, len);
526 g_free (swapped);
527 }
528 #else
529 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, (char*)mono_string_chars (str), len);
530 #endif
531 return idx;
532 }
533
534 #ifndef DISABLE_REFLECTION_EMIT
535 static MonoClass *
536 default_class_from_mono_type (MonoType *type)
537 {
538 switch (type->type) {
539 case MONO_TYPE_OBJECT:
540 return mono_defaults.object_class;
541 case MONO_TYPE_VOID:
542 return mono_defaults.void_class;
543 case MONO_TYPE_BOOLEAN:
544 return mono_defaults.boolean_class;
545 case MONO_TYPE_CHAR:
546 return mono_defaults.char_class;
547 case MONO_TYPE_I1:
548 return mono_defaults.sbyte_class;
549 case MONO_TYPE_U1:
550 return mono_defaults.byte_class;
551 case MONO_TYPE_I2:
552 return mono_defaults.int16_class;
553 case MONO_TYPE_U2:
554 return mono_defaults.uint16_class;
555 case MONO_TYPE_I4:
556 return mono_defaults.int32_class;
557 case MONO_TYPE_U4:
558 return mono_defaults.uint32_class;
559 case MONO_TYPE_I:
560 return mono_defaults.int_class;
561 case MONO_TYPE_U:
562 return mono_defaults.uint_class;
563 case MONO_TYPE_I8:
564 return mono_defaults.int64_class;
565 case MONO_TYPE_U8:
566 return mono_defaults.uint64_class;
567 case MONO_TYPE_R4:
568 return mono_defaults.single_class;
569 case MONO_TYPE_R8:
570 return mono_defaults.double_class;
571 case MONO_TYPE_STRING:
572 return mono_defaults.string_class;
573 default:
574 g_warning ("default_class_from_mono_type: implement me 0x%02x\n", type->type);
575 g_assert_not_reached ();
576 }
577
578 return NULL;
579 }
580 #endif
581
582 static void
583 encode_generic_class (MonoDynamicImage *assembly, MonoGenericClass *gclass, SigBuffer *buf)
584 {
585 int i;
586 MonoGenericInst *class_inst;
587 MonoClass *klass;
588
589 g_assert (gclass);
590
591 class_inst = gclass->context.class_inst;
592
593 sigbuffer_add_value (buf, MONO_TYPE_GENERICINST);
594 klass = gclass->container_class;
595 sigbuffer_add_value (buf, klass->byval_arg.type);
596 sigbuffer_add_value (buf, mono_image_typedef_or_ref_full (assembly, &klass->byval_arg, FALSE));
597
598 sigbuffer_add_value (buf, class_inst->type_argc);
599 for (i = 0; i < class_inst->type_argc; ++i)
600 encode_type (assembly, class_inst->type_argv [i], buf);
601
602 }
603
604 static void
605 encode_type (MonoDynamicImage *assembly, MonoType *type, SigBuffer *buf)
606 {
607 if (!type) {
608 g_assert_not_reached ();
609 return;
610 }
611
612 if (type->byref)
613 sigbuffer_add_value (buf, MONO_TYPE_BYREF);
614
615 switch (type->type){
616 case MONO_TYPE_VOID:
617 case MONO_TYPE_BOOLEAN:
618 case MONO_TYPE_CHAR:
619 case MONO_TYPE_I1:
620 case MONO_TYPE_U1:
621 case MONO_TYPE_I2:
622 case MONO_TYPE_U2:
623 case MONO_TYPE_I4:
624 case MONO_TYPE_U4:
625 case MONO_TYPE_I8:
626 case MONO_TYPE_U8:
627 case MONO_TYPE_R4:
628 case MONO_TYPE_R8:
629 case MONO_TYPE_I:
630 case MONO_TYPE_U:
631 case MONO_TYPE_STRING:
632 case MONO_TYPE_OBJECT:
633 case MONO_TYPE_TYPEDBYREF:
634 sigbuffer_add_value (buf, type->type);
635 break;
636 case MONO_TYPE_PTR:
637 sigbuffer_add_value (buf, type->type);
638 encode_type (assembly, type->data.type, buf);
639 break;
640 case MONO_TYPE_SZARRAY:
641 sigbuffer_add_value (buf, type->type);
642 encode_type (assembly, &type->data.klass->byval_arg, buf);
643 break;
644 case MONO_TYPE_VALUETYPE:
645 case MONO_TYPE_CLASS: {
646 MonoClass *k = mono_class_from_mono_type (type);
647
648 if (k->generic_container) {
649 MonoGenericClass *gclass = mono_metadata_lookup_generic_class (k, k->generic_container->context.class_inst, TRUE);
650 encode_generic_class (assembly, gclass, buf);
651 } else {
652 /*
653 * Make sure we use the correct type.
654 */
655 sigbuffer_add_value (buf, k->byval_arg.type);
656 /*
657 * ensure only non-byref gets passed to mono_image_typedef_or_ref(),
658 * otherwise two typerefs could point to the same type, leading to
659 * verification errors.
660 */
661 sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, &k->byval_arg));
662 }
663 break;
664 }
665 case MONO_TYPE_ARRAY:
666 sigbuffer_add_value (buf, type->type);
667 encode_type (assembly, &type->data.array->eklass->byval_arg, buf);
668 sigbuffer_add_value (buf, type->data.array->rank);
669 sigbuffer_add_value (buf, 0); /* FIXME: set to 0 for now */
670 sigbuffer_add_value (buf, 0);
671 break;
672 case MONO_TYPE_GENERICINST:
673 encode_generic_class (assembly, type->data.generic_class, buf);
674 break;
675 case MONO_TYPE_VAR:
676 case MONO_TYPE_MVAR:
677 sigbuffer_add_value (buf, type->type);
678 sigbuffer_add_value (buf, mono_type_get_generic_param_num (type));
679 break;
680 default:
681 g_error ("need to encode type %x", type->type);
682 }
683 }
684
685 static void
686 encode_reflection_type (MonoDynamicImage *assembly, MonoReflectionType *type, SigBuffer *buf)
687 {
688 if (!type) {
689 sigbuffer_add_value (buf, MONO_TYPE_VOID);
690 return;
691 }
692
693 if (type->type ||
694 ((type = mono_reflection_type_get_underlying_system_type (type)) && type->type)) {
695 encode_type (assembly, type->type, buf);
696 return;
697 }
698
699 g_assert_not_reached ();
700
701 }
702
703 static void
704 encode_custom_modifiers (MonoDynamicImage *assembly, MonoArray *modreq, MonoArray *modopt, SigBuffer *buf)
705 {
706 int i;
707
708 if (modreq) {
709 for (i = 0; i < mono_array_length (modreq); ++i) {
710 MonoReflectionType *mod = mono_type_array_get (modreq, i);
711 sigbuffer_add_byte (buf, MONO_TYPE_CMOD_REQD);
712 sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, mod->type));
713 }
714 }
715 if (modopt) {
716 for (i = 0; i < mono_array_length (modopt); ++i) {
717 MonoReflectionType *mod = mono_type_array_get (modopt, i);
718 sigbuffer_add_byte (buf, MONO_TYPE_CMOD_OPT);
719 sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, mod->type));
720 }
721 }
722 }
723
724 #ifndef DISABLE_REFLECTION_EMIT
725 static guint32
726 method_encode_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig)
727 {
728 SigBuffer buf;
729 int i;
730 guint32 nparams = sig->param_count;
731 guint32 idx;
732
733 if (!assembly->save)
734 return 0;
735
736 sigbuffer_init (&buf, 32);
737 /*
738 * FIXME: vararg, explicit_this, differenc call_conv values...
739 */
740 idx = sig->call_convention;
741 if (sig->hasthis)
742 idx |= 0x20; /* hasthis */
743 if (sig->generic_param_count)
744 idx |= 0x10; /* generic */
745 sigbuffer_add_byte (&buf, idx);
746 if (sig->generic_param_count)
747 sigbuffer_add_value (&buf, sig->generic_param_count);
748 sigbuffer_add_value (&buf, nparams);
749 encode_type (assembly, sig->ret, &buf);
750 for (i = 0; i < nparams; ++i) {
751 if (i == sig->sentinelpos)
752 sigbuffer_add_byte (&buf, MONO_TYPE_SENTINEL);
753 encode_type (assembly, sig->params [i], &buf);
754 }
755 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
756 sigbuffer_free (&buf);
757 return idx;
758 }
759 #endif
760
761 static guint32
762 method_builder_encode_signature (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
763 {
764 /*
765 * FIXME: reuse code from method_encode_signature().
766 */
767 SigBuffer buf;
768 int i;
769 guint32 nparams = mb->parameters ? mono_array_length (mb->parameters): 0;
770 guint32 ngparams = mb->generic_params ? mono_array_length (mb->generic_params): 0;
771 guint32 notypes = mb->opt_types ? mono_array_length (mb->opt_types): 0;
772 guint32 idx;
773
774 sigbuffer_init (&buf, 32);
775 /* LAMESPEC: all the call conv spec is foobared */
776 idx = mb->call_conv & 0x60; /* has-this, explicit-this */
777 if (mb->call_conv & 2)
778 idx |= 0x5; /* vararg */
779 if (!(mb->attrs & METHOD_ATTRIBUTE_STATIC))
780 idx |= 0x20; /* hasthis */
781 if (ngparams)
782 idx |= 0x10; /* generic */
783 sigbuffer_add_byte (&buf, idx);
784 if (ngparams)
785 sigbuffer_add_value (&buf, ngparams);
786 sigbuffer_add_value (&buf, nparams + notypes);
787 encode_custom_modifiers (assembly, mb->return_modreq, mb->return_modopt, &buf);
788 encode_reflection_type (assembly, mb->rtype, &buf);
789 for (i = 0; i < nparams; ++i) {
790 MonoArray *modreq = NULL;
791 MonoArray *modopt = NULL;
792 MonoReflectionType *pt;
793
794 if (mb->param_modreq && (i < mono_array_length (mb->param_modreq)))
795 modreq = mono_array_get (mb->param_modreq, MonoArray*, i);
796 if (mb->param_modopt && (i < mono_array_length (mb->param_modopt)))
797 modopt = mono_array_get (mb->param_modopt, MonoArray*, i);
798 encode_custom_modifiers (assembly, modreq, modopt, &buf);
799 pt = mono_type_array_get (mb->parameters, i);
800 encode_reflection_type (assembly, pt, &buf);
801 }
802 if (notypes)
803 sigbuffer_add_byte (&buf, MONO_TYPE_SENTINEL);
804 for (i = 0; i < notypes; ++i) {
805 MonoReflectionType *pt;
806
807 pt = mono_type_array_get (mb->opt_types, i);
808 encode_reflection_type (assembly, pt, &buf);
809 }
810
811 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
812 sigbuffer_free (&buf);
813 return idx;
814 }
815
816 static guint32
817 encode_locals (MonoDynamicImage *assembly, MonoReflectionILGen *ilgen)
818 {
819 MonoDynamicTable *table;
820 guint32 *values;
821 guint32 idx, sig_idx;
822 guint nl = mono_array_length (ilgen->locals);
823 SigBuffer buf;
824 int i;
825
826 sigbuffer_init (&buf, 32);
827 sigbuffer_add_value (&buf, 0x07);
828 sigbuffer_add_value (&buf, nl);
829 for (i = 0; i < nl; ++i) {
830 MonoReflectionLocalBuilder *lb = mono_array_get (ilgen->locals, MonoReflectionLocalBuilder*, i);
831
832 if (lb->is_pinned)
833 sigbuffer_add_value (&buf, MONO_TYPE_PINNED);
834
835 encode_reflection_type (assembly, monotype_cast (lb->type), &buf);
836 }
837 sig_idx = sigbuffer_add_to_blob_cached (assembly, &buf);
838 sigbuffer_free (&buf);
839
840 if (assembly->standalonesig_cache == NULL)
841 assembly->standalonesig_cache = g_hash_table_new (NULL, NULL);
842 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->standalonesig_cache, GUINT_TO_POINTER (sig_idx)));
843 if (idx)
844 return idx;
845
846 table = &assembly->tables [MONO_TABLE_STANDALONESIG];
847 idx = table->next_idx ++;
848 table->rows ++;
849 alloc_table (table, table->rows);
850 values = table->values + idx * MONO_STAND_ALONE_SIGNATURE_SIZE;
851
852 values [MONO_STAND_ALONE_SIGNATURE] = sig_idx;
853
854 g_hash_table_insert (assembly->standalonesig_cache, GUINT_TO_POINTER (sig_idx), GUINT_TO_POINTER (idx));
855
856 return idx;
857 }
858
859 static guint32
860 method_count_clauses (MonoReflectionILGen *ilgen)
861 {
862 guint32 num_clauses = 0;
863 int i;
864
865 MonoILExceptionInfo *ex_info;
866 for (i = 0; i < mono_array_length (ilgen->ex_handlers); ++i) {
867 ex_info = (MonoILExceptionInfo*)mono_array_addr (ilgen->ex_handlers, MonoILExceptionInfo, i);
868 if (ex_info->handlers)
869 num_clauses += mono_array_length (ex_info->handlers);
870 else
871 num_clauses++;
872 }
873
874 return num_clauses;
875 }
876
877 #ifndef DISABLE_REFLECTION_EMIT
878 static MonoExceptionClause*
879 method_encode_clauses (MonoImage *image, MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, guint32 num_clauses)
880 {
881 MonoExceptionClause *clauses;
882 MonoExceptionClause *clause;
883 MonoILExceptionInfo *ex_info;
884 MonoILExceptionBlock *ex_block;
885 guint32 finally_start;
886 int i, j, clause_index;;
887
888 clauses = image_g_new0 (image, MonoExceptionClause, num_clauses);
889
890 clause_index = 0;
891 for (i = mono_array_length (ilgen->ex_handlers) - 1; i >= 0; --i) {
892 ex_info = (MonoILExceptionInfo*)mono_array_addr (ilgen->ex_handlers, MonoILExceptionInfo, i);
893 finally_start = ex_info->start + ex_info->len;
894 if (!ex_info->handlers)
895 continue;
896 for (j = 0; j < mono_array_length (ex_info->handlers); ++j) {
897 ex_block = (MonoILExceptionBlock*)mono_array_addr (ex_info->handlers, MonoILExceptionBlock, j);
898 clause = &(clauses [clause_index]);
899
900 clause->flags = ex_block->type;
901 clause->try_offset = ex_info->start;
902
903 if (ex_block->type == MONO_EXCEPTION_CLAUSE_FINALLY)
904 clause->try_len = finally_start - ex_info->start;
905 else
906 clause->try_len = ex_info->len;
907 clause->handler_offset = ex_block->start;
908 clause->handler_len = ex_block->len;
909 if (ex_block->extype) {
910 clause->data.catch_class = mono_class_from_mono_type (monotype_cast (ex_block->extype)->type);
911 } else {
912 if (ex_block->type == MONO_EXCEPTION_CLAUSE_FILTER)
913 clause->data.filter_offset = ex_block->filter_offset;
914 else
915 clause->data.filter_offset = 0;
916 }
917 finally_start = ex_block->start + ex_block->len;
918
919 clause_index ++;
920 }
921 }
922
923 return clauses;
924 }
925 #endif /* !DISABLE_REFLECTION_EMIT */
926
927 static guint32
928 method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
929 {
930 char flags = 0;
931 guint32 idx;
932 guint32 code_size;
933 gint32 max_stack, i;
934 gint32 num_locals = 0;
935 gint32 num_exception = 0;
936 gint maybe_small;
937 guint32 fat_flags;
938 char fat_header [12];
939 guint32 int_value;
940 guint16 short_value;
941 guint32 local_sig = 0;
942 guint32 header_size = 12;
943 MonoArray *code;
944
945 if ((mb->attrs & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT)) ||
946 (mb->iattrs & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)))
947 return 0;
948
949 /*if (mb->name)
950 g_print ("Encode method %s\n", mono_string_to_utf8 (mb->name));*/
951 if (mb->ilgen) {
952 code = mb->ilgen->code;
953 code_size = mb->ilgen->code_len;
954 max_stack = mb->ilgen->max_stack;
955 num_locals = mb->ilgen->locals ? mono_array_length (mb->ilgen->locals) : 0;
956 if (mb->ilgen->ex_handlers)
957 num_exception = method_count_clauses (mb->ilgen);
958 } else {
959 code = mb->code;
960 if (code == NULL){
961 char *name = mono_string_to_utf8 (mb->name);
962 char *str = g_strdup_printf ("Method %s does not have any IL associated", name);
963 MonoException *exception = mono_get_exception_argument (NULL, "a method does not have any IL associated");
964 g_free (str);
965 g_free (name);
966 mono_raise_exception (exception);
967 }
968
969 code_size = mono_array_length (code);
970 max_stack = 8; /* we probably need to run a verifier on the code... */
971 }
972
973 stream_data_align (&assembly->code);
974
975 /* check for exceptions, maxstack, locals */
976 maybe_small = (max_stack <= 8) && (!num_locals) && (!num_exception);
977 if (maybe_small) {
978 if (code_size < 64 && !(code_size & 1)) {
979 flags = (code_size << 2) | 0x2;
980 } else if (code_size < 32 && (code_size & 1)) {
981 flags = (code_size << 2) | 0x6; /* LAMESPEC: see metadata.c */
982 } else {
983 goto fat_header;
984 }
985 idx = mono_image_add_stream_data (&assembly->code, &flags, 1);
986 /* add to the fixup todo list */
987 if (mb->ilgen && mb->ilgen->num_token_fixups)
988 mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 1));
989 mono_image_add_stream_data (&assembly->code, mono_array_addr (code, char, 0), code_size);
990 return assembly->text_rva + idx;
991 }
992 fat_header:
993 if (num_locals)
994 local_sig = MONO_TOKEN_SIGNATURE | encode_locals (assembly, mb->ilgen);
995 /*
996 * FIXME: need to set also the header size in fat_flags.
997 * (and more sects and init locals flags)
998 */
999 fat_flags = 0x03;
1000 if (num_exception)
1001 fat_flags |= METHOD_HEADER_MORE_SECTS;
1002 if (mb->init_locals)
1003 fat_flags |= METHOD_HEADER_INIT_LOCALS;
1004 fat_header [0] = fat_flags;
1005 fat_header [1] = (header_size / 4 ) << 4;
1006 short_value = GUINT16_TO_LE (max_stack);
1007 memcpy (fat_header + 2, &short_value, 2);
1008 int_value = GUINT32_TO_LE (code_size);
1009 memcpy (fat_header + 4, &int_value, 4);
1010 int_value = GUINT32_TO_LE (local_sig);
1011 memcpy (fat_header + 8, &int_value, 4);
1012 idx = mono_image_add_stream_data (&assembly->code, fat_header, 12);
1013 /* add to the fixup todo list */
1014 if (mb->ilgen && mb->ilgen->num_token_fixups)
1015 mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 12));
1016
1017 mono_image_add_stream_data (&assembly->code, mono_array_addr (code, char, 0), code_size);
1018 if (num_exception) {
1019 unsigned char sheader [4];
1020 MonoILExceptionInfo * ex_info;
1021 MonoILExceptionBlock * ex_block;
1022 int j;
1023
1024 stream_data_align (&assembly->code);
1025 /* always use fat format for now */
1026 sheader [0] = METHOD_HEADER_SECTION_FAT_FORMAT | METHOD_HEADER_SECTION_EHTABLE;
1027 num_exception *= 6 * sizeof (guint32);
1028 num_exception += 4; /* include the size of the header */
1029 sheader [1] = num_exception & 0xff;
1030 sheader [2] = (num_exception >> 8) & 0xff;
1031 sheader [3] = (num_exception >> 16) & 0xff;
1032 mono_image_add_stream_data (&assembly->code, (char*)sheader, 4);
1033 /* fat header, so we are already aligned */
1034 /* reverse order */
1035 for (i = mono_array_length (mb->ilgen->ex_handlers) - 1; i >= 0; --i) {
1036 ex_info = (MonoILExceptionInfo *)mono_array_addr (mb->ilgen->ex_handlers, MonoILExceptionInfo, i);
1037 if (ex_info->handlers) {
1038 int finally_start = ex_info->start + ex_info->len;
1039 for (j = 0; j < mono_array_length (ex_info->handlers); ++j) {
1040 guint32 val;
1041 ex_block = (MonoILExceptionBlock*)mono_array_addr (ex_info->handlers, MonoILExceptionBlock, j);
1042 /* the flags */
1043 val = GUINT32_TO_LE (ex_block->type);
1044 mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1045 /* try offset */
1046 val = GUINT32_TO_LE (ex_info->start);
1047 mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1048 /* need fault, too, probably */
1049 if (ex_block->type == MONO_EXCEPTION_CLAUSE_FINALLY)
1050 val = GUINT32_TO_LE (finally_start - ex_info->start);
1051 else
1052 val = GUINT32_TO_LE (ex_info->len);
1053 mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1054 /* handler offset */
1055 val = GUINT32_TO_LE (ex_block->start);
1056 mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1057 /* handler len */
1058 val = GUINT32_TO_LE (ex_block->len);
1059 mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1060 finally_start = ex_block->start + ex_block->len;
1061 if (ex_block->extype) {
1062 val = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, monotype_cast (ex_block->extype)->type));
1063 } else {
1064 if (ex_block->type == MONO_EXCEPTION_CLAUSE_FILTER)
1065 val = ex_block->filter_offset;
1066 else
1067 val = 0;
1068 }
1069 val = GUINT32_TO_LE (val);
1070 mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1071 /*g_print ("out clause %d: from %d len=%d, handler at %d, %d, finally_start=%d, ex_info->start=%d, ex_info->len=%d, ex_block->type=%d, j=%d, i=%d\n",
1072 clause.flags, clause.try_offset, clause.try_len, clause.handler_offset, clause.handler_len, finally_start, ex_info->start, ex_info->len, ex_block->type, j, i);*/
1073 }
1074 } else {
1075 g_error ("No clauses for ex info block %d", i);
1076 }
1077 }
1078 }
1079 return assembly->text_rva + idx;
1080 }
1081
1082 static guint32
1083 find_index_in_table (MonoDynamicImage *assembly, int table_idx, int col, guint32 token)
1084 {
1085 int i;
1086 MonoDynamicTable *table;
1087 guint32 *values;
1088
1089 table = &assembly->tables [table_idx];
1090
1091 g_assert (col < table->columns);
1092
1093 values = table->values + table->columns;
1094 for (i = 1; i <= table->rows; ++i) {
1095 if (values [col] == token)
1096 return i;
1097 values += table->columns;
1098 }
1099 return 0;
1100 }
1101
1102 /*
1103 * LOCKING: Acquires the loader lock.
1104 */
1105 static MonoCustomAttrInfo*
1106 lookup_custom_attr (MonoImage *image, gpointer member)
1107 {
1108 MonoCustomAttrInfo* res;
1109
1110 res = mono_image_property_lookup (image, member, MONO_PROP_DYNAMIC_CATTR);
1111
1112 if (!res)
1113 return NULL;
1114
1115 return g_memdup (res, sizeof (MonoCustomAttrInfo) + sizeof (MonoCustomAttrEntry) * (res->num_attrs - MONO_ZERO_LEN_ARRAY));
1116 }
1117
1118 static gboolean
1119 custom_attr_visible (MonoImage *image, MonoReflectionCustomAttr *cattr)
1120 {
1121 /* FIXME: Need to do more checks */
1122 if (cattr->ctor->method && (cattr->ctor->method->klass->image != image)) {
1123 int visibility = cattr->ctor->method->klass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
1124
1125 if ((visibility != TYPE_ATTRIBUTE_PUBLIC) && (visibility != TYPE_ATTRIBUTE_NESTED_PUBLIC))
1126 return FALSE;
1127 }
1128
1129 return TRUE;
1130 }
1131
1132 static MonoCustomAttrInfo*
1133 mono_custom_attrs_from_builders (MonoImage *alloc_img, MonoImage *image, MonoArray *cattrs)
1134 {
1135 int i, index, count, not_visible;
1136 MonoCustomAttrInfo *ainfo;
1137 MonoReflectionCustomAttr *cattr;
1138
1139 if (!cattrs)
1140 return NULL;
1141 /* FIXME: check in assembly the Run flag is set */
1142
1143 count = mono_array_length (cattrs);
1144
1145 /* Skip nonpublic attributes since MS.NET seems to do the same */
1146 /* FIXME: This needs to be done more globally */
1147 not_visible = 0;
1148 for (i = 0; i < count; ++i) {
1149 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
1150 if (!custom_attr_visible (image, cattr))
1151 not_visible ++;
1152 }
1153 count -= not_visible;
1154
1155 ainfo = image_g_malloc0 (alloc_img, sizeof (MonoCustomAttrInfo) + sizeof (MonoCustomAttrEntry) * (count - MONO_ZERO_LEN_ARRAY));
1156
1157 ainfo->image = image;
1158 ainfo->num_attrs = count;
1159 ainfo->cached = alloc_img != NULL;
1160 index = 0;
1161 for (i = 0; i < count; ++i) {
1162 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
1163 if (custom_attr_visible (image, cattr)) {
1164 unsigned char *saved = mono_image_alloc (image, mono_array_length (cattr->data));
1165 memcpy (saved, mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
1166 ainfo->attrs [index].ctor = cattr->ctor->method;
1167 ainfo->attrs [index].data = saved;
1168 ainfo->attrs [index].data_size = mono_array_length (cattr->data);
1169 index ++;
1170 }
1171 }
1172
1173 return ainfo;
1174 }
1175
1176 #ifndef DISABLE_REFLECTION_EMIT
1177 /*
1178 * LOCKING: Acquires the loader lock.
1179 */
1180 static void
1181 mono_save_custom_attrs (MonoImage *image, void *obj, MonoArray *cattrs)
1182 {
1183 MonoCustomAttrInfo *ainfo, *tmp;
1184
1185 if (!cattrs || !mono_array_length (cattrs))
1186 return;
1187
1188 ainfo = mono_custom_attrs_from_builders (image, image, cattrs);
1189
1190 mono_loader_lock ();
1191 tmp = mono_image_property_lookup (image, obj, MONO_PROP_DYNAMIC_CATTR);
1192 if (tmp)
1193 mono_custom_attrs_free (tmp);
1194 mono_image_property_insert (image, obj, MONO_PROP_DYNAMIC_CATTR, ainfo);
1195 mono_loader_unlock ();
1196
1197 }
1198 #endif
1199
1200 void
1201 mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
1202 {
1203 if (!ainfo->cached)
1204 g_free (ainfo);
1205 }
1206
1207 /*
1208 * idx is the table index of the object
1209 * type is one of MONO_CUSTOM_ATTR_*
1210 */
1211 static void
1212 mono_image_add_cattrs (MonoDynamicImage *assembly, guint32 idx, guint32 type, MonoArray *cattrs)
1213 {
1214 MonoDynamicTable *table;
1215 MonoReflectionCustomAttr *cattr;
1216 guint32 *values;
1217 guint32 count, i, token;
1218 char blob_size [6];
1219 char *p = blob_size;
1220
1221 /* it is legal to pass a NULL cattrs: we avoid to use the if in a lot of places */
1222 if (!cattrs)
1223 return;
1224 count = mono_array_length (cattrs);
1225 table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1226 table->rows += count;
1227 alloc_table (table, table->rows);
1228 values = table->values + table->next_idx * MONO_CUSTOM_ATTR_SIZE;
1229 idx <<= MONO_CUSTOM_ATTR_BITS;
1230 idx |= type;
1231 for (i = 0; i < count; ++i) {
1232 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
1233 values [MONO_CUSTOM_ATTR_PARENT] = idx;
1234 token = mono_image_create_token (assembly, (MonoObject*)cattr->ctor, FALSE, FALSE);
1235 type = mono_metadata_token_index (token);
1236 type <<= MONO_CUSTOM_ATTR_TYPE_BITS;
1237 switch (mono_metadata_token_table (token)) {
1238 case MONO_TABLE_METHOD:
1239 type |= MONO_CUSTOM_ATTR_TYPE_METHODDEF;
1240 break;
1241 case MONO_TABLE_MEMBERREF:
1242 type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
1243 break;
1244 default:
1245 g_warning ("got wrong token in custom attr");
1246 continue;
1247 }
1248 values [MONO_CUSTOM_ATTR_TYPE] = type;
1249 p = blob_size;
1250 mono_metadata_encode_value (mono_array_length (cattr->data), p, &p);
1251 values [MONO_CUSTOM_ATTR_VALUE] = add_to_blob_cached (assembly, blob_size, p - blob_size,
1252 mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
1253 values += MONO_CUSTOM_ATTR_SIZE;
1254 ++table->next_idx;
1255 }
1256 }
1257
1258 static void
1259 mono_image_add_decl_security (MonoDynamicImage *assembly, guint32 parent_token, MonoArray *permissions)
1260 {
1261 MonoDynamicTable *table;
1262 guint32 *values;
1263 guint32 count, i, idx;
1264 MonoReflectionPermissionSet *perm;
1265
1266 if (!permissions)
1267 return;
1268
1269 count = mono_array_length (permissions);
1270 table = &assembly->tables [MONO_TABLE_DECLSECURITY];
1271 table->rows += count;
1272 alloc_table (table, table->rows);
1273
1274 for (i = 0; i < mono_array_length (permissions); ++i) {
1275 perm = (MonoReflectionPermissionSet*)mono_array_addr (permissions, MonoReflectionPermissionSet, i);
1276
1277 values = table->values + table->next_idx * MONO_DECL_SECURITY_SIZE;
1278
1279 idx = mono_metadata_token_index (parent_token);
1280 idx <<= MONO_HAS_DECL_SECURITY_BITS;
1281 switch (mono_metadata_token_table (parent_token)) {
1282 case MONO_TABLE_TYPEDEF:
1283 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
1284 break;
1285 case MONO_TABLE_METHOD:
1286 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
1287 break;
1288 case MONO_TABLE_ASSEMBLY:
1289 idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
1290 break;
1291 default:
1292 g_assert_not_reached ();
1293 }
1294
1295 values [MONO_DECL_SECURITY_ACTION] = perm->action;
1296 values [MONO_DECL_SECURITY_PARENT] = idx;
1297 values [MONO_DECL_SECURITY_PERMISSIONSET] = add_mono_string_to_blob_cached (assembly, perm->pset);
1298
1299 ++table->next_idx;
1300 }
1301 }
1302
1303 /*
1304 * Fill in the MethodDef and ParamDef tables for a method.
1305 * This is used for both normal methods and constructors.
1306 */
1307 static void
1308 mono_image_basic_method (ReflectionMethodBuilder *mb, MonoDynamicImage *assembly)
1309 {
1310 MonoDynamicTable *table;
1311 guint32 *values;
1312 guint i, count;
1313
1314 /* room in this table is already allocated */
1315 table = &assembly->tables [MONO_TABLE_METHOD];
1316 *mb->table_idx = table->next_idx ++;
1317 g_hash_table_insert (assembly->method_to_table_idx, mb->mhandle, GUINT_TO_POINTER ((*mb->table_idx)));
1318 values = table->values + *mb->table_idx * MONO_METHOD_SIZE;
1319 values [MONO_METHOD_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name);
1320 values [MONO_METHOD_FLAGS] = mb->attrs;
1321 values [MONO_METHOD_IMPLFLAGS] = mb->iattrs;
1322 values [MONO_METHOD_SIGNATURE] = method_builder_encode_signature (assembly, mb);
1323 values [MONO_METHOD_RVA] = method_encode_code (assembly, mb);
1324
1325 table = &assembly->tables [MONO_TABLE_PARAM];
1326 values [MONO_METHOD_PARAMLIST] = table->next_idx;
1327
1328 mono_image_add_decl_security (assembly,
1329 mono_metadata_make_token (MONO_TABLE_METHOD, *mb->table_idx), mb->permissions);
1330
1331 if (mb->pinfo) {
1332 MonoDynamicTable *mtable;
1333 guint32 *mvalues;
1334
1335 mtable = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
1336 mvalues = mtable->values + mtable->next_idx * MONO_FIELD_MARSHAL_SIZE;
1337
1338 count = 0;
1339 for (i = 0; i < mono_array_length (mb->pinfo); ++i) {
1340 if (mono_array_get (mb->pinfo, gpointer, i))
1341 count++;
1342 }
1343 table->rows += count;
1344 alloc_table (table, table->rows);
1345 values = table->values + table->next_idx * MONO_PARAM_SIZE;
1346 for (i = 0; i < mono_array_length (mb->pinfo); ++i) {
1347 MonoReflectionParamBuilder *pb;
1348 if ((pb = mono_array_get (mb->pinfo, MonoReflectionParamBuilder*, i))) {
1349 values [MONO_PARAM_FLAGS] = pb->attrs;
1350 values [MONO_PARAM_SEQUENCE] = i;
1351 if (pb->name != NULL) {
1352 values [MONO_PARAM_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name);
1353 } else {
1354 values [MONO_PARAM_NAME] = 0;
1355 }
1356 values += MONO_PARAM_SIZE;
1357 if (pb->marshal_info) {
1358 mtable->rows++;
1359 alloc_table (mtable, mtable->rows);
1360 mvalues = mtable->values + mtable->rows * MONO_FIELD_MARSHAL_SIZE;
1361 mvalues [MONO_FIELD_MARSHAL_PARENT] = (table->next_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_PARAMDEF;
1362 mvalues [MONO_FIELD_MARSHAL_NATIVE_TYPE] = encode_marshal_blob (assembly, pb->marshal_info);
1363 }
1364 pb->table_idx = table->next_idx++;
1365 if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
1366 guint32 field_type = 0;
1367 mtable = &assembly->tables [MONO_TABLE_CONSTANT];
1368 mtable->rows ++;
1369 alloc_table (mtable, mtable->rows);
1370 mvalues = mtable->values + mtable->rows * MONO_CONSTANT_SIZE;
1371 mvalues [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_PARAM | (pb->table_idx << MONO_HASCONSTANT_BITS);
1372 mvalues [MONO_CONSTANT_VALUE] = encode_constant (assembly, pb->def_value, &field_type);
1373 mvalues [MONO_CONSTANT_TYPE] = field_type;
1374 mvalues [MONO_CONSTANT_PADDING] = 0;
1375 }
1376 }
1377 }
1378 }
1379 }
1380
1381 static void
1382 reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb)
1383 {
1384 memset (rmb, 0, sizeof (ReflectionMethodBuilder));
1385
1386 rmb->ilgen = mb->ilgen;
1387 rmb->rtype = monotype_cast (mb->rtype);
1388 rmb->parameters = mb->parameters;
1389 rmb->generic_params = mb->generic_params;
1390 rmb->generic_container = mb->generic_container;
1391 rmb->opt_types = NULL;
1392 rmb->pinfo = mb->pinfo;
1393 rmb->attrs = mb->attrs;
1394 rmb->iattrs = mb->iattrs;
1395 rmb->call_conv = mb->call_conv;
1396 rmb->code = mb->code;
1397 rmb->type = mb->type;
1398 rmb->name = mb->name;
1399 rmb->table_idx = &mb->table_idx;
1400 rmb->init_locals = mb->init_locals;
1401 rmb->skip_visibility = FALSE;
1402 rmb->return_modreq = mb->return_modreq;
1403 rmb->return_modopt = mb->return_modopt;
1404 rmb->param_modreq = mb->param_modreq;
1405 rmb->param_modopt = mb->param_modopt;
1406 rmb->permissions = mb->permissions;
1407 rmb->mhandle = mb->mhandle;
1408 rmb->nrefs = 0;
1409 rmb->refs = NULL;
1410
1411 if (mb->dll) {
1412 rmb->charset = mb->charset;
1413 rmb->extra_flags = mb->extra_flags;
1414 rmb->native_cc = mb->native_cc;
1415 rmb->dllentry = mb->dllentry;
1416 rmb->dll = mb->dll;
1417 }
1418 }
1419
1420 static void
1421 reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb)
1422 {
1423 const char *name = mb->attrs & METHOD_ATTRIBUTE_STATIC ? ".cctor": ".ctor";
1424
1425 memset (rmb, 0, sizeof (ReflectionMethodBuilder));
1426
1427 rmb->ilgen = mb->ilgen;
1428 rmb->rtype = mono_type_get_object (mono_domain_get (), &mono_defaults.void_class->byval_arg);
1429 rmb->parameters = mb->parameters;
1430 rmb->generic_params = NULL;
1431 rmb->generic_container = NULL;
1432 rmb->opt_types = NULL;
1433 rmb->pinfo = mb->pinfo;
1434 rmb->attrs = mb->attrs;
1435 rmb->iattrs = mb->iattrs;
1436 rmb->call_conv = mb->call_conv;
1437 rmb->code = NULL;
1438 rmb->type = mb->type;
1439 rmb->name = mono_string_new (mono_domain_get (), name);
1440 rmb->table_idx = &mb->table_idx;
1441 rmb->init_locals = mb->init_locals;
1442 rmb->skip_visibility = FALSE;
1443 rmb->return_modreq = NULL;
1444 rmb->return_modopt = NULL;
1445 rmb->param_modreq = mb->param_modreq;
1446 rmb->param_modopt = mb->param_modopt;
1447 rmb->permissions = mb->permissions;
1448 rmb->mhandle = mb->mhandle;
1449 rmb->nrefs = 0;
1450 rmb->refs = NULL;
1451 }
1452
1453 #ifndef DISABLE_REFLECTION_EMIT
1454 static void
1455 reflection_methodbuilder_from_dynamic_method (ReflectionMethodBuilder *rmb, MonoReflectionDynamicMethod *mb)
1456 {
1457 memset (rmb, 0, sizeof (ReflectionMethodBuilder));
1458
1459 rmb->ilgen = mb->ilgen;
1460 rmb->rtype = mb->rtype;
1461 rmb->parameters = mb->parameters;
1462 rmb->generic_params = NULL;
1463 rmb->generic_container = NULL;
1464 rmb->opt_types = NULL;
1465 rmb->pinfo = NULL;
1466 rmb->attrs = mb->attrs;
1467 rmb->iattrs = 0;
1468 rmb->call_conv = mb->call_conv;
1469 rmb->code = NULL;
1470 rmb->type = (MonoObject *) mb->owner;
1471 rmb->name = mb->name;
1472 rmb->table_idx = NULL;
1473 rmb->init_locals = mb->init_locals;
1474 rmb->skip_visibility = mb->skip_visibility;
1475 rmb->return_modreq = NULL;
1476 rmb->return_modopt = NULL;
1477 rmb->param_modreq = NULL;
1478 rmb->param_modopt = NULL;
1479 rmb->permissions = NULL;
1480 rmb->mhandle = mb->mhandle;
1481 rmb->nrefs = 0;
1482 rmb->refs = NULL;
1483 }
1484 #endif
1485
1486 static void
1487 mono_image_add_methodimpl (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb)
1488 {
1489 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mb->type;
1490 MonoDynamicTable *table;
1491 guint32 *values;
1492 guint32 tok;
1493
1494 if (!mb->override_method)
1495 return;
1496
1497 table = &assembly->tables [MONO_TABLE_METHODIMPL];
1498 table->rows ++;
1499 alloc_table (table, table->rows);
1500 values = table->values + table->rows * MONO_METHODIMPL_SIZE;
1501 values [MONO_METHODIMPL_CLASS] = tb->table_idx;
1502 values [MONO_METHODIMPL_BODY] = MONO_METHODDEFORREF_METHODDEF | (mb->table_idx << MONO_METHODDEFORREF_BITS);
1503
1504 tok = mono_image_create_token (assembly, (MonoObject*)mb->override_method, FALSE, FALSE);
1505 switch (mono_metadata_token_table (tok)) {
1506 case MONO_TABLE_MEMBERREF:
1507 tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODREF;
1508 break;
1509 case MONO_TABLE_METHOD:
1510 tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODDEF;
1511 break;
1512 default:
1513 g_assert_not_reached ();
1514 }
1515 values [MONO_METHODIMPL_DECLARATION] = tok;
1516 }
1517
1518 static void
1519 mono_image_get_method_info (MonoReflectionMethodBuilder *mb, MonoDynamicImage *assembly)
1520 {
1521 MonoDynamicTable *table;
1522 guint32 *values;
1523 ReflectionMethodBuilder rmb;
1524 int i;
1525
1526 reflection_methodbuilder_from_method_builder (&rmb, mb);
1527
1528 mono_image_basic_method (&rmb, assembly);
1529 mb->table_idx = *rmb.table_idx;
1530
1531 if (mb->dll) { /* It's a P/Invoke method */
1532 guint32 moduleref;
1533 /* map CharSet values to on-disk values */
1534 int ncharset = (mb->charset ? (mb->charset - 1) * 2 : 0);
1535 int extra_flags = mb->extra_flags;
1536 table = &assembly->tables [MONO_TABLE_IMPLMAP];
1537 table->rows ++;
1538 alloc_table (table, table->rows);
1539 values = table->values + table->rows * MONO_IMPLMAP_SIZE;
1540
1541 values [MONO_IMPLMAP_FLAGS] = (mb->native_cc << 8) | ncharset | extra_flags;
1542 values [MONO_IMPLMAP_MEMBER] = (mb->table_idx << 1) | 1; /* memberforwarded: method */
1543 if (mb->dllentry)
1544 values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->dllentry);
1545 else
1546 values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name);
1547 moduleref = string_heap_insert_mstring (&assembly->sheap, mb->dll);
1548 if (!(values [MONO_IMPLMAP_SCOPE] = find_index_in_table (assembly, MONO_TABLE_MODULEREF, MONO_MODULEREF_NAME, moduleref))) {
1549 table = &assembly->tables [MONO_TABLE_MODULEREF];
1550 table->rows ++;
1551 alloc_table (table, table->rows);
1552 table->values [table->rows * MONO_MODULEREF_SIZE + MONO_MODULEREF_NAME] = moduleref;
1553 values [MONO_IMPLMAP_SCOPE] = table->rows;
1554 }
1555 }
1556
1557 if (mb->generic_params) {
1558 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
1559 table->rows += mono_array_length (mb->generic_params);
1560 alloc_table (table, table->rows);
1561 for (i = 0; i < mono_array_length (mb->generic_params); ++i) {
1562 guint32 owner = MONO_TYPEORMETHOD_METHOD | (mb->table_idx << MONO_TYPEORMETHOD_BITS);
1563
1564 mono_image_get_generic_param_info (
1565 mono_array_get (mb->generic_params, gpointer, i), owner, assembly);
1566 }
1567 }
1568
1569 }
1570
1571 static void
1572 mono_image_get_ctor_info (MonoDomain *domain, MonoReflectionCtorBuilder *mb, MonoDynamicImage *assembly)
1573 {
1574 ReflectionMethodBuilder rmb;
1575
1576 reflection_methodbuilder_from_ctor_builder (&rmb, mb);
1577
1578 mono_image_basic_method (&rmb, assembly);
1579 mb->table_idx = *rmb.table_idx;
1580 }
1581
1582 static char*
1583 type_get_fully_qualified_name (MonoType *type)
1584 {
1585 return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
1586 }
1587
1588 static char*
1589 type_get_qualified_name (MonoType *type, MonoAssembly *ass) {
1590 MonoClass *klass;
1591 MonoAssembly *ta;
1592
1593 klass = mono_class_from_mono_type (type);
1594 if (!klass)
1595 return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_REFLECTION);
1596 ta = klass->image->assembly;
1597 if (ta->dynamic || (ta == ass)) {
1598 if (klass->generic_class || klass->generic_container)
1599 /* For generic type definitions, we want T, while REFLECTION returns T<K> */
1600 return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_FULL_NAME);
1601 else
1602 return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_REFLECTION);
1603 }
1604
1605 return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
1606 }
1607
1608 #ifndef DISABLE_REFLECTION_EMIT
1609 static guint32
1610 fieldref_encode_signature (MonoDynamicImage *assembly, MonoType *type)
1611 {
1612 SigBuffer buf;
1613 guint32 idx, i;
1614
1615 if (!assembly->save)
1616 return 0;
1617
1618 sigbuffer_init (&buf, 32);
1619
1620 sigbuffer_add_value (&buf, 0x06);
1621 /* encode custom attributes before the type */
1622 /* FIXME: This should probably go in encode_type () */
1623 if (type->num_mods) {
1624 for (i = 0; i < type->num_mods; ++i) {
1625 if (type->modifiers [i].required)
1626 sigbuffer_add_byte (&buf, MONO_TYPE_CMOD_REQD);
1627 else
1628 sigbuffer_add_byte (&buf, MONO_TYPE_CMOD_OPT);
1629 sigbuffer_add_value (&buf, type->modifiers [i].token);
1630 }
1631 }
1632 encode_type (assembly, type, &buf);
1633 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1634 sigbuffer_free (&buf);
1635 return idx;
1636 }
1637 #endif
1638
1639 static guint32
1640 field_encode_signature (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
1641 {
1642 SigBuffer buf;
1643 guint32 idx;
1644
1645 sigbuffer_init (&buf, 32);
1646
1647 sigbuffer_add_value (&buf, 0x06);
1648 encode_custom_modifiers (assembly, fb->modreq, fb->modopt, &buf);
1649 /* encode custom attributes before the type */
1650 encode_reflection_type (assembly, monotype_cast (fb->type), &buf);
1651 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1652 sigbuffer_free (&buf);
1653 return idx;
1654 }
1655
1656 static guint32
1657 encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type) {
1658 char blob_size [64];
1659 char *b = blob_size;
1660 char *p, *box_val;
1661 char* buf;
1662 guint32 idx = 0, len = 0, dummy = 0;
1663 #ifdef ARM_FPU_FPA
1664 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
1665 guint32 fpa_double [2];
1666 guint32 *fpa_p;
1667 #endif
1668 #endif
1669
1670 p = buf = g_malloc (64);
1671 if (!val) {
1672 *ret_type = MONO_TYPE_CLASS;
1673 len = 4;
1674 box_val = (char*)&dummy;
1675 } else {
1676 box_val = ((char*)val) + sizeof (MonoObject);
1677 *ret_type = val->vtable->klass->byval_arg.type;
1678 }
1679 handle_enum:
1680 switch (*ret_type) {
1681 case MONO_TYPE_BOOLEAN:
1682 case MONO_TYPE_U1:
1683 case MONO_TYPE_I1:
1684 len = 1;
1685 break;
1686 case MONO_TYPE_CHAR:
1687 case MONO_TYPE_U2:
1688 case MONO_TYPE_I2:
1689 len = 2;
1690 break;
1691 case MONO_TYPE_U4:
1692 case MONO_TYPE_I4:
1693 case MONO_TYPE_R4:
1694 len = 4;
1695 break;
1696 case MONO_TYPE_U8:
1697 case MONO_TYPE_I8:
1698 len = 8;
1699 break;
1700 case MONO_TYPE_R8:
1701 len = 8;
1702 #ifdef ARM_FPU_FPA
1703 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
1704 fpa_p = (guint32*)box_val;
1705 fpa_double [0] = fpa_p [1];
1706 fpa_double [1] = fpa_p [0];
1707 box_val = (char*)fpa_double;
1708 #endif
1709 #endif
1710 break;
1711 case MONO_TYPE_VALUETYPE:
1712 if (val->vtable->klass->enumtype) {
1713 *ret_type = mono_class_enum_basetype (val->vtable->klass)->type;
1714 goto handle_enum;
1715 } else
1716 g_error ("we can't encode valuetypes");
1717 case MONO_TYPE_CLASS:
1718 break;
1719 case MONO_TYPE_STRING: {
1720 MonoString *str = (MonoString*)val;
1721 /* there is no signature */
1722 len = str->length * 2;
1723 mono_metadata_encode_value (len, b, &b);
1724 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
1725 {
1726 char *swapped = g_malloc (2 * mono_string_length (str));
1727 const char *p = (const char*)mono_string_chars (str);
1728
1729 swap_with_size (swapped, p, 2, mono_string_length (str));
1730 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, swapped, len);
1731 g_free (swapped);
1732 }
1733 #else
1734 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, (char*)mono_string_chars (str), len);
1735 #endif
1736
1737 g_free (buf);
1738 return idx;
1739 }
1740 case MONO_TYPE_GENERICINST:
1741 *ret_type = val->vtable->klass->generic_class->container_class->byval_arg.type;
1742 goto handle_enum;
1743 default:
1744 g_error ("we don't encode constant type 0x%02x yet", *ret_type);
1745 }
1746
1747 /* there is no signature */
1748 mono_metadata_encode_value (len, b, &b);
1749 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
1750 idx = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
1751 swap_with_size (blob_size, box_val, len, 1);
1752 mono_image_add_stream_data (&assembly->blob, blob_size, len);
1753 #else
1754 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, box_val, len);
1755 #endif
1756
1757 g_free (buf);
1758 return idx;
1759 }
1760
1761 static guint32
1762 encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo) {
1763 char *str;
1764 SigBuffer buf;
1765 guint32 idx, len;
1766
1767 sigbuffer_init (&buf, 32);
1768
1769 sigbuffer_add_value (&buf, minfo->type);
1770
1771 switch (minfo->type) {
1772 case MONO_NATIVE_BYVALTSTR:
1773 case MONO_NATIVE_BYVALARRAY:
1774 sigbuffer_add_value (&buf, minfo->count);
1775 break;
1776 case MONO_NATIVE_LPARRAY:
1777 if (minfo->eltype || minfo->has_size) {
1778 sigbuffer_add_value (&buf, minfo->eltype);
1779 if (minfo->has_size) {
1780 sigbuffer_add_value (&buf, minfo->param_num != -1? minfo->param_num: 0);
1781 sigbuffer_add_value (&buf, minfo->count != -1? minfo->count: 0);
1782
1783 /* LAMESPEC: ElemMult is undocumented */
1784 sigbuffer_add_value (&buf, minfo->param_num != -1? 1: 0);
1785 }
1786 }
1787 break;
1788 case MONO_NATIVE_CUSTOM:
1789 if (minfo->guid) {
1790 str = mono_string_to_utf8 (minfo->guid);
1791 len = strlen (str);
1792 sigbuffer_add_value (&buf, len);
1793 sigbuffer_add_mem (&buf, str, len);
1794 g_free (str);
1795 } else {
1796 sigbuffer_add_value (&buf, 0);
1797 }
1798 /* native type name */
1799 sigbuffer_add_value (&buf, 0);
1800 /* custom marshaler type name */
1801 if (minfo->marshaltype || minfo->marshaltyperef) {
1802 if (minfo->marshaltyperef)
1803 str = type_get_fully_qualified_name (monotype_cast (minfo->marshaltyperef)->type);
1804 else
1805 str = mono_string_to_utf8 (minfo->marshaltype);
1806 len = strlen (str);
1807 sigbuffer_add_value (&buf, len);
1808 sigbuffer_add_mem (&buf, str, len);
1809 g_free (str);
1810 } else {
1811 /* FIXME: Actually a bug, since this field is required. Punting for now ... */
1812 sigbuffer_add_value (&buf, 0);
1813 }
1814 if (minfo->mcookie) {
1815 str = mono_string_to_utf8 (minfo->mcookie);
1816 len = strlen (str);
1817 sigbuffer_add_value (&buf, len);
1818 sigbuffer_add_mem (&buf, str, len);
1819 g_free (str);
1820 } else {
1821 sigbuffer_add_value (&buf, 0);
1822 }
1823 break;
1824 default:
1825 break;
1826 }
1827 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1828 sigbuffer_free (&buf);
1829 return idx;
1830 }
1831
1832 static void
1833 mono_image_get_field_info (MonoReflectionFieldBuilder *fb, MonoDynamicImage *assembly)
1834 {
1835 MonoDynamicTable *table;
1836 guint32 *values;
1837
1838 /* maybe this fixup should be done in the C# code */
1839 if (fb->attrs & FIELD_ATTRIBUTE_LITERAL)
1840 fb->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
1841 table = &assembly->tables [MONO_TABLE_FIELD];
1842 fb->table_idx = table->next_idx ++;
1843 g_hash_table_insert (assembly->field_to_table_idx, fb->handle, GUINT_TO_POINTER (fb->table_idx));
1844 values = table->values + fb->table_idx * MONO_FIELD_SIZE;
1845 values [MONO_FIELD_NAME] = string_heap_insert_mstring (&assembly->sheap, fb->name);
1846 values [MONO_FIELD_FLAGS] = fb->attrs;
1847 values [MONO_FIELD_SIGNATURE] = field_encode_signature (assembly, fb);
1848
1849 if (fb->offset != -1) {
1850 table = &assembly->tables [MONO_TABLE_FIELDLAYOUT];
1851 table->rows ++;
1852 alloc_table (table, table->rows);
1853 values = table->values + table->rows * MONO_FIELD_LAYOUT_SIZE;
1854 values [MONO_FIELD_LAYOUT_FIELD] = fb->table_idx;
1855 values [MONO_FIELD_LAYOUT_OFFSET] = fb->offset;
1856 }
1857 if (fb->attrs & FIELD_ATTRIBUTE_LITERAL) {
1858 guint32 field_type = 0;
1859 table = &assembly->tables [MONO_TABLE_CONSTANT];
1860 table->rows ++;
1861 alloc_table (table, table->rows);
1862 values = table->values + table->rows * MONO_CONSTANT_SIZE;
1863 values [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_FIEDDEF | (fb->table_idx << MONO_HASCONSTANT_BITS);
1864 values [MONO_CONSTANT_VALUE] = encode_constant (assembly, fb->def_value, &field_type);
1865 values [MONO_CONSTANT_TYPE] = field_type;
1866 values [MONO_CONSTANT_PADDING] = 0;
1867 }
1868 if (fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) {
1869 guint32 rva_idx;
1870 table = &assembly->tables [MONO_TABLE_FIELDRVA];
1871 table->rows ++;
1872 alloc_table (table, table->rows);
1873 values = table->values + table->rows * MONO_FIELD_RVA_SIZE;
1874 values [MONO_FIELD_RVA_FIELD] = fb->table_idx;
1875 /*
1876 * We store it in the code section because it's simpler for now.
1877 */
1878 if (fb->rva_data) {
1879 if (mono_array_length (fb->rva_data) >= 10)
1880 stream_data_align (&assembly->code);
1881 rva_idx = mono_image_add_stream_data (&assembly->code, mono_array_addr (fb->rva_data, char, 0), mono_array_length (fb->rva_data));
1882 } else
1883 rva_idx = mono_image_add_stream_zero (&assembly->code, mono_class_value_size (fb->handle->parent, NULL));
1884 values [MONO_FIELD_RVA_RVA] = rva_idx + assembly->text_rva;
1885 }
1886 if (fb->marshal_info) {
1887 table = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
1888 table->rows ++;
1889 alloc_table (table, table->rows);
1890 values = table->values + table->rows * MONO_FIELD_MARSHAL_SIZE;
1891 values [MONO_FIELD_MARSHAL_PARENT] = (fb->table_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_FIELDSREF;
1892 values [MONO_FIELD_MARSHAL_NATIVE_TYPE] = encode_marshal_blob (assembly, fb->marshal_info);
1893 }
1894 }
1895
1896 static guint32
1897 property_encode_signature (MonoDynamicImage *assembly, MonoReflectionPropertyBuilder *fb)
1898 {
1899 SigBuffer buf;
1900 guint32 nparams = 0;
1901 MonoReflectionMethodBuilder *mb = fb->get_method;
1902 MonoReflectionMethodBuilder *smb = fb->set_method;
1903 guint32 idx, i;
1904
1905 if (mb && mb->parameters)
1906 nparams = mono_array_length (mb->parameters);
1907 if (!mb && smb && smb->parameters)
1908 nparams = mono_array_length (smb->parameters) - 1;
1909 sigbuffer_init (&buf, 32);
1910 sigbuffer_add_byte (&buf, 0x08);
1911 sigbuffer_add_value (&buf, nparams);
1912 if (mb) {
1913 encode_reflection_type (assembly, monotype_cast (mb->rtype), &buf);
1914 for (i = 0; i < nparams; ++i) {
1915 MonoReflectionType *pt = mono_type_array_get (mb->parameters, i);
1916 encode_reflection_type (assembly, pt, &buf);
1917 }
1918 } else if (smb && smb->parameters) {
1919 /* the property type is the last param */
1920 encode_reflection_type (assembly, mono_type_array_get (smb->parameters, nparams), &buf);
1921 for (i = 0; i < nparams; ++i) {
1922 MonoReflectionType *pt = mono_type_array_get (smb->parameters, i);
1923 encode_reflection_type (assembly, pt, &buf);
1924 }
1925 } else {
1926 encode_reflection_type (assembly, monotype_cast (fb->type), &buf);
1927 }
1928
1929 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1930 sigbuffer_free (&buf);
1931 return idx;
1932 }
1933
1934 static void
1935 mono_image_get_property_info (MonoReflectionPropertyBuilder *pb, MonoDynamicImage *assembly)
1936 {
1937 MonoDynamicTable *table;
1938 guint32 *values;
1939 guint num_methods = 0;
1940 guint32 semaidx;
1941
1942 /*
1943 * we need to set things in the following tables:
1944 * PROPERTYMAP (info already filled in _get_type_info ())
1945 * PROPERTY (rows already preallocated in _get_type_info ())
1946 * METHOD (method info already done with the generic method code)
1947 * METHODSEMANTICS
1948 */
1949 table = &assembly->tables [MONO_TABLE_PROPERTY];
1950 pb->table_idx = table->next_idx ++;
1951 values = table->values + pb->table_idx * MONO_PROPERTY_SIZE;
1952 values [MONO_PROPERTY_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name);
1953 values [MONO_PROPERTY_FLAGS] = pb->attrs;
1954 values [MONO_PROPERTY_TYPE] = property_encode_signature (assembly, pb);
1955
1956 /* FIXME: we still don't handle 'other' methods */
1957 if (pb->get_method) num_methods ++;
1958 if (pb->set_method) num_methods ++;
1959
1960 table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
1961 table->rows += num_methods;
1962 alloc_table (table, table->rows);
1963
1964 if (pb->get_method) {
1965 semaidx = table->next_idx ++;
1966 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
1967 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_GETTER;
1968 values [MONO_METHOD_SEMA_METHOD] = pb->get_method->table_idx;
1969 values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
1970 }
1971 if (pb->set_method) {
1972 semaidx = table->next_idx ++;
1973 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
1974 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_SETTER;
1975 values [MONO_METHOD_SEMA_METHOD] = pb->set_method->table_idx;
1976 values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
1977 }
1978 }
1979
1980 static void
1981 mono_image_get_event_info (MonoReflectionEventBuilder *eb, MonoDynamicImage *assembly)
1982 {
1983 MonoDynamicTable *table;
1984 guint32 *values;
1985 guint num_methods = 0;
1986 guint32 semaidx;
1987
1988 /*
1989 * we need to set things in the following tables:
1990 * EVENTMAP (info already filled in _get_type_info ())
1991 * EVENT (rows already preallocated in _get_type_info ())
1992 * METHOD (method info already done with the generic method code)
1993 * METHODSEMANTICS
1994 */
1995 table = &assembly->tables [MONO_TABLE_EVENT];
1996 eb->table_idx = table->next_idx ++;
1997 values = table->values + eb->table_idx * MONO_EVENT_SIZE;
1998 values [MONO_EVENT_NAME] = string_heap_insert_mstring (&assembly->sheap, eb->name);
1999 values [MONO_EVENT_FLAGS] = eb->attrs;
2000 values [MONO_EVENT_TYPE] = mono_image_typedef_or_ref (assembly, eb->type->type);
2001
2002 /*
2003 * FIXME: we still don't handle 'other' methods
2004 */
2005 if (eb->add_method) num_methods ++;
2006 if (eb->remove_method) num_methods ++;
2007 if (eb->raise_method) num_methods ++;
2008
2009 table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
2010 table->rows += num_methods;
2011 alloc_table (table, table->rows);
2012
2013 if (eb->add_method) {
2014 semaidx = table->next_idx ++;
2015 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
2016 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_ADD_ON;
2017 values [MONO_METHOD_SEMA_METHOD] = eb->add_method->table_idx;
2018 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
2019 }
2020 if (eb->remove_method) {
2021 semaidx = table->next_idx ++;
2022 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
2023 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_REMOVE_ON;
2024 values [MONO_METHOD_SEMA_METHOD] = eb->remove_method->table_idx;
2025 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
2026 }
2027 if (eb->raise_method) {
2028 semaidx = table->next_idx ++;
2029 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
2030 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_FIRE;
2031 values [MONO_METHOD_SEMA_METHOD] = eb->raise_method->table_idx;
2032 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
2033 }
2034 }
2035
2036 static void
2037 encode_constraints (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly)
2038 {
2039 MonoDynamicTable *table;
2040 guint32 num_constraints, i;
2041 guint32 *values;
2042 guint32 table_idx;
2043
2044 table = &assembly->tables [MONO_TABLE_GENERICPARAMCONSTRAINT];
2045 num_constraints = gparam->iface_constraints ?
2046 mono_array_length (gparam->iface_constraints) : 0;
2047 table->rows += num_constraints;
2048 if (gparam->base_type)
2049 table->rows++;
2050 alloc_table (table, table->rows);
2051
2052 if (gparam->base_type) {
2053 table_idx = table->next_idx ++;
2054 values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE;
2055
2056 values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner;
2057 values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (
2058 assembly, gparam->base_type->type);
2059 }
2060
2061 for (i = 0; i < num_constraints; i++) {
2062 MonoReflectionType *constraint = mono_array_get (
2063 gparam->iface_constraints, gpointer, i);
2064
2065 table_idx = table->next_idx ++;
2066 values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE;
2067
2068 values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner;
2069 values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (
2070 assembly, constraint->type);
2071 }
2072 }
2073
2074 static void
2075 mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly)
2076 {
2077 GenericParamTableEntry *entry;
2078
2079 /*
2080 * The GenericParam table must be sorted according to the `owner' field.
2081 * We need to do this sorting prior to writing the GenericParamConstraint
2082 * table, since we have to use the final GenericParam table indices there
2083 * and they must also be sorted.
2084 */
2085
2086 entry = g_new0 (GenericParamTableEntry, 1);
2087 entry->owner = owner;
2088 /* FIXME: track where gen_params should be freed and remove the GC root as well */
2089 MOVING_GC_REGISTER (&entry->gparam);
2090 entry->gparam = gparam;
2091
2092 g_ptr_array_add (assembly->gen_params, entry);
2093 }
2094
2095 static void
2096 write_generic_param_entry (MonoDynamicImage *assembly, GenericParamTableEntry *entry)
2097 {
2098 MonoDynamicTable *table;
2099 MonoGenericParam *param;
2100 guint32 *values;
2101 guint32 table_idx;
2102
2103 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
2104 table_idx = table->next_idx ++;
2105 values = table->values + table_idx * MONO_GENERICPARAM_SIZE;
2106
2107 param = entry->gparam->type.type->data.generic_param;
2108
2109 values [MONO_GENERICPARAM_OWNER] = entry->owner;
2110 values [MONO_GENERICPARAM_FLAGS] = entry->gparam->attrs;
2111 values [MONO_GENERICPARAM_NUMBER] = mono_generic_param_num (param);
2112 values [MONO_GENERICPARAM_NAME] = string_heap_insert (&assembly->sheap, mono_generic_param_info (param)->name);
2113
2114 mono_image_add_cattrs (assembly, table_idx, MONO_CUSTOM_ATTR_GENERICPAR, entry->gparam->cattrs);
2115
2116 encode_constraints (entry->gparam, table_idx, assembly);
2117 }
2118
2119 static guint32
2120 resolution_scope_from_image (MonoDynamicImage *assembly, MonoImage *image)
2121 {
2122 MonoDynamicTable *table;
2123 guint32 token;
2124 guint32 *values;
2125 guint32 cols [MONO_ASSEMBLY_SIZE];
2126 const char *pubkey;
2127 guint32 publen;
2128
2129 if ((token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, image))))
2130 return token;
2131
2132 if (image->assembly->dynamic && (image->assembly == assembly->image.assembly)) {
2133 table = &assembly->tables [MONO_TABLE_MODULEREF];
2134 token = table->next_idx ++;
2135 table->rows ++;
2136 alloc_table (table, table->rows);
2137 values = table->values + token * MONO_MODULEREF_SIZE;
2138 values [MONO_MODULEREF_NAME] = string_heap_insert (&assembly->sheap, image->module_name);
2139
2140 token <<= MONO_RESOLTION_SCOPE_BITS;
2141 token |= MONO_RESOLTION_SCOPE_MODULEREF;
2142 g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
2143
2144 return token;
2145 }
2146
2147 if (image->assembly->dynamic)
2148 /* FIXME: */
2149 memset (cols, 0, sizeof (cols));
2150 else {
2151 /* image->assembly->image is the manifest module */
2152 image = image->assembly->image;
2153 mono_metadata_decode_row (&image->tables [MONO_TABLE_ASSEMBLY], 0, cols, MONO_ASSEMBLY_SIZE);
2154 }
2155
2156 table = &assembly->tables [MONO_TABLE_ASSEMBLYREF];
2157 token = table->next_idx ++;
2158 table->rows ++;
2159 alloc_table (table, table->rows);
2160 values = table->values + token * MONO_ASSEMBLYREF_SIZE;
2161 values [MONO_ASSEMBLYREF_NAME] = string_heap_insert (&assembly->sheap, image->assembly_name);
2162 values [MONO_ASSEMBLYREF_MAJOR_VERSION] = cols [MONO_ASSEMBLY_MAJOR_VERSION];
2163 values [MONO_ASSEMBLYREF_MINOR_VERSION] = cols [MONO_ASSEMBLY_MINOR_VERSION];
2164 values [MONO_ASSEMBLYREF_BUILD_NUMBER] = cols [MONO_ASSEMBLY_BUILD_NUMBER];
2165 values [MONO_ASSEMBLYREF_REV_NUMBER] = cols [MONO_ASSEMBLY_REV_NUMBER];
2166 values [MONO_ASSEMBLYREF_FLAGS] = 0;
2167 values [MONO_ASSEMBLYREF_CULTURE] = 0;
2168 values [MONO_ASSEMBLYREF_HASH_VALUE] = 0;
2169
2170 if (strcmp ("", image->assembly->aname.culture)) {
2171 values [MONO_ASSEMBLYREF_CULTURE] = string_heap_insert (&assembly->sheap,
2172 image->assembly->aname.culture);
2173 }
2174
2175 if ((pubkey = mono_image_get_public_key (image, &publen))) {
2176 guchar pubtoken [9];
2177 pubtoken [0] = 8;
2178 mono_digest_get_public_token (pubtoken + 1, (guchar*)pubkey, publen);
2179 values [MONO_ASSEMBLYREF_PUBLIC_KEY] = mono_image_add_stream_data (&assembly->blob, (char*)pubtoken, 9);
2180 } else {
2181 values [MONO_ASSEMBLYREF_PUBLIC_KEY] = 0;
2182 }
2183 token <<= MONO_RESOLTION_SCOPE_BITS;
2184 token |= MONO_RESOLTION_SCOPE_ASSEMBLYREF;
2185 g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
2186 return token;
2187 }
2188
2189 static guint32
2190 create_typespec (MonoDynamicImage *assembly, MonoType *type)
2191 {
2192 MonoDynamicTable *table;
2193 guint32 *values;
2194 guint32 token;
2195 SigBuffer buf;
2196
2197 if ((token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typespec, type))))
2198 return token;
2199
2200 sigbuffer_init (&buf, 32);
2201 switch (type->type) {
2202 case MONO_TYPE_FNPTR:
2203 case MONO_TYPE_PTR:
2204 case MONO_TYPE_SZARRAY:
2205 case MONO_TYPE_ARRAY:
2206 case MONO_TYPE_VAR:
2207 case MONO_TYPE_MVAR:
2208 case MONO_TYPE_GENERICINST:
2209 encode_type (assembly, type, &buf);
2210 break;
2211 case MONO_TYPE_CLASS:
2212 case MONO_TYPE_VALUETYPE: {
2213 MonoClass *k = mono_class_from_mono_type (type);
2214 if (!k || !k->generic_container) {
2215 sigbuffer_free (&buf);
2216 return 0;
2217 }
2218 encode_type (assembly, type, &buf);
2219 break;
2220 }
2221 default:
2222 sigbuffer_free (&buf);
2223 return 0;
2224 }
2225
2226 table = &assembly->tables [MONO_TABLE_TYPESPEC];
2227 if (assembly->save) {
2228 token = sigbuffer_add_to_blob_cached (assembly, &buf);
2229 alloc_table (table, table->rows + 1);
2230 values = table->values + table->next_idx * MONO_TYPESPEC_SIZE;
2231 values [MONO_TYPESPEC_SIGNATURE] = token;
2232 }
2233 sigbuffer_free (&buf);
2234
2235 token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
2236 g_hash_table_insert (assembly->typespec, type, GUINT_TO_POINTER(token));
2237 table->next_idx ++;
2238 return token;
2239 }
2240
2241 static guint32
2242 mono_image_typedef_or_ref_full (MonoDynamicImage *assembly, MonoType *type, gboolean try_typespec)
2243 {
2244 MonoDynamicTable *table;
2245 guint32 *values;
2246 guint32 token, scope, enclosing;
2247 MonoClass *klass;
2248
2249 /* if the type requires a typespec, we must try that first*/
2250 if (try_typespec && (token = create_typespec (assembly, type)))
2251 return token;
2252 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typeref, type));
2253 if (token)
2254 return token;
2255 klass = mono_class_from_mono_type (type);
2256 if (!klass)
2257 klass = mono_class_from_mono_type (type);
2258
2259 /*
2260 * If it's in the same module and not a generic type parameter:
2261 */
2262 if ((klass->image == &assembly->image) && (type->type != MONO_TYPE_VAR) &&
2263 (type->type != MONO_TYPE_MVAR)) {
2264 MonoReflectionTypeBuilder *tb = klass->reflection_info;
2265 token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
2266 mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), klass->reflection_info);
2267 return token;
2268 }
2269
2270 if (klass->nested_in) {
2271 enclosing = mono_image_typedef_or_ref_full (assembly, &klass->nested_in->byval_arg, FALSE);
2272 /* get the typeref idx of the enclosing type */
2273 enclosing >>= MONO_TYPEDEFORREF_BITS;
2274 scope = (enclosing << MONO_RESOLTION_SCOPE_BITS) | MONO_RESOLTION_SCOPE_TYPEREF;
2275 } else {
2276 scope = resolution_scope_from_image (assembly, klass->image);
2277 }
2278 table = &assembly->tables [MONO_TABLE_TYPEREF];
2279 if (assembly->save) {
2280 alloc_table (table, table->rows + 1);
2281 values = table->values + table->next_idx * MONO_TYPEREF_SIZE;
2282 values [MONO_TYPEREF_SCOPE] = scope;
2283 values [MONO_TYPEREF_NAME] = string_heap_insert (&assembly->sheap, klass->name);
2284 values [MONO_TYPEREF_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
2285 }
2286 token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
2287 g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
2288 table->next_idx ++;
2289 mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), klass->reflection_info);
2290 return token;
2291 }
2292
2293 /*
2294 * Despite the name, we handle also TypeSpec (with the above helper).
2295 */
2296 static guint32
2297 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type)
2298 {
2299 return mono_image_typedef_or_ref_full (assembly, type, TRUE);
2300 }
2301
2302 #ifndef DISABLE_REFLECTION_EMIT
2303 /*
2304 * Insert a memberef row into the metadata: the token that point to the memberref
2305 * is returned. Caching is done in the caller (mono_image_get_methodref_token() or
2306 * mono_image_get_fieldref_token()).
2307 * The sig param is an index to an already built signature.
2308 */
2309 static guint32
2310 mono_image_get_memberref_token (MonoDynamicImage *assembly, MonoType *type, const char *name, guint32 sig)
2311 {
2312 MonoDynamicTable *table;
2313 guint32 *values;
2314 guint32 token, pclass;
2315 guint32 parent;
2316
2317 parent = mono_image_typedef_or_ref (assembly, type);
2318 switch (parent & MONO_TYPEDEFORREF_MASK) {
2319 case MONO_TYPEDEFORREF_TYPEREF:
2320 pclass = MONO_MEMBERREF_PARENT_TYPEREF;
2321 break;
2322 case MONO_TYPEDEFORREF_TYPESPEC:
2323 pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
2324 break;
2325 case MONO_TYPEDEFORREF_TYPEDEF:
2326 pclass = MONO_MEMBERREF_PARENT_TYPEDEF;
2327 break;
2328 default:
2329 g_warning ("unknown typeref or def token 0x%08x for %s", parent, name);
2330 return 0;
2331 }
2332 /* extract the index */
2333 parent >>= MONO_TYPEDEFORREF_BITS;
2334
2335 table = &assembly->tables [MONO_TABLE_MEMBERREF];
2336
2337 if (assembly->save) {
2338 alloc_table (table, table->rows + 1);
2339 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
2340 values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
2341 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
2342 values [MONO_MEMBERREF_SIGNATURE] = sig;
2343 }
2344
2345 token = MONO_TOKEN_MEMBER_REF | table->next_idx;
2346 table->next_idx ++;
2347
2348 return token;
2349 }
2350
2351 static guint32
2352 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec)
2353 {
2354 guint32 token;
2355 MonoMethodSignature *sig;
2356
2357 create_typespec = create_typespec && method->is_generic && method->klass->image != &assembly->image;
2358
2359 if (create_typespec) {
2360 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, GUINT_TO_POINTER (GPOINTER_TO_UINT (method) + 1)));
2361 if (token)
2362 return token;
2363 }
2364
2365 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
2366 if (token && !create_typespec)
2367 return token;
2368
2369 g_assert (!method->is_inflated);
2370 if (!token) {
2371 /*
2372 * A methodref signature can't contain an unmanaged calling convention.
2373 */
2374 sig = mono_metadata_signature_dup (mono_method_signature (method));
2375 if ((sig->call_convention != MONO_CALL_DEFAULT) && (sig->call_convention != MONO_CALL_VARARG))
2376 sig->call_convention = MONO_CALL_DEFAULT;
2377 token = mono_image_get_memberref_token (assembly, &method->klass->byval_arg,
2378 method->name, method_encode_signature (assembly, sig));
2379 g_free (sig);
2380 g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
2381 }
2382
2383 if (create_typespec) {
2384 MonoDynamicTable *table = &assembly->tables [MONO_TABLE_METHODSPEC];
2385 g_assert (mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF);
2386 token = (mono_metadata_token_index (token) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
2387
2388 if (assembly->save) {
2389 guint32 *values;
2390
2391 alloc_table (table, table->rows + 1);
2392 values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
2393 values [MONO_METHODSPEC_METHOD] = token;
2394 values [MONO_METHODSPEC_SIGNATURE] = encode_generic_method_sig (assembly, &mono_method_get_generic_container (method)->context);
2395 }
2396
2397 token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
2398 table->next_idx ++;
2399 /*methodspec and memberef tokens are diferent, */
2400 g_hash_table_insert (assembly->handleref, GUINT_TO_POINTER (GPOINTER_TO_UINT (method) + 1), GUINT_TO_POINTER (token));
2401 return token;
2402 }
2403 return token;
2404 }
2405
2406 static guint32
2407 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method)
2408 {
2409 guint32 token;
2410 ReflectionMethodBuilder rmb;
2411 char *name;
2412
2413 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
2414 if (token)
2415 return token;
2416
2417 name = mono_string_to_utf8 (method->name);
2418 reflection_methodbuilder_from_method_builder (&rmb, method);
2419
2420 /*
2421 * A methodref signature can't contain an unmanaged calling convention.
2422 * Since some flags are encoded as part of call_conv, we need to check against it.
2423 */
2424 if ((rmb.call_conv & ~0x60) != MONO_CALL_DEFAULT && (rmb.call_conv & ~0x60) != MONO_CALL_VARARG)
2425 rmb.call_conv = (rmb.call_conv & 0x60) | MONO_CALL_DEFAULT;
2426 token = mono_image_get_memberref_token (assembly, ((MonoReflectionTypeBuilder*)rmb.type)->type.type,
2427 name, method_builder_encode_signature (assembly, &rmb));
2428
2429 g_free (name);
2430 g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
2431 return token;
2432 }
2433
2434 static guint32
2435 mono_image_get_varargs_method_token (MonoDynamicImage *assembly, guint32 original,
2436 const gchar *name, guint32 sig)
2437 {
2438 MonoDynamicTable *table;
2439 guint32 token;
2440 guint32 *values;
2441
2442 table = &assembly->tables [MONO_TABLE_MEMBERREF];
2443
2444 if (assembly->save) {
2445 alloc_table (table, table->rows + 1);
2446 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
2447 values [MONO_MEMBERREF_CLASS] = original;
2448 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
2449 values [MONO_MEMBERREF_SIGNATURE] = sig;
2450 }
2451
2452 token = MONO_TOKEN_MEMBER_REF | table->next_idx;
2453 table->next_idx ++;
2454
2455 return token;
2456 }
2457
2458 static guint32
2459 encode_generic_method_definition_sig (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb)
2460 {
2461 SigBuffer buf;
2462 int i;
2463 guint32 nparams = mono_array_length (mb->generic_params);
2464 guint32 idx;
2465
2466 if (!assembly->save)
2467 return 0;
2468
2469 sigbuffer_init (&buf, 32);
2470
2471 sigbuffer_add_value (&buf, 0xa);
2472 sigbuffer_add_value (&buf, nparams);
2473
2474 for (i = 0; i < nparams; i++) {
2475 sigbuffer_add_value (&buf, MONO_TYPE_MVAR);
2476 sigbuffer_add_value (&buf, i);
2477 }
2478
2479 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
2480 sigbuffer_free (&buf);
2481 return idx;
2482 }
2483
2484 static guint32
2485 mono_image_get_methodspec_token_for_generic_method_definition (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb)
2486 {
2487 MonoDynamicTable *table;
2488 guint32 *values;
2489 guint32 token, mtoken = 0;
2490
2491 token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->methodspec, mb));
2492 if (token)
2493 return token;
2494
2495 table = &assembly->tables [MONO_TABLE_METHODSPEC];
2496
2497 mtoken = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
2498 switch (mono_metadata_token_table (mtoken)) {
2499 case MONO_TABLE_MEMBERREF:
2500 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
2501 break;
2502 case MONO_TABLE_METHOD:
2503 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODDEF;
2504 break;
2505 default:
2506 g_assert_not_reached ();
2507 }
2508
2509 if (assembly->save) {
2510 alloc_table (table, table->rows + 1);
2511 values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
2512 values [MONO_METHODSPEC_METHOD] = mtoken;
2513 values [MONO_METHODSPEC_SIGNATURE] = encode_generic_method_definition_sig (assembly, mb);
2514 }
2515
2516 token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
2517 table->next_idx ++;
2518
2519 mono_g_hash_table_insert (assembly->methodspec, mb, GUINT_TO_POINTER(token));
2520 return token;
2521 }
2522
2523 static guint32
2524 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_methodspec)
2525 {
2526 guint32 token;
2527
2528 if (mb->generic_params && create_methodspec)
2529 return mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb);
2530
2531 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, mb));
2532 if (token)
2533 return token;
2534
2535 token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb);
2536 g_hash_table_insert (assembly->handleref, mb, GUINT_TO_POINTER(token));
2537 return token;
2538 }
2539
2540 static guint32
2541 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *mb)
2542 {
2543 guint32 token;
2544 ReflectionMethodBuilder rmb;
2545 char *name;
2546
2547 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, mb));
2548 if (token)
2549 return token;
2550
2551 reflection_methodbuilder_from_ctor_builder (&rmb, mb);
2552
2553 name = mono_string_to_utf8 (rmb.name);
2554 token = mono_image_get_memberref_token (assembly, ((MonoReflectionTypeBuilder*)rmb.type)->type.type,
2555 name, method_builder_encode_signature (assembly, &rmb));
2556
2557 g_free (name);
2558 g_hash_table_insert (assembly->handleref, mb, GUINT_TO_POINTER(token));
2559 return token;
2560 }
2561 #endif
2562
2563 static gboolean
2564 is_field_on_inst (MonoClassField *field)
2565 {
2566 return (field->parent->generic_class && field->parent->generic_class->is_dynamic && ((MonoDynamicGenericClass*)field->parent->generic_class)->fields);
2567 }
2568
2569 /*
2570 * If FIELD is a field of a MonoDynamicGenericClass, return its non-inflated type.
2571 */
2572 static MonoType*
2573 get_field_on_inst_generic_type (MonoClassField *field)
2574 {
2575 MonoDynamicGenericClass *dgclass;
2576 int field_index;
2577
2578 g_assert (is_field_on_inst (field));
2579
2580 dgclass = (MonoDynamicGenericClass*)field->parent->generic_class;
2581 field_index = field - dgclass->fields;
2582
2583 g_assert (field_index >= 0 && field_index < dgclass->count_fields);
2584 return dgclass->field_generic_types [field_index];
2585 }
2586
2587 #ifndef DISABLE_REFLECTION_EMIT
2588 static guint32
2589 mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoReflectionField *f)
2590 {
2591 MonoType *type;
2592 guint32 token;
2593 MonoClassField *field;
2594
2595 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, f));
2596 if (token)
2597 return token;
2598 g_assert (f->field->parent);
2599
2600 field = f->field;
2601 if (field->parent->generic_class && field->parent->generic_class->container_class && field->parent->generic_class->container_class->fields) {
2602 int index = field - field->parent->fields;
2603 type = field->parent->generic_class->container_class->fields [index].type;
2604 } else {
2605 if (is_field_on_inst (f->field))
2606 type = get_field_on_inst_generic_type (f->field);
2607 else
2608 type = f->field->type;
2609 }
2610 token = mono_image_get_memberref_token (assembly, &f->field->parent->byval_arg,
2611 mono_field_get_name (f->field),
2612 fieldref_encode_signature (assembly, type));
2613 g_hash_table_insert (assembly->handleref, f, GUINT_TO_POINTER(token));
2614 return token;
2615 }
2616
2617 static guint32
2618 mono_image_get_field_on_inst_token (MonoDynamicImage *assembly, MonoReflectionFieldOnTypeBuilderInst *f)
2619 {
2620 guint32 token;
2621 MonoClass *klass;
2622 MonoGenericClass *gclass;
2623 MonoDynamicGenericClass *dgclass;
2624 MonoReflectionFieldBuilder *fb = f->fb;
2625 char *name;
2626
2627 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, f));
2628 if (token)
2629 return token;
2630 klass = mono_class_from_mono_type (f->inst->type.type);
2631 gclass = f->inst->type.type->data.generic_class;
2632 g_assert (gclass->is_dynamic);
2633 dgclass = (MonoDynamicGenericClass *) gclass;
2634
2635 name = mono_string_to_utf8 (fb->name);
2636 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name,
2637 field_encode_signature (assembly, fb));
2638 g_free (name);
2639 g_hash_table_insert (assembly->handleref, f, GUINT_TO_POINTER (token));
2640 return token;
2641 }
2642
2643 static guint32
2644 mono_image_get_ctor_on_inst_token (MonoDynamicImage *assembly, MonoReflectionCtorOnTypeBuilderInst *c, gboolean create_methodspec)
2645 {
2646 guint32 sig, token;
2647 MonoClass *klass;
2648 MonoGenericClass *gclass;
2649 MonoDynamicGenericClass *dgclass;
2650 MonoReflectionCtorBuilder *cb = c->cb;
2651 ReflectionMethodBuilder rmb;
2652 char *name;
2653
2654 /* A ctor cannot be a generic method, so we can ignore create_methodspec */
2655
2656 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, c));
2657 if (token)
2658 return token;
2659 klass = mono_class_from_mono_type (c->inst->type.type);
2660 gclass = c->inst->type.type->data.generic_class;
2661 g_assert (gclass->is_dynamic);
2662 dgclass = (MonoDynamicGenericClass *) gclass;
2663
2664 reflection_methodbuilder_from_ctor_builder (&rmb, cb);
2665
2666 name = mono_string_to_utf8 (rmb.name);
2667
2668 sig = method_builder_encode_signature (assembly, &rmb);
2669
2670 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig);
2671 g_free (name);
2672
2673 g_hash_table_insert (assembly->handleref, c, GUINT_TO_POINTER (token));
2674 return token;
2675 }
2676
2677 static guint32
2678 mono_image_get_method_on_inst_token (MonoDynamicImage *assembly, MonoReflectionMethodOnTypeBuilderInst *m, gboolean create_methodspec)
2679 {
2680 guint32 sig, token;
2681 MonoClass *klass;
2682 MonoGenericClass *gclass;
2683 MonoReflectionMethodBuilder *mb = m->mb;
2684 ReflectionMethodBuilder rmb;
2685 char *name;
2686
2687 if (create_methodspec && mb->generic_params)
2688 // FIXME:
2689 g_assert_not_reached ();
2690
2691 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, m));
2692 if (token)
2693 return token;
2694 klass = mono_class_from_mono_type (m->inst->type.type);
2695 gclass = m->inst->type.type->data.generic_class;
2696 g_assert (gclass->is_dynamic);
2697
2698 reflection_methodbuilder_from_method_builder (&rmb, mb);
2699
2700 name = mono_string_to_utf8 (rmb.name);
2701
2702 sig = method_builder_encode_signature (assembly, &rmb);
2703
2704 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig);
2705 g_free (name);
2706
2707 g_hash_table_insert (assembly->handleref, m, GUINT_TO_POINTER (token));
2708 return token;
2709 }
2710
2711 static guint32
2712 encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context)
2713 {
2714 SigBuffer buf;
2715 int i;
2716 guint32 nparams = context->method_inst->type_argc;
2717 guint32 idx;
2718
2719 if (!assembly->save)
2720 return 0;
2721
2722 sigbuffer_init (&buf, 32);
2723 /*
2724 * FIXME: vararg, explicit_this, differenc call_conv values...
2725 */
2726 sigbuffer_add_value (&buf, 0xa); /* FIXME FIXME FIXME */
2727 sigbuffer_add_value (&buf, nparams);
2728
2729 for (i = 0; i < nparams; i++)
2730 encode_type (assembly, context->method_inst->type_argv [i], &buf);
2731
2732 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
2733 sigbuffer_free (&buf);
2734 return idx;
2735 }
2736
2737 static guint32
2738 method_encode_methodspec (MonoDynamicImage *assembly, MonoMethod *method)
2739 {
2740 MonoDynamicTable *table;
2741 guint32 *values;
2742 guint32 token, mtoken = 0, sig;
2743 MonoMethodInflated *imethod;
2744 MonoMethod *declaring;
2745
2746 table = &assembly->tables [MONO_TABLE_METHODSPEC];
2747
2748 g_assert (method->is_inflated);
2749 imethod = (MonoMethodInflated *) method;
2750 declaring = imethod->declaring;
2751
2752 sig = method_encode_signature (assembly, mono_method_signature (declaring));
2753 mtoken = mono_image_get_memberref_token (assembly, &method->klass->byval_arg, declaring->name, sig);
2754
2755 if (!mono_method_signature (declaring)->generic_param_count)
2756 return mtoken;
2757
2758 switch (mono_metadata_token_table (mtoken)) {
2759 case MONO_TABLE_MEMBERREF:
2760 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
2761 break;
2762 case MONO_TABLE_METHOD:
2763 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODDEF;
2764 break;
2765 default:
2766 g_assert_not_reached ();
2767 }
2768
2769 sig = encode_generic_method_sig (assembly, mono_method_get_context (method));
2770
2771 if (assembly->save) {
2772 alloc_table (table, table->rows + 1);
2773 values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
2774 values [MONO_METHODSPEC_METHOD] = mtoken;
2775 values [MONO_METHODSPEC_SIGNATURE] = sig;
2776 }
2777
2778 token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
2779 table->next_idx ++;
2780
2781 return token;
2782 }
2783
2784 static guint32
2785 mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *method)
2786 {
2787 MonoMethodInflated *imethod;
2788 guint32 token;
2789
2790 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
2791 if (token)
2792 return token;
2793
2794 g_assert (method->is_inflated);
2795 imethod = (MonoMethodInflated *) method;
2796
2797 if (mono_method_signature (imethod->declaring)->generic_param_count) {
2798 token = method_encode_methodspec (assembly, method);
2799 } else {
2800 guint32 sig = method_encode_signature (
2801 assembly, mono_method_signature (imethod->declaring));
2802 token = mono_image_get_memberref_token (
2803 assembly, &method->klass->byval_arg, method->name, sig);
2804 }
2805
2806 g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
2807 return token;
2808 }
2809
2810 static guint32
2811 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m)
2812 {
2813 MonoMethodInflated *imethod = (MonoMethodInflated *) m;
2814 guint32 sig, token;
2815
2816 sig = method_encode_signature (assembly, mono_method_signature (imethod->declaring));
2817 token = mono_image_get_memberref_token (
2818 assembly, &m->klass->byval_arg, m->name, sig);
2819
2820 return token;
2821 }
2822
2823 static guint32
2824 create_generic_typespec (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb)
2825 {
2826 MonoDynamicTable *table;
2827 MonoClass *klass;
2828 guint32 *values;
2829 guint32 token;
2830 SigBuffer buf;
2831 int count, i;
2832
2833 /*
2834 * We're creating a TypeSpec for the TypeBuilder of a generic type declaration,
2835 * ie. what we'd normally use as the generic type in a TypeSpec signature.
2836 * Because of this, we must not insert it into the `typeref' hash table.
2837 */
2838
2839 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typespec, tb->type.type));
2840 if (token)
2841 return token;
2842
2843 sigbuffer_init (&buf, 32);
2844
2845 g_assert (tb->generic_params);
2846 klass = mono_class_from_mono_type (tb->type.type);
2847
2848 if (tb->generic_container)
2849 mono_reflection_create_generic_class (tb);
2850
2851 sigbuffer_add_value (&buf, MONO_TYPE_GENERICINST);
2852 g_assert (klass->generic_container);
2853 sigbuffer_add_value (&buf, klass->byval_arg.type);
2854 sigbuffer_add_value (&buf, mono_image_typedef_or_ref_full (assembly, &klass->byval_arg, FALSE));
2855
2856 count = mono_array_length (tb->generic_params);
2857 sigbuffer_add_value (&buf, count);
2858 for (i = 0; i < count; i++) {
2859 MonoReflectionGenericParam *gparam;
2860
2861 gparam = mono_array_get (tb->generic_params, MonoReflectionGenericParam *, i);
2862
2863 encode_type (assembly, gparam->type.type, &buf);
2864 }
2865
2866 table = &assembly->tables [MONO_TABLE_TYPESPEC];
2867
2868 if (assembly->save) {
2869 token = sigbuffer_add_to_blob_cached (assembly, &buf);
2870 alloc_table (table, table->rows + 1);
2871 values = table->values + table->next_idx * MONO_TYPESPEC_SIZE;
2872 values [MONO_TYPESPEC_SIGNATURE] = token;
2873 }
2874 sigbuffer_free (&buf);
2875
2876 token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
2877 g_hash_table_insert (assembly->typespec, tb->type.type, GUINT_TO_POINTER(token));
2878 table->next_idx ++;
2879 return token;
2880 }
2881
2882 /*
2883 * Return a copy of TYPE, adding the custom modifiers in MODREQ and MODOPT.
2884 */
2885 static MonoType*
2886 add_custom_modifiers (MonoDynamicImage *assembly, MonoType *type, MonoArray *modreq, MonoArray *modopt)
2887 {
2888 int i, count, len, pos;
2889 MonoType *t;
2890
2891 count = 0;
2892 if (modreq)
2893 count += mono_array_length (modreq);
2894 if (modopt)
2895 count += mono_array_length (modopt);
2896
2897 if (count == 0)
2898 return mono_metadata_type_dup (NULL, type);
2899
2900 len = sizeof (MonoType) + ((gint32)count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoCustomMod);
2901 t = g_malloc (len);
2902 memcpy (t, type, sizeof (MonoType));
2903
2904 t->num_mods = count;
2905 pos = 0;
2906 if (modreq) {
2907 for (i = 0; i < mono_array_length (modreq); ++i) {
2908 MonoReflectionType *mod = mono_type_array_get (modreq, i);
2909 t->modifiers [pos].required = 1;
2910 t->modifiers [pos].token = mono_image_typedef_or_ref (assembly, mod->type);
2911 pos ++;
2912 }
2913 }
2914 if (modopt) {
2915 for (i = 0; i < mono_array_length (modopt); ++i) {
2916 MonoReflectionType *mod = mono_type_array_get (modopt, i);
2917 t->modifiers [pos].required = 0;
2918 t->modifiers [pos].token = mono_image_typedef_or_ref (assembly, mod->type);
2919 pos ++;
2920 }
2921 }
2922
2923 return t;
2924 }
2925
2926 static guint32
2927 mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
2928 {
2929 MonoDynamicTable *table;
2930 MonoClass *klass;
2931 MonoType *custom = NULL;
2932 guint32 *values;
2933 guint32 token, pclass, parent, sig;
2934 gchar *name;
2935
2936 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, fb));
2937 if (token)
2938 return token;
2939
2940 klass = mono_class_from_mono_type (fb->typeb->type);
2941 name = mono_string_to_utf8 (fb->name);
2942
2943 /* fb->type does not include the custom modifiers */
2944 /* FIXME: We should do this in one place when a fieldbuilder is created */
2945 if (fb->modreq || fb->modopt) {
2946 custom = add_custom_modifiers (assembly, monotype_cast (fb->type)->type, fb->modreq, fb->modopt);
2947 sig = fieldref_encode_signature (assembly, custom);
2948 g_free (custom);
2949 } else {
2950 sig = fieldref_encode_signature (assembly, monotype_cast (fb->type)->type);
2951 }
2952
2953 parent = create_generic_typespec (assembly, (MonoReflectionTypeBuilder *) fb->typeb);
2954 g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC);
2955
2956 pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
2957 parent >>= MONO_TYPEDEFORREF_BITS;
2958
2959 table = &assembly->tables [MONO_TABLE_MEMBERREF];
2960
2961 if (assembly->save) {
2962 alloc_table (table, table->rows + 1);
2963 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
2964 values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
2965 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
2966 values [MONO_MEMBERREF_SIGNATURE] = sig;
2967 }
2968
2969 token = MONO_TOKEN_MEMBER_REF | table->next_idx;
2970 table->next_idx ++;
2971 g_hash_table_insert (assembly->handleref, fb, GUINT_TO_POINTER(token));
2972 g_free (name);
2973 return token;
2974 }
2975
2976 static guint32
2977 mono_reflection_encode_sighelper (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper)
2978 {
2979 SigBuffer buf;
2980 guint32 nargs;
2981 guint32 size;
2982 guint32 i, idx;
2983
2984 if (!assembly->save)
2985 return 0;
2986
2987 /* FIXME: this means SignatureHelper.SignatureHelpType.HELPER_METHOD */
2988 g_assert (helper->type == 2);
2989
2990 if (helper->arguments)
2991 nargs = mono_array_length (helper->arguments);
2992 else
2993 nargs = 0;
2994
2995 size = 10 + (nargs * 10);
2996
2997 sigbuffer_init (&buf, 32);
2998
2999 /* Encode calling convention */
3000 /* Change Any to Standard */
3001 if ((helper->call_conv & 0x03) == 0x03)
3002 helper->call_conv = 0x01;
3003 /* explicit_this implies has_this */
3004 if (helper->call_conv & 0x40)
3005 helper->call_conv &= 0x20;
3006
3007 if (helper->call_conv == 0) { /* Unmanaged */
3008 idx = helper->unmanaged_call_conv - 1;
3009 } else {
3010 /* Managed */
3011 idx = helper->call_conv & 0x60; /* has_this + explicit_this */
3012 if (helper->call_conv & 0x02) /* varargs */
3013 idx += 0x05;
3014 }
3015
3016 sigbuffer_add_byte (&buf, idx);
3017 sigbuffer_add_value (&buf, nargs);
3018 encode_reflection_type (assembly, helper->return_type, &buf);
3019 for (i = 0; i < nargs; ++i) {
3020 MonoArray *modreqs = NULL;
3021 MonoArray *modopts = NULL;
3022 MonoReflectionType *pt;
3023
3024 if (helper->modreqs && (i < mono_array_length (helper->modreqs)))
3025 modreqs = mono_array_get (helper->modreqs, MonoArray*, i);
3026 if (helper->modopts && (i < mono_array_length (helper->modopts)))
3027 modopts = mono_array_get (helper->modopts, MonoArray*, i);
3028
3029 encode_custom_modifiers (assembly, modreqs, modopts, &buf);
3030 pt = mono_type_array_get (helper->arguments, i);
3031 encode_reflection_type (assembly, pt, &buf);
3032 }
3033 idx = sigbuffer_add_to_blob_cached (assembly, &buf);
3034 sigbuffer_free (&buf);
3035
3036 return idx;
3037 }
3038
3039 static guint32
3040 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper)
3041 {
3042 guint32 idx;
3043 MonoDynamicTable *table;
3044 guint32 *values;
3045
3046 table = &assembly->tables [MONO_TABLE_STANDALONESIG];
3047 idx = table->next_idx ++;
3048 table->rows ++;
3049 alloc_table (table, table->rows);
3050 values = table->values + idx * MONO_STAND_ALONE_SIGNATURE_SIZE;
3051
3052 values [MONO_STAND_ALONE_SIGNATURE] =
3053 mono_reflection_encode_sighelper (assembly, helper);
3054
3055 return idx;
3056 }
3057
3058 static int
3059 reflection_cc_to_file (int call_conv) {
3060 switch (call_conv & 0x3) {
3061 case 0:
3062 case 1: return MONO_CALL_DEFAULT;
3063 case 2: return MONO_CALL_VARARG;
3064 default:
3065 g_assert_not_reached ();
3066 }
3067 return 0;
3068 }
3069 #endif /* !DISABLE_REFLECTION_EMIT */
3070
3071 typedef struct {
3072 MonoType *parent;
3073 MonoMethodSignature *sig;
3074 char *name;
3075 guint32 token;
3076 } ArrayMethod;
3077
3078 #ifndef DISABLE_REFLECTION_EMIT
3079 static guint32
3080 mono_image_get_array_token (MonoDynamicImage *assembly, MonoReflectionArrayMethod *m)
3081 {
3082 guint32 nparams, i;
3083 GList *tmp;
3084 char *name;
3085 MonoMethodSignature *sig;
3086 ArrayMethod *am;
3087
3088 name = mono_string_to_utf8 (m->name);
3089 nparams = mono_array_length (m->parameters);
3090 sig = g_malloc0 (sizeof (MonoMethodSignature) + sizeof (MonoType*) * nparams);
3091 sig->hasthis = 1;
3092 sig->sentinelpos = -1;
3093 sig->call_convention = reflection_cc_to_file (m->call_conv);
3094 sig->param_count = nparams;
3095 sig->ret = m->ret? m->ret->type: &mono_defaults.void_class->byval_arg;
3096 for (i = 0; i < nparams; ++i) {
3097 MonoReflectionType *t = mono_type_array_get (m->parameters, i);
3098 sig->params [i] = t->type;
3099 }
3100
3101 for (tmp = assembly->array_methods; tmp; tmp = tmp->next) {
3102 am = tmp->data;
3103 if (strcmp (name, am->name) == 0 &&
3104 mono_metadata_type_equal (am->parent, m->parent->type) &&
3105 mono_metadata_signature_equal (am->sig, sig)) {
3106 g_free (name);
3107 g_free (sig);
3108 m->table_idx = am->token & 0xffffff;
3109 return am->token;
3110 }
3111 }
3112 am = g_new0 (ArrayMethod, 1);
3113 am->name = name;
3114 am->sig = sig;
3115 am->parent = m->parent->type;
3116 am->token = mono_image_get_memberref_token (assembly, am->parent, name,
3117 method_encode_signature (assembly, sig));
3118 assembly->array_methods = g_list_prepend (assembly->array_methods, am);
3119 m->table_idx = am->token & 0xffffff;
3120 return am->token;
3121 }
3122 #endif
3123
3124 /*
3125 * Insert into the metadata tables all the info about the TypeBuilder tb.
3126 * Data in the tables is inserted in a predefined order, since some tables need to be sorted.
3127 */
3128 static void
3129 mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, MonoDynamicImage *assembly)
3130 {
3131 MonoDynamicTable *table;
3132 guint *values;
3133 int i, is_object = 0, is_system = 0;
3134 char *n;
3135
3136 table = &assembly->tables [MONO_TABLE_TYPEDEF];
3137 values = table->values + tb->table_idx * MONO_TYPEDEF_SIZE;
3138 values [MONO_TYPEDEF_FLAGS] = tb->attrs;
3139 n = mono_string_to_utf8 (tb->name);
3140 if (strcmp (n, "Object") == 0)
3141 is_object++;
3142 values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, n);
3143 g_free (n);
3144 n = mono_string_to_utf8 (tb->nspace);
3145 if (strcmp (n, "System") == 0)
3146 is_system++;
3147 values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, n);
3148 g_free (n);
3149 if (tb->parent && !(is_system && is_object) &&
3150 !(tb->attrs & TYPE_ATTRIBUTE_INTERFACE)) { /* interfaces don't have a parent */
3151 values [MONO_TYPEDEF_EXTENDS] = mono_image_typedef_or_ref (assembly, monotype_cast (tb->parent)->type);
3152 } else {
3153 values [MONO_TYPEDEF_EXTENDS] = 0;
3154 }
3155 values [MONO_TYPEDEF_FIELD_LIST] = assembly->tables [MONO_TABLE_FIELD].next_idx;
3156 values [MONO_TYPEDEF_METHOD_LIST] = assembly->tables [MONO_TABLE_METHOD].next_idx;
3157
3158 /*
3159 * if we have explicitlayout or sequentiallayouts, output data in the
3160 * ClassLayout table.
3161 */
3162 if (((tb->attrs & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT) &&
3163 ((tb->class_size > 0) || (tb->packing_size > 0))) {
3164 table = &assembly->tables [MONO_TABLE_CLASSLAYOUT];
3165 table->rows++;
3166 alloc_table (table, table->rows);
3167 values = table->values + table->rows * MONO_CLASS_LAYOUT_SIZE;
3168 values [MONO_CLASS_LAYOUT_PARENT] = tb->table_idx;
3169 values [MONO_CLASS_LAYOUT_CLASS_SIZE] = tb->class_size;
3170 values [MONO_CLASS_LAYOUT_PACKING_SIZE] = tb->packing_size;
3171 }
3172
3173 /* handle interfaces */
3174 if (tb->interfaces) {
3175 table = &assembly->tables [MONO_TABLE_INTERFACEIMPL];
3176 i = table->rows;
3177 table->rows += mono_array_length (tb->interfaces);
3178 alloc_table (table, table->rows);
3179 values = table->values + (i + 1) * MONO_INTERFACEIMPL_SIZE;
3180 for (i = 0; i < mono_array_length (tb->interfaces); ++i) {
3181 MonoReflectionType* iface = (MonoReflectionType*) mono_array_get (tb->interfaces, gpointer, i);
3182 values [MONO_INTERFACEIMPL_CLASS] = tb->table_idx;
3183 values [MONO_INTERFACEIMPL_INTERFACE] = mono_image_typedef_or_ref (assembly, iface->type);
3184 values += MONO_INTERFACEIMPL_SIZE;
3185 }
3186 }
3187
3188 /* handle fields */
3189 if (tb->fields) {
3190 table = &assembly->tables [MONO_TABLE_FIELD];
3191 table->rows += tb->num_fields;
3192 alloc_table (table, table->rows);
3193 for (i = 0; i < tb->num_fields; ++i)
3194 mono_image_get_field_info (
3195 mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i), assembly);
3196 }
3197
3198 /* handle constructors */
3199 if (tb->ctors) {
3200 table = &assembly->tables [MONO_TABLE_METHOD];
3201 table->rows += mono_array_length (tb->ctors);
3202 alloc_table (table, table->rows);
3203 for (i = 0; i < mono_array_length (tb->ctors); ++i)
3204 mono_image_get_ctor_info (domain,
3205 mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i), assembly);
3206 }
3207
3208 /* handle methods */
3209 if (tb->methods) {
3210 table = &assembly->tables [MONO_TABLE_METHOD];
3211 table->rows += tb->num_methods;
3212 alloc_table (table, table->rows);
3213 for (i = 0; i < tb->num_methods; ++i)
3214 mono_image_get_method_info (
3215 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i), assembly);
3216 }
3217
3218 /* Do the same with properties etc.. */
3219 if (tb->events && mono_array_length (tb->events)) {
3220 table = &assembly->tables [MONO_TABLE_EVENT];
3221 table->rows += mono_array_length (tb->events);
3222 alloc_table (table, table->rows);
3223 table = &assembly->tables [MONO_TABLE_EVENTMAP];
3224 table->rows ++;
3225 alloc_table (table, table->rows);
3226 values = table->values + table->rows * MONO_EVENT_MAP_SIZE;
3227 values [MONO_EVENT_MAP_PARENT] = tb->table_idx;
3228 values [MONO_EVENT_MAP_EVENTLIST] = assembly->tables [MONO_TABLE_EVENT].next_idx;
3229 for (i = 0; i < mono_array_length (tb->events); ++i)
3230 mono_image_get_event_info (
3231 mono_array_get (tb->events, MonoReflectionEventBuilder*, i), assembly);
3232 }
3233 if (tb->properties && mono_array_length (tb->properties)) {
3234 table = &assembly->tables [MONO_TABLE_PROPERTY];
3235 table->rows += mono_array_length (tb->properties);
3236 alloc_table (table, table->rows);
3237 table = &assembly->tables [MONO_TABLE_PROPERTYMAP];
3238 table->rows ++;
3239 alloc_table (table, table->rows);
3240 values = table->values + table->rows * MONO_PROPERTY_MAP_SIZE;
3241 values [MONO_PROPERTY_MAP_PARENT] = tb->table_idx;
3242 values [MONO_PROPERTY_MAP_PROPERTY_LIST] = assembly->tables [MONO_TABLE_PROPERTY].next_idx;
3243 for (i = 0; i < mono_array_length (tb->properties); ++i)
3244 mono_image_get_property_info (
3245 mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i), assembly);
3246 }
3247
3248 /* handle generic parameters */
3249 if (tb->generic_params) {
3250 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
3251 table->rows += mono_array_length (tb->generic_params);
3252 alloc_table (table, table->rows);
3253 for (i = 0; i < mono_array_length (tb->generic_params); ++i) {
3254 guint32 owner = MONO_TYPEORMETHOD_TYPE | (tb->table_idx << MONO_TYPEORMETHOD_BITS);
3255
3256 mono_image_get_generic_param_info (
3257 mono_array_get (tb->generic_params, MonoReflectionGenericParam*, i), owner, assembly);
3258 }
3259 }
3260
3261 mono_image_add_decl_security (assembly,
3262 mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx), tb->permissions);
3263
3264 if (tb->subtypes) {
3265 MonoDynamicTable *ntable;
3266
3267 ntable = &assembly->tables [MONO_TABLE_NESTEDCLASS];
3268 ntable->rows += mono_array_length (tb->subtypes);
3269 alloc_table (ntable, ntable->rows);
3270 values = ntable->values + ntable->next_idx * MONO_NESTED_CLASS_SIZE;
3271
3272 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
3273 MonoReflectionTypeBuilder *subtype = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
3274
3275 values [MONO_NESTED_CLASS_NESTED] = subtype->table_idx;
3276 values [MONO_NESTED_CLASS_ENCLOSING] = tb->table_idx;
3277 /*g_print ("nesting %s (%d) in %s (%d) (rows %d/%d)\n",
3278 mono_string_to_utf8 (subtype->name), subtype->table_idx,
3279 mono_string_to_utf8 (tb->name), tb->table_idx,
3280 ntable->next_idx, ntable->rows);*/
3281 values += MONO_NESTED_CLASS_SIZE;
3282 ntable->next_idx++;
3283 }
3284 }
3285 }
3286
3287 static void
3288 collect_types (GPtrArray *types, MonoReflectionTypeBuilder *type)
3289 {
3290 int i;
3291
3292 g_ptr_array_add (types, type); /* FIXME: GC object added to unmanaged memory */
3293
3294 if (!type->subtypes)
3295 return;
3296
3297 for (i = 0; i < mono_array_length (type->subtypes); ++i) {
3298 MonoReflectionTypeBuilder *subtype = mono_array_get (type->subtypes, MonoReflectionTypeBuilder*, i);
3299 collect_types (types, subtype);
3300 }
3301 }
3302
3303 static gint
3304 compare_types_by_table_idx (MonoReflectionTypeBuilder **type1, MonoReflectionTypeBuilder **type2)
3305 {
3306 if ((*type1)->table_idx < (*type2)->table_idx)
3307 return -1;
3308 else
3309 if ((*type1)->table_idx > (*type2)->table_idx)
3310 return 1;
3311 else
3312 return 0;
3313 }
3314
3315 static void
3316 params_add_cattrs (MonoDynamicImage *assembly, MonoArray *pinfo) {
3317 int i;
3318
3319 if (!pinfo)
3320 return;
3321 for (i = 0; i < mono_array_length (pinfo); ++i) {
3322 MonoReflectionParamBuilder *pb;
3323 pb = mono_array_get (pinfo, MonoReflectionParamBuilder *, i);
3324 if (!pb)
3325 continue;
3326 mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PARAMDEF, pb->cattrs);
3327 }
3328 }
3329
3330 static void
3331 type_add_cattrs (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb) {
3332 int i;
3333
3334 mono_image_add_cattrs (assembly, tb->table_idx, MONO_CUSTOM_ATTR_TYPEDEF, tb->cattrs);
3335 if (tb->fields) {
3336 for (i = 0; i < tb->num_fields; ++i) {
3337 MonoReflectionFieldBuilder* fb;
3338 fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i);
3339 mono_image_add_cattrs (assembly, fb->table_idx, MONO_CUSTOM_ATTR_FIELDDEF, fb->cattrs);
3340 }
3341 }
3342 if (tb->events) {
3343 for (i = 0; i < mono_array_length (tb->events); ++i) {
3344 MonoReflectionEventBuilder* eb;
3345 eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
3346 mono_image_add_cattrs (assembly, eb->table_idx, MONO_CUSTOM_ATTR_EVENT, eb->cattrs);
3347 }
3348 }
3349 if (tb->properties) {
3350 for (i = 0; i < mono_array_length (tb->properties); ++i) {
3351 MonoReflectionPropertyBuilder* pb;
3352 pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
3353 mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PROPERTY, pb->cattrs);
3354 }
3355 }
3356 if (tb->ctors) {
3357 for (i = 0; i < mono_array_length (tb->ctors); ++i) {
3358 MonoReflectionCtorBuilder* cb;
3359 cb = mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i);
3360 mono_image_add_cattrs (assembly, cb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, cb->cattrs);
3361 params_add_cattrs (assembly, cb->pinfo);
3362 }
3363 }
3364
3365 if (tb->methods) {
3366 for (i = 0; i < tb->num_methods; ++i) {
3367 MonoReflectionMethodBuilder* mb;
3368 mb = mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
3369 mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, mb->cattrs);
3370 params_add_cattrs (assembly, mb->pinfo);
3371 }
3372 }
3373
3374 if (tb->subtypes) {
3375 for (i = 0; i < mono_array_length (tb->subtypes); ++i)
3376 type_add_cattrs (assembly, mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i));
3377 }
3378 }
3379
3380 static void
3381 module_add_cattrs (MonoDynamicImage *assembly, MonoReflectionModuleBuilder *moduleb)
3382 {
3383 int i;
3384
3385 mono_image_add_cattrs (assembly, moduleb->table_idx, MONO_CUSTOM_ATTR_MODULE, moduleb->cattrs);
3386
3387 if (moduleb->global_methods) {
3388 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
3389 MonoReflectionMethodBuilder* mb = mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i);
3390 mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, mb->cattrs);
3391 params_add_cattrs (assembly, mb->pinfo);
3392 }
3393 }
3394
3395 if (moduleb->global_fields) {
3396 for (i = 0; i < mono_array_length (moduleb->global_fields); ++i) {
3397 MonoReflectionFieldBuilder *fb = mono_array_get (moduleb->global_fields, MonoReflectionFieldBuilder*, i);
3398 mono_image_add_cattrs (assembly, fb->table_idx, MONO_CUSTOM_ATTR_FIELDDEF, fb->cattrs);
3399 }
3400 }
3401
3402 if (moduleb->types) {
3403 for (i = 0; i < moduleb->num_types; ++i)
3404 type_add_cattrs (assembly, mono_array_get (moduleb->types, MonoReflectionTypeBuilder*, i));
3405 }
3406 }
3407
3408 static void
3409 mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, MonoDynamicImage *assembly)
3410 {
3411 MonoDynamicTable *table;
3412 guint32 *values;
3413 char blob_size [6];
3414 guchar hash [20];
3415 char *b = blob_size;
3416 char *dir, *path;
3417
3418 table = &assembly->tables [MONO_TABLE_FILE];
3419 table->rows++;
3420 alloc_table (table, table->rows);
3421 values = table->values + table->next_idx * MONO_FILE_SIZE;
3422 values [MONO_FILE_FLAGS] = FILE_CONTAINS_METADATA;
3423 values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, module->image->module_name);
3424 if (module->image->dynamic) {
3425 /* This depends on the fact that the main module is emitted last */
3426 dir = mono_string_to_utf8 (((MonoReflectionModuleBuilder*)module)->assemblyb->dir);
3427 path = g_strdup_printf ("%s%c%s", dir, G_DIR_SEPARATOR, module->image->module_name);
3428 } else {
3429 dir = NULL;
3430 path = g_strdup (module->image->name);
3431 }
3432 mono_sha1_get_digest_from_file (path, hash);
3433 g_free (dir);
3434 g_free (path);
3435 mono_metadata_encode_value (20, b, &b);
3436 values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
3437 mono_image_add_stream_data (&assembly->blob, (char*)hash, 20);
3438 table->next_idx ++;
3439 }
3440
3441 static void
3442 mono_image_fill_module_table (MonoDomain *domain, MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly)
3443 {
3444 MonoDynamicTable *table;
3445 int i;
3446
3447 table = &assembly->tables [MONO_TABLE_MODULE];
3448 mb->table_idx = table->next_idx ++;
3449 table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->module.name);
3450 i = mono_image_add_stream_data (&assembly->guid, mono_array_addr (mb->guid, char, 0), 16);
3451 i /= 16;
3452 ++i;
3453 table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_GENERATION] = 0;
3454 table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_MVID] = i;
3455 table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_ENC] = 0;
3456 table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_ENCBASE] = 0;
3457 }
3458
3459 static guint32
3460 mono_image_fill_export_table_from_class (MonoDomain *domain, MonoClass *klass,
3461 guint32 module_index, guint32 parent_index, MonoDynamicImage *assembly)
3462 {
3463 MonoDynamicTable *table;
3464 guint32 *values;
3465 guint32 visib, res;
3466
3467 visib = klass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
3468 if (! ((visib & TYPE_ATTRIBUTE_PUBLIC) || (visib & TYPE_ATTRIBUTE_NESTED_PUBLIC)))
3469 return 0;
3470
3471 table = &assembly->tables [MONO_TABLE_EXPORTEDTYPE];
3472 table->rows++;
3473 alloc_table (table, table->rows);
3474 values = table->values + table->next_idx * MONO_EXP_TYPE_SIZE;
3475
3476 values [MONO_EXP_TYPE_FLAGS] = klass->flags;
3477 values [MONO_EXP_TYPE_TYPEDEF] = klass->type_token;
3478 if (klass->nested_in)
3479 values [MONO_EXP_TYPE_IMPLEMENTATION] = (parent_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_EXP_TYPE;
3480 else
3481 values [MONO_EXP_TYPE_IMPLEMENTATION] = (module_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_FILE;
3482 values [MONO_EXP_TYPE_NAME] = string_heap_insert (&assembly->sheap, klass->name);
3483 values [MONO_EXP_TYPE_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
3484
3485 res = table->next_idx;
3486
3487 table->next_idx ++;
3488
3489 /* Emit nested types */
3490 if (klass->ext && klass->ext->nested_classes) {
3491 GList *tmp;
3492
3493 for (tmp = klass->ext->nested_classes; tmp; tmp = tmp->next)
3494 mono_image_fill_export_table_from_class (domain, tmp->data, module_index, table->next_idx - 1, assembly);
3495 }
3496
3497 return res;
3498 }
3499
3500 static void
3501 mono_image_fill_export_table (MonoDomain *domain, MonoReflectionTypeBuilder *tb,
3502 guint32 module_index, guint32 parent_index, MonoDynamicImage *assembly)
3503 {
3504 MonoClass *klass;
3505 guint32 idx, i;
3506
3507 klass = mono_class_from_mono_type (tb->type.type);
3508
3509 klass->type_token = mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx);
3510
3511 idx = mono_image_fill_export_table_from_class (domain, klass, module_index,
3512 parent_index, assembly);
3513
3514 /*
3515 * Emit nested types
3516 * We need to do this ourselves since klass->nested_classes is not set up.
3517 */
3518 if (tb->subtypes) {
3519 for (i = 0; i < mono_array_length (tb->subtypes); ++i)
3520 mono_image_fill_export_table (domain, mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i), module_index, idx, assembly);
3521 }
3522 }
3523
3524 static void
3525 mono_image_fill_export_table_from_module (MonoDomain *domain, MonoReflectionModule *module,
3526 guint32 module_index, MonoDynamicImage *assembly)
3527 {
3528 MonoImage *image = module->image;
3529 MonoTableInfo *t;
3530 guint32 i;
3531
3532 t = &image->tables [MONO_TABLE_TYPEDEF];
3533
3534 for (i = 0; i < t->rows; ++i) {
3535 MonoClass *klass = mono_class_get (image, mono_metadata_make_token (MONO_TABLE_TYPEDEF, i + 1));
3536
3537 if (klass->flags & TYPE_ATTRIBUTE_PUBLIC)
3538 mono_image_fill_export_table_from_class (domain, klass, module_index, 0, assembly);
3539 }
3540 }
3541
3542 static guint32
3543 add_exported_type (MonoReflectionAssemblyBuilder *assemblyb, MonoDynamicImage *assembly, MonoClass *klass)
3544 {
3545 MonoDynamicTable *table;
3546 guint32 *values;
3547 guint32 scope, idx, res, impl;
3548 gboolean forwarder = TRUE;
3549
3550 if (klass->nested_in) {
3551 impl = add_exported_type (assemblyb, assembly, klass->nested_in);
3552 forwarder = FALSE;
3553 } else {
3554 scope = resolution_scope_from_image (assembly, klass->image);
3555 g_assert ((scope & MONO_RESOLTION_SCOPE_MASK) == MONO_RESOLTION_SCOPE_ASSEMBLYREF);
3556 idx = scope >> MONO_RESOLTION_SCOPE_BITS;
3557 impl = (idx << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_ASSEMBLYREF;
3558 }
3559
3560 table = &assembly->tables [MONO_TABLE_EXPORTEDTYPE];
3561
3562 table->rows++;
3563 alloc_table (table, table->rows);
3564 values = table->values + table->next_idx * MONO_EXP_TYPE_SIZE;
3565
3566 values [MONO_EXP_TYPE_FLAGS] = forwarder ? TYPE_ATTRIBUTE_FORWARDER : 0;
3567 values [MONO_EXP_TYPE_TYPEDEF] = 0;
3568 values [MONO_EXP_TYPE_IMPLEMENTATION] = impl;
3569 values [MONO_EXP_TYPE_NAME] = string_heap_insert (&assembly->sheap, klass->name);
3570 values [MONO_EXP_TYPE_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
3571
3572 res = (table->next_idx << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_EXP_TYPE;
3573
3574 table->next_idx++;
3575
3576 return res;
3577 }
3578
3579 static void
3580 mono_image_fill_export_table_from_type_forwarders (MonoReflectionAssemblyBuilder *assemblyb, MonoDynamicImage *assembly)
3581 {
3582 MonoClass *klass;
3583 int i;
3584
3585 if (!assemblyb->type_forwarders)
3586 return;
3587
3588 for (i = 0; i < mono_array_length (assemblyb->type_forwarders); ++i) {
3589 MonoReflectionType *t = mono_type_array_get (assemblyb->type_forwarders, i);
3590 if (!t)
3591 continue;
3592
3593 g_assert (t->type);
3594
3595 klass = mono_class_from_mono_type (t->type);
3596
3597 add_exported_type (assemblyb, assembly, klass);
3598 }
3599 }
3600
3601 #define align_pointer(base,p)\
3602 do {\
3603 guint32 __diff = (unsigned char*)(p)-(unsigned char*)(base);\
3604 if (__diff & 3)\
3605 (p) += 4 - (__diff & 3);\
3606 } while (0)
3607
3608 static int
3609 compare_constants (const void *a, const void *b)
3610 {
3611 const guint32 *a_values = a;
3612 const guint32 *b_values = b;
3613 return a_values [MONO_CONSTANT_PARENT] - b_values [MONO_CONSTANT_PARENT];
3614 }
3615
3616 static int
3617 compare_semantics (const void *a, const void *b)
3618 {
3619 const guint32 *a_values = a;
3620 const guint32 *b_values = b;
3621 int assoc = a_values [MONO_METHOD_SEMA_ASSOCIATION] - b_values [MONO_METHOD_SEMA_ASSOCIATION];
3622 if (assoc)
3623 return assoc;
3624 return a_values [MONO_METHOD_SEMA_SEMANTICS] - b_values [MONO_METHOD_SEMA_SEMANTICS];
3625 }
3626
3627 static int
3628 compare_custom_attrs (const void *a, const void *b)
3629 {
3630 const guint32 *a_values = a;
3631 const guint32 *b_values = b;
3632
3633 return a_values [MONO_CUSTOM_ATTR_PARENT] - b_values [MONO_CUSTOM_ATTR_PARENT];
3634 }
3635
3636 static int
3637 compare_field_marshal (const void *a, const void *b)
3638 {
3639 const guint32 *a_values = a;
3640 const guint32 *b_values = b;
3641
3642 return a_values [MONO_FIELD_MARSHAL_PARENT] - b_values [MONO_FIELD_MARSHAL_PARENT];
3643 }
3644
3645 static int
3646 compare_nested (const void *a, const void *b)
3647 {
3648 const guint32 *a_values = a;
3649 const guint32 *b_values = b;
3650
3651 return a_values [MONO_NESTED_CLASS_NESTED] - b_values [MONO_NESTED_CLASS_NESTED];
3652 }
3653
3654 static int
3655 compare_genericparam (const void *a, const void *b)
3656 {
3657 const GenericParamTableEntry **a_entry = (const GenericParamTableEntry **) a;
3658 const GenericParamTableEntry **b_entry = (const GenericParamTableEntry **) b;
3659
3660 if ((*b_entry)->owner == (*a_entry)->owner)
3661 return
3662 mono_type_get_generic_param_num ((*a_entry)->gparam->type.type) -
3663 mono_type_get_generic_param_num ((*b_entry)->gparam->type.type);
3664 else
3665 return (*a_entry)->owner - (*b_entry)->owner;
3666 }
3667
3668 static int
3669 compare_declsecurity_attrs (const void *a, const void *b)
3670 {
3671 const guint32 *a_values = a;
3672 const guint32 *b_values = b;
3673
3674 return a_values [MONO_DECL_SECURITY_PARENT] - b_values [MONO_DECL_SECURITY_PARENT];
3675 }
3676
3677 static int
3678 compare_interface_impl (const void *a, const void *b)
3679 {
3680 const guint32 *a_values = a;
3681 const guint32 *b_values = b;
3682
3683 int klass = a_values [MONO_INTERFACEIMPL_CLASS] - b_values [MONO_INTERFACEIMPL_CLASS];
3684 if (klass)
3685 return klass;
3686
3687 return a_values [MONO_INTERFACEIMPL_INTERFACE] - b_values [MONO_INTERFACEIMPL_INTERFACE];
3688 }
3689
3690 static void
3691 pad_heap (MonoDynamicStream *sh)
3692 {
3693 if (sh->index & 3) {
3694 int sz = 4 - (sh->index & 3);
3695 memset (sh->data + sh->index, 0, sz);
3696 sh->index += sz;
3697 }
3698 }
3699
3700 struct StreamDesc {
3701 const char *name;
3702 MonoDynamicStream *stream;
3703 };
3704
3705 /*
3706 * build_compressed_metadata() fills in the blob of data that represents the
3707 * raw metadata as it will be saved in the PE file. The five streams are output
3708 * and the metadata tables are comnpressed from the guint32 array representation,
3709 * to the compressed on-disk format.
3710 */
3711 static void
3712 build_compressed_metadata (MonoDynamicImage *assembly)
3713 {
3714 MonoDynamicTable *table;
3715 int i;
3716 guint64 valid_mask = 0;
3717 guint64 sorted_mask;
3718 guint32 heapt_size = 0;
3719 guint32 meta_size = 256; /* allow for header and other stuff */
3720 guint32 table_offset;
3721 guint32 ntables = 0;
3722 guint64 *int64val;
3723 guint32 *int32val;
3724 guint16 *int16val;
3725 MonoImage *meta;
3726 unsigned char *p;
3727 struct StreamDesc stream_desc [5];
3728
3729 qsort (assembly->gen_params->pdata, assembly->gen_params->len, sizeof (gpointer), compare_genericparam);
3730 for (i = 0; i < assembly->gen_params->len; i++){
3731 GenericParamTableEntry *entry = g_ptr_array_index (assembly->gen_params, i);
3732 write_generic_param_entry (assembly, entry);
3733 }
3734
3735 stream_desc [0].name = "#~";
3736 stream_desc [0].stream = &assembly->tstream;
3737 stream_desc [1].name = "#Strings";
3738 stream_desc [1].stream = &assembly->sheap;
3739 stream_desc [2].name = "#US";
3740 stream_desc [2].stream = &assembly->us;
3741 stream_desc [3].name = "#Blob";
3742 stream_desc [3].stream = &assembly->blob;
3743 stream_desc [4].name = "#GUID";
3744 stream_desc [4].stream = &assembly->guid;
3745
3746 /* tables that are sorted */
3747 sorted_mask = ((guint64)1 << MONO_TABLE_CONSTANT) | ((guint64)1 << MONO_TABLE_FIELDMARSHAL)
3748 | ((guint64)1 << MONO_TABLE_METHODSEMANTICS) | ((guint64)1 << MONO_TABLE_CLASSLAYOUT)
3749 | ((guint64)1 << MONO_TABLE_FIELDLAYOUT) | ((guint64)1 << MONO_TABLE_FIELDRVA)
3750 | ((guint64)1 << MONO_TABLE_IMPLMAP) | ((guint64)1 << MONO_TABLE_NESTEDCLASS)
3751 | ((guint64)1 << MONO_TABLE_METHODIMPL) | ((guint64)1 << MONO_TABLE_CUSTOMATTRIBUTE)
3752 | ((guint64)1 << MONO_TABLE_DECLSECURITY) | ((guint64)1 << MONO_TABLE_GENERICPARAM)
3753 | ((guint64)1 << MONO_TABLE_INTERFACEIMPL);
3754
3755 /* Compute table sizes */
3756 /* the MonoImage has already been created in mono_image_basic_init() */
3757 meta = &assembly->image;
3758
3759 /* sizes should be multiple of 4 */
3760 pad_heap (&assembly->blob);
3761 pad_heap (&assembly->guid);
3762 pad_heap (&assembly->sheap);
3763 pad_heap (&assembly->us);
3764
3765 /* Setup the info used by compute_sizes () */
3766 meta->idx_blob_wide = assembly->blob.index >= 65536 ? 1 : 0;
3767 meta->idx_guid_wide = assembly->guid.index >= 65536 ? 1 : 0;
3768 meta->idx_string_wide = assembly->sheap.index >= 65536 ? 1 : 0;
3769
3770 meta_size += assembly->blob.index;
3771 meta_size += assembly->guid.index;
3772 meta_size += assembly->sheap.index;
3773 meta_size += assembly->us.index;
3774
3775 for (i=0; i < MONO_TABLE_NUM; ++i)
3776 meta->tables [i].rows = assembly->tables [i].rows;
3777
3778 for (i = 0; i < MONO_TABLE_NUM; i++){
3779 if (meta->tables [i].rows == 0)
3780 continue;
3781 valid_mask |= (guint64)1 << i;
3782 ntables ++;
3783 meta->tables [i].row_size = mono_metadata_compute_size (
3784 meta, i, &meta->tables [i].size_bitfield);
3785 heapt_size += meta->tables [i].row_size * meta->tables [i].rows;
3786 }
3787 heapt_size += 24; /* #~ header size */
3788 heapt_size += ntables * 4;
3789 /* make multiple of 4 */
3790 heapt_size += 3;
3791 heapt_size &= ~3;
3792 meta_size += heapt_size;
3793 meta->raw_metadata = g_malloc0 (meta_size);
3794 p = (unsigned char*)meta->raw_metadata;
3795 /* the metadata signature */
3796 *p++ = 'B'; *p++ = 'S'; *p++ = 'J'; *p++ = 'B';
3797 /* version numbers and 4 bytes reserved */
3798 int16val = (guint16*)p;
3799 *int16val++ = GUINT16_TO_LE (meta->md_version_major);
3800 *int16val = GUINT16_TO_LE (meta->md_version_minor);
3801 p += 8;
3802 /* version string */
3803 int32val = (guint32*)p;
3804 *int32val = GUINT32_TO_LE ((strlen (meta->version) + 3) & (~3)); /* needs to be multiple of 4 */
3805 p += 4;
3806 memcpy (p, meta->version, strlen (meta->version));
3807 p += GUINT32_FROM_LE (*int32val);
3808 align_pointer (meta->raw_metadata, p);
3809 int16val = (guint16*)p;
3810 *int16val++ = GUINT16_TO_LE (0); /* flags must be 0 */
3811 *int16val = GUINT16_TO_LE (5); /* number of streams */
3812 p += 4;
3813
3814 /*
3815 * write the stream info.
3816 */
3817 table_offset = (p - (unsigned char*)meta->raw_metadata) + 5 * 8 + 40; /* room needed for stream headers */
3818 table_offset += 3; table_offset &= ~3;
3819
3820 assembly->tstream.index = heapt_size;
3821 for (i = 0; i < 5; ++i) {
3822 int32val = (guint32*)p;
3823 stream_desc [i].stream->offset = table_offset;
3824 *int32val++ = GUINT32_TO_LE (table_offset);
3825 *int32val = GUINT32_TO_LE (stream_desc [i].stream->index);
3826 table_offset += GUINT32_FROM_LE (*int32val);
3827 table_offset += 3; table_offset &= ~3;
3828 p += 8;
3829 strcpy ((char*)p, stream_desc [i].name);
3830 p += strlen (stream_desc [i].name) + 1;
3831 align_pointer (meta->raw_metadata, p);
3832 }
3833 /*
3834 * now copy the data, the table stream header and contents goes first.
3835 */
3836 g_assert ((p - (unsigned char*)meta->raw_metadata) < assembly->tstream.offset);
3837 p = (guchar*)meta->raw_metadata + assembly->tstream.offset;
3838 int32val = (guint32*)p;
3839 *int32val = GUINT32_TO_LE (0); /* reserved */
3840 p += 4;
3841
3842 if (mono_framework_version () > 1) {
3843 *p++ = 2; /* version */
3844 *p++ = 0;
3845 } else {
3846 *p++ = 1; /* version */
3847 *p++ = 0;
3848 }
3849
3850 if (meta->idx_string_wide)
3851 *p |= 0x01;
3852 if (meta->idx_guid_wide)
3853 *p |= 0x02;
3854 if (meta->idx_blob_wide)
3855 *p |= 0x04;
3856 ++p;
3857 *p++ = 1; /* reserved */
3858 int64val = (guint64*)p;
3859 *int64val++ = GUINT64_TO_LE (valid_mask);
3860 *int64val++ = GUINT64_TO_LE (valid_mask & sorted_mask); /* bitvector of sorted tables */
3861 p += 16;
3862 int32val = (guint32*)p;
3863 for (i = 0; i < MONO_TABLE_NUM; i++){
3864 if (meta->tables [i].rows == 0)
3865 continue;
3866 *int32val++ = GUINT32_TO_LE (meta->tables [i].rows);
3867 }
3868 p = (unsigned char*)int32val;
3869
3870 /* sort the tables that still need sorting */
3871 table = &assembly->tables [MONO_TABLE_CONSTANT];
3872 if (table->rows)
3873 qsort (table->values + MONO_CONSTANT_SIZE, table->rows, sizeof (guint32) * MONO_CONSTANT_SIZE, compare_constants);
3874 table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
3875 if (table->rows)
3876 qsort (table->values + MONO_METHOD_SEMA_SIZE, table->rows, sizeof (guint32) * MONO_METHOD_SEMA_SIZE, compare_semantics);
3877 table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
3878 if (table->rows)
3879 qsort (table->values + MONO_CUSTOM_ATTR_SIZE, table->rows, sizeof (guint32) * MONO_CUSTOM_ATTR_SIZE, compare_custom_attrs);
3880 table = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
3881 if (table->rows)
3882 qsort (table->values + MONO_FIELD_MARSHAL_SIZE, table->rows, sizeof (guint32) * MONO_FIELD_MARSHAL_SIZE, compare_field_marshal);
3883 table = &assembly->tables [MONO_TABLE_NESTEDCLASS];
3884 if (table->rows)
3885 qsort (table->values + MONO_NESTED_CLASS_SIZE, table->rows, sizeof (guint32) * MONO_NESTED_CLASS_SIZE, compare_nested);
3886 /* Section 21.11 DeclSecurity in Partition II doesn't specify this to be sorted by MS implementation requires it */
3887 table = &assembly->tables [MONO_TABLE_DECLSECURITY];
3888 if (table->rows)
3889 qsort (table->values + MONO_DECL_SECURITY_SIZE, table->rows, sizeof (guint32) * MONO_DECL_SECURITY_SIZE, compare_declsecurity_attrs);
3890 table = &assembly->tables [MONO_TABLE_INTERFACEIMPL];
3891 if (table->rows)
3892 qsort (table->values + MONO_INTERFACEIMPL_SIZE, table->rows, sizeof (guint32) * MONO_INTERFACEIMPL_SIZE, compare_interface_impl);
3893
3894 /* compress the tables */
3895 for (i = 0; i < MONO_TABLE_NUM; i++){
3896 int row, col;
3897 guint32 *values;
3898 guint32 bitfield = meta->tables [i].size_bitfield;
3899 if (!meta->tables [i].rows)
3900 continue;
3901 if (assembly->tables [i].columns != mono_metadata_table_count (bitfield))
3902 g_error ("col count mismatch in %d: %d %d", i, assembly->tables [i].columns, mono_metadata_table_count (bitfield));
3903 meta->tables [i].base = (char*)p;
3904 for (row = 1; row <= meta->tables [i].rows; ++row) {
3905 values = assembly->tables [i].values + row * assembly->tables [i].columns;
3906 for (col = 0; col < assembly->tables [i].columns; ++col) {
3907 switch (mono_metadata_table_size (bitfield, col)) {
3908 case 1:
3909 *p++ = values [col];
3910 break;
3911 case 2:
3912 *p++ = values [col] & 0xff;
3913 *p++ = (values [col] >> 8) & 0xff;
3914 break;
3915 case 4:
3916 *p++ = values [col] & 0xff;
3917 *p++ = (values [col] >> 8) & 0xff;
3918 *p++ = (values [col] >> 16) & 0xff;
3919 *p++ = (values [col] >> 24) & 0xff;
3920 break;
3921 default:
3922 g_assert_not_reached ();
3923 }
3924 }
3925 }
3926 g_assert ((p - (const unsigned char*)meta->tables [i].base) == (meta->tables [i].rows * meta->tables [i].row_size));
3927 }
3928
3929 g_assert (assembly->guid.offset + assembly->guid.index < meta_size);
3930 memcpy (meta->raw_metadata + assembly->sheap.offset, assembly->sheap.data, assembly->sheap.index);
3931 memcpy (meta->raw_metadata + assembly->us.offset, assembly->us.data, assembly->us.index);
3932 memcpy (meta->raw_metadata + assembly->blob.offset, assembly->blob.data, assembly->blob.index);
3933 memcpy (meta->raw_metadata + assembly->guid.offset, assembly->guid.data, assembly->guid.index);
3934
3935 assembly->meta_size = assembly->guid.offset + assembly->guid.index;
3936 }
3937
3938 /*
3939 * Some tables in metadata need to be sorted according to some criteria, but
3940 * when methods and fields are first created with reflection, they may be assigned a token
3941 * that doesn't correspond to the final token they will get assigned after the sorting.
3942 * ILGenerator.cs keeps a fixup table that maps the position of tokens in the IL code stream
3943 * with the reflection objects that represent them. Once all the tables are set up, the
3944 * reflection objects will contains the correct table index. fixup_method() will fixup the
3945 * tokens for the method with ILGenerator @ilgen.
3946 */
3947 static void
3948 fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *assembly)
3949 {
3950 guint32 code_idx = GPOINTER_TO_UINT (value);
3951 MonoReflectionILTokenInfo *iltoken;
3952 MonoReflectionFieldBuilder *field;
3953 MonoReflectionCtorBuilder *ctor;
3954 MonoReflectionMethodBuilder *method;
3955 MonoReflectionTypeBuilder *tb;
3956 MonoReflectionArrayMethod *am;
3957 guint32 i, idx = 0;
3958 unsigned char *target;
3959
3960 for (i = 0; i < ilgen->num_token_fixups; ++i) {
3961 iltoken = (MonoReflectionILTokenInfo *)mono_array_addr_with_size (ilgen->token_fixups, sizeof (MonoReflectionILTokenInfo), i);
3962 target = (guchar*)assembly->code.data + code_idx + iltoken->code_pos;
3963 switch (target [3]) {
3964 case MONO_TABLE_FIELD:
3965 if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
3966 field = (MonoReflectionFieldBuilder *)iltoken->member;
3967 idx = field->table_idx;
3968 } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) {
3969 MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field;
3970 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->field_to_table_idx, f));
3971 } else {
3972 g_assert_not_reached ();
3973 }
3974 break;
3975 case MONO_TABLE_METHOD:
3976 if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) {
3977 method = (MonoReflectionMethodBuilder *)iltoken->member;
3978 idx = method->table_idx;
3979 } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) {
3980 ctor = (MonoReflectionCtorBuilder *)iltoken->member;
3981 idx = ctor->table_idx;
3982 } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
3983 !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) {
3984 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
3985 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
3986 } else {
3987 g_assert_not_reached ();
3988 }
3989 break;
3990 case MONO_TABLE_TYPEDEF:
3991 if (strcmp (iltoken->member->vtable->klass->name, "TypeBuilder"))
3992 g_assert_not_reached ();
3993 tb = (MonoReflectionTypeBuilder *)iltoken->member;
3994 idx = tb->table_idx;
3995 break;
3996 case MONO_TABLE_MEMBERREF:
3997 if (!strcmp (iltoken->member->vtable->klass->name, "MonoArrayMethod")) {
3998 am = (MonoReflectionArrayMethod*)iltoken->member;
3999 idx = am->table_idx;
4000 } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
4001 !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod") ||
4002 !strcmp (iltoken->member->vtable->klass->name, "MonoGenericMethod") ||
4003 !strcmp (iltoken->member->vtable->klass->name, "MonoGenericCMethod")) {
4004 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
4005 g_assert (m->klass->generic_class || m->klass->generic_container);
4006 continue;
4007 } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
4008 continue;
4009 } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) {
4010 MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field;
4011 g_assert (is_field_on_inst (f));
4012 continue;
4013 } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder") ||
4014 !strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) {
4015 continue;
4016 } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldOnTypeBuilderInst")) {
4017 continue;
4018 } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodOnTypeBuilderInst")) {
4019 continue;
4020 } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorOnTypeBuilderInst")) {
4021 continue;
4022 } else {
4023 g_assert_not_reached ();
4024 }
4025 break;
4026 case MONO_TABLE_METHODSPEC:
4027 if (!strcmp (iltoken->member->vtable->klass->name, "MonoGenericMethod")) {
4028 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
4029 g_assert (mono_method_signature (m)->generic_param_count);
4030 continue;
4031 } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) {
4032 continue;
4033 } else {
4034 g_assert_not_reached ();
4035 }
4036 break;
4037 default:
4038 g_error ("got unexpected table 0x%02x in fixup", target [3]);
4039 }
4040 target [0] = idx & 0xff;
4041 target [1] = (idx >> 8) & 0xff;
4042 target [2] = (idx >> 16) & 0xff;
4043 }
4044 }
4045
4046 /*
4047 * fixup_cattrs:
4048 *
4049 * The CUSTOM_ATTRIBUTE table might contain METHODDEF tokens whose final
4050 * value is not known when the table is emitted.
4051 */
4052 static void
4053 fixup_cattrs (MonoDynamicImage *assembly)
4054 {
4055 MonoDynamicTable *table;
4056 guint32 *values;
4057 guint32 type, i, idx, token;
4058 MonoObject *ctor;
4059
4060 table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
4061
4062 for (i = 0; i < table->rows; ++i) {
4063 values = table->values + ((i + 1) * MONO_CUSTOM_ATTR_SIZE);
4064
4065 type = values [MONO_CUSTOM_ATTR_TYPE];
4066 if ((type & MONO_CUSTOM_ATTR_TYPE_MASK) == MONO_CUSTOM_ATTR_TYPE_METHODDEF) {
4067 idx = type >> MONO_CUSTOM_ATTR_TYPE_BITS;
4068 token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
4069 ctor = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
4070 g_assert (ctor);
4071
4072 if (!strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
4073 MonoMethod *m = ((MonoReflectionMethod*)ctor)->method;
4074 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
4075 values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
4076 }
4077 }
4078 }
4079 }
4080
4081 static void
4082 assembly_add_resource_manifest (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc, guint32 implementation)
4083 {
4084 MonoDynamicTable *table;
4085 guint32 *values;
4086
4087 table = &assembly->tables [MONO_TABLE_MANIFESTRESOURCE];
4088 table->rows++;
4089 alloc_table (table, table->rows);
4090 values = table->values + table->next_idx * MONO_MANIFEST_SIZE;
4091 values [MONO_MANIFEST_OFFSET] = rsrc->offset;
4092 values [MONO_MANIFEST_FLAGS] = rsrc->attrs;
4093 values [MONO_MANIFEST_NAME] = string_heap_insert_mstring (&assembly->sheap, rsrc->name);
4094 values [MONO_MANIFEST_IMPLEMENTATION] = implementation;
4095 table->next_idx++;
4096 }
4097
4098 static void
4099 assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc)
4100 {
4101 MonoDynamicTable *table;
4102 guint32 *values;
4103 char blob_size [6];
4104 guchar hash [20];
4105 char *b = blob_size;
4106 char *name, *sname;
4107 guint32 idx, offset;
4108
4109 if (rsrc->filename) {
4110 name = mono_string_to_utf8 (rsrc->filename);
4111 sname = g_path_get_basename (name);
4112
4113 table = &assembly->tables [MONO_TABLE_FILE];
4114 table->rows++;
4115 alloc_table (table, table->rows);
4116 values = table->values + table->next_idx * MONO_FILE_SIZE;
4117 values [MONO_FILE_FLAGS] = FILE_CONTAINS_NO_METADATA;
4118 values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, sname);
4119 g_free (sname);
4120
4121 mono_sha1_get_digest_from_file (name, hash);
4122 mono_metadata_encode_value (20, b, &b);
4123 values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
4124 mono_image_add_stream_data (&assembly->blob, (char*)hash, 20);
4125 g_free (name);
4126 idx = table->next_idx++;
4127 rsrc->offset = 0;
4128 idx = MONO_IMPLEMENTATION_FILE | (idx << MONO_IMPLEMENTATION_BITS);
4129 } else {
4130 char sizebuf [4];
4131 char *data;
4132 guint len;
4133 if (rsrc->data) {
4134 data = mono_array_addr (rsrc->data, char, 0);
4135 len = mono_array_length (rsrc->data);
4136 } else {
4137 data = NULL;
4138 len = 0;
4139 }
4140 offset = len;
4141 sizebuf [0] = offset; sizebuf [1] = offset >> 8;
4142 sizebuf [2] = offset >> 16; sizebuf [3] = offset >> 24;
4143 rsrc->offset = mono_image_add_stream_data (&assembly->resources, sizebuf, 4);
4144 mono_image_add_stream_data (&assembly->resources, data, len);
4145
4146 if (!mb->is_main)
4147 /*
4148 * The entry should be emitted into the MANIFESTRESOURCE table of
4149 * the main module, but that needs to reference the FILE table
4150 * which isn't emitted yet.
4151 */
4152 return;
4153 else
4154 idx = 0;
4155 }
4156
4157 assembly_add_resource_manifest (mb, assembly, rsrc, idx);
4158 }
4159
4160 static void
4161 set_version_from_string (MonoString *version, guint32 *values)
4162 {
4163 gchar *ver, *p, *str;
4164 guint32 i;
4165
4166 values [MONO_ASSEMBLY_MAJOR_VERSION] = 0;
4167 values [MONO_ASSEMBLY_MINOR_VERSION] = 0;
4168 values [MONO_ASSEMBLY_REV_NUMBER] = 0;
4169 values [MONO_ASSEMBLY_BUILD_NUMBER] = 0;
4170 if (!version)
4171 return;
4172 ver = str = mono_string_to_utf8 (version);
4173 for (i = 0; i < 4; ++i) {
4174 values [MONO_ASSEMBLY_MAJOR_VERSION + i] = strtol (ver, &p, 10);
4175 switch (*p) {
4176 case '.':
4177 p++;
4178 break;
4179 case '*':
4180 /* handle Revision and Build */
4181 p++;
4182 break;
4183 }
4184 ver = p;
4185 }
4186 g_free (str);
4187 }
4188
4189 static guint32
4190 load_public_key (MonoArray *pkey, MonoDynamicImage *assembly) {
4191 gsize len;
4192 guint32 token = 0;
4193 char blob_size [6];
4194 char *b = blob_size;
4195
4196 if (!pkey)
4197 return token;
4198
4199 len = mono_array_length (pkey);
4200 mono_metadata_encode_value (len, b, &b);
4201 token = mono_image_add_stream_data (&assembly->blob, blob_size, b - blob_size);
4202 mono_image_add_stream_data (&assembly->blob, mono_array_addr (pkey, char, 0), len);
4203
4204 assembly->public_key = g_malloc (len);
4205 memcpy (assembly->public_key, mono_array_addr (pkey, char, 0), len);
4206 assembly->public_key_len = len;
4207
4208 /* Special case: check for ECMA key (16 bytes) */
4209 if ((len == MONO_ECMA_KEY_LENGTH) && mono_is_ecma_key (mono_array_addr (pkey, char, 0), len)) {
4210 /* In this case we must reserve 128 bytes (1024 bits) for the signature */
4211 assembly->strong_name_size = MONO_DEFAULT_PUBLIC_KEY_LENGTH;
4212 } else if (len >= MONO_PUBLIC_KEY_HEADER_LENGTH + MONO_MINIMUM_PUBLIC_KEY_LENGTH) {
4213 /* minimum key size (in 2.0) is 384 bits */
4214 assembly->strong_name_size = len - MONO_PUBLIC_KEY_HEADER_LENGTH;
4215 } else {
4216 /* FIXME - verifier */
4217 g_warning ("Invalid public key length: %d bits (total: %d)", (int)MONO_PUBLIC_KEY_BIT_SIZE (len), (int)len);
4218 assembly->strong_name_size = MONO_DEFAULT_PUBLIC_KEY_LENGTH; /* to be safe */
4219 }
4220 assembly->strong_name = g_malloc0 (assembly->strong_name_size);
4221
4222 return token;
4223 }
4224
4225 static void
4226 mono_image_emit_manifest (MonoReflectionModuleBuilder *moduleb)
4227 {
4228 MonoDynamicTable *table;
4229 MonoDynamicImage *assembly;
4230 MonoReflectionAssemblyBuilder *assemblyb;
4231 MonoDomain *domain;
4232 guint32 *values;
4233 int i;
4234 guint32 module_index;
4235
4236 assemblyb = moduleb->assemblyb;
4237 assembly = moduleb->dynamic_image;
4238 domain = mono_object_domain (assemblyb);
4239
4240 /* Emit ASSEMBLY table */
4241 table = &assembly->tables [MONO_TABLE_ASSEMBLY];
4242 alloc_table (table, 1);
4243 values = table->values + MONO_ASSEMBLY_SIZE;
4244 values [MONO_ASSEMBLY_HASH_ALG] = assemblyb->algid? assemblyb->algid: ASSEMBLY_HASH_SHA1;
4245 values [MONO_ASSEMBLY_NAME] = string_heap_insert_mstring (&assembly->sheap, assemblyb->name);
4246 if (assemblyb->culture) {
4247 values [MONO_ASSEMBLY_CULTURE] = string_heap_insert_mstring (&assembly->sheap, assemblyb->culture);
4248 } else {
4249 values [MONO_ASSEMBLY_CULTURE] = string_heap_insert (&assembly->sheap, "");
4250 }
4251 values [MONO_ASSEMBLY_PUBLIC_KEY] = load_public_key (assemblyb->public_key, assembly);
4252 values [MONO_ASSEMBLY_FLAGS] = assemblyb->flags;
4253 set_version_from_string (assemblyb->version, values);
4254
4255 /* Emit FILE + EXPORTED_TYPE table */
4256 module_index = 0;
4257 for (i = 0; i < mono_array_length (assemblyb->modules); ++i) {
4258 int j;
4259 MonoReflectionModuleBuilder *file_module =
4260 mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
4261 if (file_module != moduleb) {
4262 mono_image_fill_file_table (domain, (MonoReflectionModule*)file_module, assembly);
4263 module_index ++;
4264 if (file_module->types) {
4265 for (j = 0; j < file_module->num_types; ++j) {
4266 MonoReflectionTypeBuilder *tb = mono_array_get (file_module->types, MonoReflectionTypeBuilder*, j);
4267 mono_image_fill_export_table (domain, tb, module_index, 0, assembly);
4268 }
4269 }
4270 }
4271 }
4272 if (assemblyb->loaded_modules) {
4273 for (i = 0; i < mono_array_length (assemblyb->loaded_modules); ++i) {
4274 MonoReflectionModule *file_module =
4275 mono_array_get (assemblyb->loaded_modules, MonoReflectionModule*, i);
4276 mono_image_fill_file_table (domain, file_module, assembly);
4277 module_index ++;
4278 mono_image_fill_export_table_from_module (domain, file_module, module_index, assembly);
4279 }
4280 }
4281 if (assemblyb->type_forwarders)
4282 mono_image_fill_export_table_from_type_forwarders (assemblyb, assembly);
4283
4284 /* Emit MANIFESTRESOURCE table */
4285 module_index = 0;
4286 for (i = 0; i < mono_array_length (assemblyb->modules); ++i) {
4287 int j;
4288 MonoReflectionModuleBuilder *file_module =
4289 mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
4290 /* The table for the main module is emitted later */
4291 if (file_module != moduleb) {
4292 module_index ++;
4293 if (file_module->resources) {
4294 int len = mono_array_length (file_module->resources);
4295 for (j = 0; j < len; ++j) {
4296 MonoReflectionResource* res = (MonoReflectionResource*)mono_array_addr (file_module->resources, MonoReflectionResource, j);
4297 assembly_add_resource_manifest (file_module, assembly, res, MONO_IMPLEMENTATION_FILE | (module_index << MONO_IMPLEMENTATION_BITS));
4298 }
4299 }
4300 }
4301 }
4302 }
4303
4304 #ifndef DISABLE_REFLECTION_EMIT_SAVE
4305
4306 /*
4307 * mono_image_build_metadata() will fill the info in all the needed metadata tables
4308 * for the modulebuilder @moduleb.
4309 * At the end of the process, method and field tokens are fixed up and the
4310 * on-disk compressed metadata representation is created.
4311 */
4312 void
4313 mono_image_build_metadata (MonoReflectionModuleBuilder *moduleb)
4314 {
4315 MonoDynamicTable *table;
4316 MonoDynamicImage *assembly;
4317 MonoReflectionAssemblyBuilder *assemblyb;
4318 MonoDomain *domain;
4319 GPtrArray *types;
4320 guint32 *values;
4321 int i, j;
4322
4323 assemblyb = moduleb->assemblyb;
4324 assembly = moduleb->dynamic_image;
4325 domain = mono_object_domain (assemblyb);
4326
4327 if (assembly->text_rva)
4328 return;
4329
4330 assembly->text_rva = START_TEXT_RVA;
4331
4332 if (moduleb->is_main) {
4333 mono_image_emit_manifest (moduleb);
4334 }
4335
4336 table = &assembly->tables [MONO_TABLE_TYPEDEF];
4337 table->rows = 1; /* .<Module> */
4338 table->next_idx++;
4339 alloc_table (table, table->rows);
4340 /*
4341 * Set the first entry.
4342 */
4343 values = table->values + table->columns;
4344 values [MONO_TYPEDEF_FLAGS] = 0;
4345 values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, "<Module>") ;
4346 values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, "") ;
4347 values [MONO_TYPEDEF_EXTENDS] = 0;
4348 values [MONO_TYPEDEF_FIELD_LIST] = 1;
4349 values [MONO_TYPEDEF_METHOD_LIST] = 1;
4350
4351 /*
4352 * handle global methods
4353 * FIXME: test what to do when global methods are defined in multiple modules.
4354 */
4355 if (moduleb->global_methods) {
4356 table = &assembly->tables [MONO_TABLE_METHOD];
4357 table->rows += mono_array_length (moduleb->global_methods);
4358 alloc_table (table, table->rows);
4359 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i)
4360 mono_image_get_method_info (
4361 mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i), assembly);
4362 }
4363 if (moduleb->global_fields) {
4364 table = &assembly->tables [MONO_TABLE_FIELD];
4365 table->rows += mono_array_length (moduleb->global_fields);
4366 alloc_table (table, table->rows);
4367 for (i = 0; i < mono_array_length (moduleb->global_fields); ++i)
4368 mono_image_get_field_info (
4369 mono_array_get (moduleb->global_fields, MonoReflectionFieldBuilder*, i), assembly);
4370 }
4371
4372 table = &assembly->tables [MONO_TABLE_MODULE];
4373 alloc_table (table, 1);
4374 mono_image_fill_module_table (domain, moduleb, assembly);
4375
4376 /* Collect all types into a list sorted by their table_idx */
4377 types = g_ptr_array_new ();
4378
4379 if (moduleb->types)
4380 for (i = 0; i < moduleb->num_types; ++i) {
4381 MonoReflectionTypeBuilder *type = mono_array_get (moduleb->types, MonoReflectionTypeBuilder*, i);
4382 collect_types (types, type);
4383 }
4384
4385 g_ptr_array_sort (types, (GCompareFunc)compare_types_by_table_idx);
4386 table = &assembly->tables [MONO_TABLE_TYPEDEF];
4387 table->rows += types->len;
4388 alloc_table (table, table->rows);
4389
4390 /*
4391 * Emit type names + namespaces at one place inside the string heap,
4392 * so load_class_names () needs to touch fewer pages.
4393 */
4394 for (i = 0; i < types->len; ++i) {
4395 MonoReflectionTypeBuilder *tb = g_ptr_array_index (types, i);
4396 string_heap_insert_mstring (&assembly->sheap, tb->nspace);
4397 }
4398 for (i = 0; i < types->len; ++i) {
4399 MonoReflectionTypeBuilder *tb = g_ptr_array_index (types, i);
4400 string_heap_insert_mstring (&assembly->sheap, tb->name);
4401 }
4402
4403 for (i = 0; i < types->len; ++i) {
4404 MonoReflectionTypeBuilder *type = g_ptr_array_index (types, i);
4405 mono_image_get_type_info (domain, type, assembly);
4406 }
4407
4408 /*
4409 * table->rows is already set above and in mono_image_fill_module_table.
4410 */
4411 /* add all the custom attributes at the end, once all the indexes are stable */
4412 mono_image_add_cattrs (assembly, 1, MONO_CUSTOM_ATTR_ASSEMBLY, assemblyb->cattrs);
4413
4414 /* CAS assembly permissions */
4415 if (assemblyb->permissions_minimum)
4416 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_minimum);
4417 if (assemblyb->permissions_optional)
4418 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_optional);
4419 if (assemblyb->permissions_refused)
4420 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_refused);
4421
4422 module_add_cattrs (assembly, moduleb);
4423
4424 /* fixup tokens */
4425 mono_g_hash_table_foreach (assembly->token_fixups, (GHFunc)fixup_method, assembly);
4426
4427 /* Create the MethodImpl table. We do this after emitting all methods so we already know
4428 * the final tokens and don't need another fixup pass. */
4429
4430 if (moduleb->global_methods) {
4431 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
4432 MonoReflectionMethodBuilder *mb = mono_array_get (
4433 moduleb->global_methods, MonoReflectionMethodBuilder*, i);
4434 mono_image_add_methodimpl (assembly, mb);
4435 }
4436 }
4437
4438 for (i = 0; i < types->len; ++i) {
4439 MonoReflectionTypeBuilder *type = g_ptr_array_index (types, i);
4440 if (type->methods) {
4441 for (j = 0; j < type->num_methods; ++j) {
4442 MonoReflectionMethodBuilder *mb = mono_array_get (
4443 type->methods, MonoReflectionMethodBuilder*, j);
4444
4445 mono_image_add_methodimpl (assembly, mb);
4446 }
4447 }
4448 }
4449
4450 g_ptr_array_free (types, TRUE);
4451
4452 fixup_cattrs (assembly);
4453 }
4454
4455 #else /* DISABLE_REFLECTION_EMIT_SAVE */
4456
4457 void
4458 mono_image_build_metadata (MonoReflectionModuleBuilder *moduleb)
4459 {
4460 g_error ("This mono runtime was configured with --enable-minimal=reflection_emit_save, so saving of dynamic assemblies is not supported.");
4461 }
4462
4463 #endif /* DISABLE_REFLECTION_EMIT_SAVE */
4464
4465
4466 typedef struct {
4467 guint32 import_lookup_table;
4468 guint32 timestamp;
4469 guint32 forwarder;
4470 guint32 name_rva;
4471 guint32 import_address_table_rva;
4472 } MonoIDT;
4473
4474 typedef struct {
4475 guint32 name_rva;
4476 guint32 flags;
4477 } MonoILT;
4478
4479 #ifndef DISABLE_REFLECTION_EMIT
4480
4481 /*
4482 * mono_image_insert_string:
4483 * @module: module builder object
4484 * @str: a string
4485 *
4486 * Insert @str into the user string stream of @module.
4487 */
4488 guint32
4489 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str)
4490 {
4491 MonoDynamicImage *assembly;
4492 guint32 idx;
4493 char buf [16];
4494 char *b = buf;
4495
4496 MONO_ARCH_SAVE_REGS;
4497
4498 if (!module->dynamic_image)
4499 mono_image_module_basic_init (module);
4500
4501 assembly = module->dynamic_image;
4502
4503 if (assembly->save) {
4504 mono_metadata_encode_value (1 | (str->length * 2), b, &b);
4505 idx = mono_image_add_stream_data (&assembly->us, buf, b-buf);
4506 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
4507 {
4508 char *swapped = g_malloc (2 * mono_string_length (str));
4509 const char *p = (const char*)mono_string_chars (str);
4510
4511 swap_with_size (swapped, p, 2, mono_string_length (str));
4512 mono_image_add_stream_data (&assembly->us, swapped, str->length * 2);
4513 g_free (swapped);
4514 }
4515 #else
4516 mono_image_add_stream_data (&assembly->us, (const char*)mono_string_chars (str), str->length * 2);
4517 #endif
4518 mono_image_add_stream_data (&assembly->us, "", 1);
4519 } else {
4520 idx = assembly->us.index ++;
4521 }
4522
4523 mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (MONO_TOKEN_STRING | idx), str);
4524
4525 return MONO_TOKEN_STRING | idx;
4526 }
4527
4528 guint32
4529 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types)
4530 {
4531 MonoClass *klass;
4532 guint32 token = 0;
4533
4534 klass = obj->vtable->klass;
4535 if (strcmp (klass->name, "MonoMethod") == 0) {
4536 MonoMethod *method = ((MonoReflectionMethod *)obj)->method;
4537 MonoMethodSignature *sig, *old;
4538 guint32 sig_token, parent;
4539 int nargs, i;
4540
4541 g_assert (opt_param_types && (mono_method_signature (method)->sentinelpos >= 0));
4542
4543 nargs = mono_array_length (opt_param_types);
4544 old = mono_method_signature (method);
4545 sig = mono_metadata_signature_alloc ( &assembly->image, old->param_count + nargs);
4546
4547 sig->hasthis = old->hasthis;
4548 sig->explicit_this = old->explicit_this;
4549 sig->call_convention = old->call_convention;
4550 sig->generic_param_count = old->generic_param_count;
4551 sig->param_count = old->param_count + nargs;
4552 sig->sentinelpos = old->param_count;
4553 sig->ret = old->ret;
4554
4555 for (i = 0; i < old->param_count; i++)
4556 sig->params [i] = old->params [i];
4557
4558 for (i = 0; i < nargs; i++) {
4559 MonoReflectionType *rt = mono_array_get (opt_param_types, MonoReflectionType *, i);
4560 sig->params [old->param_count + i] = rt->type;
4561 }
4562
4563 parent = mono_image_typedef_or_ref (assembly, &method->klass->byval_arg);
4564 g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF);
4565 parent >>= MONO_TYPEDEFORREF_BITS;
4566
4567 parent <<= MONO_MEMBERREF_PARENT_BITS;
4568 parent |= MONO_MEMBERREF_PARENT_TYPEREF;
4569
4570 sig_token = method_encode_signature (assembly, sig);
4571 token = mono_image_get_varargs_method_token (assembly, parent, method->name, sig_token);
4572 } else if (strcmp (klass->name, "MethodBuilder") == 0) {
4573 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
4574 ReflectionMethodBuilder rmb;
4575 guint32 parent, sig;
4576 char *name;
4577
4578 reflection_methodbuilder_from_method_builder (&rmb, mb);
4579 rmb.opt_types = opt_param_types;
4580
4581 sig = method_builder_encode_signature (assembly, &rmb);
4582
4583 parent = mono_image_create_token (assembly, obj, TRUE, TRUE);
4584 g_assert (mono_metadata_token_table (parent) == MONO_TABLE_METHOD);
4585
4586 parent = mono_metadata_token_index (parent) << MONO_MEMBERREF_PARENT_BITS;
4587 parent |= MONO_MEMBERREF_PARENT_METHODDEF;
4588
4589 name = mono_string_to_utf8 (rmb.name);
4590 token = mono_image_get_varargs_method_token (
4591 assembly, parent, name, sig);
4592 g_free (name);
4593 } else {
4594 g_error ("requested method token for %s\n", klass->name);
4595 }
4596
4597 return token;
4598 }
4599
4600 /*
4601 * mono_image_create_token:
4602 * @assembly: a dynamic assembly
4603 * @obj:
4604 * @register_token: Whenever to register the token in the assembly->tokens hash.
4605 *
4606 * Get a token to insert in the IL code stream for the given MemberInfo.
4607 * The metadata emission routines need to pass FALSE as REGISTER_TOKEN, since by that time,
4608 * the table_idx-es were recomputed, so registering the token would overwrite an existing
4609 * entry.
4610 */
4611 guint32
4612 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj,
4613 gboolean create_methodspec, gboolean register_token)
4614 {
4615 MonoClass *klass;
4616 guint32 token = 0;
4617
4618 klass = obj->vtable->klass;
4619
4620 /* Check for user defined reflection objects */
4621 /* TypeDelegator is the only corlib type which doesn't look like a MonoReflectionType */
4622 if (klass->image != mono_defaults.corlib || (strcmp (klass->name, "TypeDelegator") == 0))
4623 mono_raise_exception (mono_get_exception_not_supported ("User defined subclasses of System.Type are not yet supported")); \
4624
4625 if (strcmp (klass->name, "MethodBuilder") == 0) {
4626 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
4627 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type;
4628
4629 if (tb->module->dynamic_image == assembly && !tb->generic_params && !mb->generic_params)
4630 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
4631 else
4632 token = mono_image_get_methodbuilder_token (assembly, mb, create_methodspec);
4633 /*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
4634 } else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
4635 MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
4636 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type;
4637
4638 if (tb->module->dynamic_image == assembly && !tb->generic_params)
4639 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
4640 else
4641 token = mono_image_get_ctorbuilder_token (assembly, mb);
4642 /*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
4643 } else if (strcmp (klass->name, "FieldBuilder") == 0) {
4644 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
4645 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)fb->typeb;
4646 if (tb->generic_params) {
4647 token = mono_image_get_generic_field_token (assembly, fb);
4648 } else {
4649 token = fb->table_idx | MONO_TOKEN_FIELD_DEF;
4650 }
4651 } else if (strcmp (klass->name, "TypeBuilder") == 0) {
4652 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
4653 token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
4654 } else if (strcmp (klass->name, "MonoType") == 0) {
4655 MonoReflectionType *tb = (MonoReflectionType *)obj;
4656 MonoClass *mc = mono_class_from_mono_type (tb->type);
4657 token = mono_metadata_token_from_dor (
4658 mono_image_typedef_or_ref_full (assembly, tb->type, mc->generic_container == NULL));
4659 } else if (strcmp (klass->name, "GenericTypeParameterBuilder") == 0) {
4660 MonoReflectionType *tb = (MonoReflectionType *)obj;
4661 token = mono_metadata_token_from_dor (
4662 mono_image_typedef_or_ref (assembly, tb->type));
4663 } else if (strcmp (klass->name, "MonoGenericClass") == 0) {
4664 MonoReflectionType *tb = (MonoReflectionType *)obj;
4665 token = mono_metadata_token_from_dor (
4666 mono_image_typedef_or_ref (assembly, tb->type));
4667 } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
4668 strcmp (klass->name, "MonoMethod") == 0 ||
4669 strcmp (klass->name, "MonoGenericMethod") == 0 ||
4670 strcmp (klass->name, "MonoGenericCMethod") == 0) {
4671 MonoReflectionMethod *m = (MonoReflectionMethod *)obj;
4672 if (m->method->is_inflated) {
4673 if (create_methodspec)
4674 token = mono_image_get_methodspec_token (assembly, m->method);
4675 else
4676 token = mono_image_get_inflated_method_token (assembly, m->method);
4677 } else if ((m->method->klass->image == &assembly->image) &&
4678 !m->method->klass->generic_class) {
4679 static guint32 method_table_idx = 0xffffff;
4680 if (m->method->klass->wastypebuilder) {
4681 /* we use the same token as the one that was assigned
4682 * to the Methodbuilder.
4683 * FIXME: do the equivalent for Fields.
4684 */
4685 token = m->method->token;
4686 } else {
4687 /*
4688 * Each token should have a unique index, but the indexes are
4689 * assigned by managed code, so we don't know about them. An
4690 * easy solution is to count backwards...
4691 */
4692 method_table_idx --;
4693 token = MONO_TOKEN_METHOD_DEF | method_table_idx;
4694 }
4695 } else {
4696 token = mono_image_get_methodref_token (assembly, m->method, create_methodspec);
4697 }
4698 /*g_print ("got token 0x%08x for %s\n", token, m->method->name);*/
4699 } else if (strcmp (klass->name, "MonoField") == 0) {
4700 MonoReflectionField *f = (MonoReflectionField *)obj;
4701 if ((f->field->parent->image == &assembly->image) && !is_field_on_inst (f->field)) {
4702 static guint32 field_table_idx = 0xffffff;
4703 field_table_idx --;
4704 token = MONO_TOKEN_FIELD_DEF | field_table_idx;
4705 } else {
4706 token = mono_image_get_fieldref_token (assembly, f);
4707 }
4708 /*g_print ("got token 0x%08x for %s\n", token, f->field->name);*/
4709 } else if (strcmp (klass->name, "MonoArrayMethod") == 0) {
4710 MonoReflectionArrayMethod *m = (MonoReflectionArrayMethod *)obj;
4711 token = mono_image_get_array_token (assembly, m);
4712 } else if (strcmp (klass->name, "SignatureHelper") == 0) {
4713 MonoReflectionSigHelper *s = (MonoReflectionSigHelper*)obj;
4714 token = MONO_TOKEN_SIGNATURE | mono_image_get_sighelper_token (assembly, s);
4715 } else if (strcmp (klass->name, "EnumBuilder") == 0) {
4716 MonoReflectionType *tb = (MonoReflectionType *)obj;
4717 token = mono_metadata_token_from_dor (
4718 mono_image_typedef_or_ref (assembly, tb->type));
4719 } else if (strcmp (klass->name, "FieldOnTypeBuilderInst") == 0) {
4720 MonoReflectionFieldOnTypeBuilderInst *f = (MonoReflectionFieldOnTypeBuilderInst*)obj;
4721 token = mono_image_get_field_on_inst_token (assembly, f);
4722 } else if (strcmp (klass->name, "ConstructorOnTypeBuilderInst") == 0) {
4723 MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)obj;
4724 token = mono_image_get_ctor_on_inst_token (assembly, c, create_methodspec);
4725 } else if (strcmp (klass->name, "MethodOnTypeBuilderInst") == 0) {
4726 MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj;
4727 token = mono_image_get_method_on_inst_token (assembly, m, create_methodspec);
4728 } else {
4729 g_error ("requested token for %s\n", klass->name);
4730 }
4731
4732 if (register_token)
4733 mono_image_register_token (assembly, token, obj);
4734
4735 return token;
4736 }
4737
4738 /*
4739 * mono_image_register_token:
4740 *
4741 * Register the TOKEN->OBJ mapping in the mapping table in ASSEMBLY. This is required for
4742 * the Module.ResolveXXXToken () methods to work.
4743 */
4744 void
4745 mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj)
4746 {
4747 MonoObject *prev = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
4748 if (prev) {
4749 /* There could be multiple MethodInfo objects with the same token */
4750 //g_assert (prev == obj);
4751 } else {
4752 mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), obj);
4753 }
4754 }
4755
4756 static MonoDynamicImage*
4757 create_dynamic_mono_image (MonoDynamicAssembly *assembly, char *assembly_name, char *module_name)
4758 {
4759 static const guchar entrycode [16] = {0xff, 0x25, 0};
4760 MonoDynamicImage *image;
4761 int i;
4762
4763 const char *version;
4764
4765 if (!strcmp (mono_get_runtime_info ()->framework_version, "2.1"))
4766 version = "v2.0.50727"; /* HACK: SL 2 enforces the .net 2 metadata version */
4767 else
4768 version = mono_get_runtime_info ()->runtime_version;
4769
4770 #if HAVE_BOEHM_GC
4771 image = GC_MALLOC (sizeof (MonoDynamicImage));
4772 #else
4773 image = g_new0 (MonoDynamicImage, 1);
4774 #endif
4775
4776 mono_profiler_module_event (&image->image, MONO_PROFILE_START_LOAD);
4777
4778 /*g_print ("created image %p\n", image);*/
4779 /* keep in sync with image.c */
4780 image->image.name = assembly_name;
4781 image->image.assembly_name = image->image.name; /* they may be different */
4782 image->image.module_name = module_name;
4783 image->image.version = g_strdup (version);
4784 image->image.md_version_major = 1;
4785 image->image.md_version_minor = 1;
4786 image->image.dynamic = TRUE;
4787
4788 image->image.references = g_new0 (MonoAssembly*, 1);
4789 image->image.references [0] = NULL;
4790
4791 mono_image_init (&image->image);
4792
4793 image->token_fixups = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC);
4794 image->method_to_table_idx = g_hash_table_new (NULL, NULL);
4795 image->field_to_table_idx = g_hash_table_new (NULL, NULL);
4796 image->method_aux_hash = g_hash_table_new (NULL, NULL);
4797 image->handleref = g_hash_table_new (NULL, NULL);
4798 image->tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC);
4799 image->generic_def_objects = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC);
4800 image->methodspec = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC);
4801 image->typespec = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
4802 image->typeref = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
4803 image->blob_cache = g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal);
4804 image->gen_params = g_ptr_array_new ();
4805
4806 /*g_print ("string heap create for image %p (%s)\n", image, module_name);*/
4807 string_heap_init (&image->sheap);
4808 mono_image_add_stream_data (&image->us, "", 1);
4809 add_to_blob_cached (image, (char*) "", 1, NULL, 0);
4810 /* import tables... */
4811 mono_image_add_stream_data (&image->code, (char*)entrycode, sizeof (entrycode));
4812 image->iat_offset = mono_image_add_stream_zero (&image->code, 8); /* two IAT entries */
4813 image->idt_offset = mono_image_add_stream_zero (&image->code, 2 * sizeof (MonoIDT)); /* two IDT entries */
4814 image->imp_names_offset = mono_image_add_stream_zero (&image->code, 2); /* flags for name entry */
4815 mono_image_add_stream_data (&image->code, "_CorExeMain", 12);
4816 mono_image_add_stream_data (&image->code, "mscoree.dll", 12);
4817 image->ilt_offset = mono_image_add_stream_zero (&image->code, 8); /* two ILT entries */
4818 stream_data_align (&image->code);
4819
4820 image->cli_header_offset = mono_image_add_stream_zero (&image->code, sizeof (MonoCLIHeader));
4821
4822 for (i=0; i < MONO_TABLE_NUM; ++i) {
4823 image->tables [i].next_idx = 1;
4824 image->tables [i].columns = table_sizes [i];
4825 }
4826
4827 image->image.assembly = (MonoAssembly*)assembly;
4828 image->run = assembly->run;
4829 image->save = assembly->save;
4830 image->pe_kind = 0x1; /* ILOnly */
4831 image->machine = 0x14c; /* I386 */
4832
4833 mono_profiler_module_loaded (&image->image, MONO_PROFILE_OK);
4834
4835 return image;
4836 }
4837 #endif
4838
4839 static void
4840 free_blob_cache_entry (gpointer key, gpointer val, gpointer user_data)
4841 {
4842 g_free (key);
4843 }
4844
4845 void
4846 mono_dynamic_image_free (MonoDynamicImage *image)
4847 {
4848 MonoDynamicImage *di = image;
4849 GList *list;
4850 int i;
4851
4852 if (di->methodspec)
4853 mono_g_hash_table_destroy (di->methodspec);
4854 if (di->typespec)
4855 g_hash_table_destroy (di->typespec);
4856 if (di->typeref)
4857 g_hash_table_destroy (di->typeref);
4858 if (di->handleref)
4859 g_hash_table_destroy (di->handleref);
4860 if (di->tokens)
4861 mono_g_hash_table_destroy (di->tokens);
4862 if (di->generic_def_objects)
4863 mono_g_hash_table_destroy (di->generic_def_objects);
4864 if (di->blob_cache) {
4865 g_hash_table_foreach (di->blob_cache, free_blob_cache_entry, NULL);
4866 g_hash_table_destroy (di->blob_cache);
4867 }
4868 if (di->standalonesig_cache)
4869 g_hash_table_destroy (di->standalonesig_cache);
4870 for (list = di->array_methods; list; list = list->next) {
4871 ArrayMethod *am = (ArrayMethod *)list->data;
4872 g_free (am->sig);
4873 g_free (am->name);
4874 g_free (am);
4875 }
4876 g_list_free (di->array_methods);
4877 if (di->gen_params) {
4878 for (i = 0; i < di->gen_params->len; i++) {
4879 GenericParamTableEntry *entry = g_ptr_array_index (di->gen_params, i);
4880 if (entry->gparam->type.type) {
4881 MonoGenericParam *param = entry->gparam->type.type->data.generic_param;
4882 g_free ((char*)mono_generic_param_info (param)->name);
4883 g_free (param);
4884 }
4885 g_free (entry);
4886 }
4887 g_ptr_array_free (di->gen_params, TRUE);
4888 }
4889 if (di->token_fixups)
4890 mono_g_hash_table_destroy (di->token_fixups);
4891 if (di->method_to_table_idx)
4892 g_hash_table_destroy (di->method_to_table_idx);
4893 if (di->field_to_table_idx)
4894 g_hash_table_destroy (di->field_to_table_idx);
4895 if (di->method_aux_hash)
4896 g_hash_table_destroy (di->method_aux_hash);
4897 g_free (di->strong_name);
4898 g_free (di->win32_res);
4899 if (di->public_key)
4900 g_free (di->public_key);
4901
4902 /*g_print ("string heap destroy for image %p\n", di);*/
4903 mono_dynamic_stream_reset (&di->sheap);
4904 mono_dynamic_stream_reset (&di->code);
4905 mono_dynamic_stream_reset (&di->resources);
4906 mono_dynamic_stream_reset (&di->us);
4907 mono_dynamic_stream_reset (&di->blob);
4908 mono_dynamic_stream_reset (&di->tstream);
4909 mono_dynamic_stream_reset (&di->guid);
4910 for (i = 0; i < MONO_TABLE_NUM; ++i) {
4911 g_free (di->tables [i].values);
4912 }
4913 }
4914
4915 #ifndef DISABLE_REFLECTION_EMIT
4916
4917 /*
4918 * mono_image_basic_init:
4919 * @assembly: an assembly builder object
4920 *
4921 * Create the MonoImage that represents the assembly builder and setup some
4922 * of the helper hash table and the basic metadata streams.
4923 */
4924 void
4925 mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
4926 {
4927 MonoDynamicAssembly *assembly;
4928 MonoDynamicImage *image;
4929 MonoDomain *domain = mono_object_domain (assemblyb);
4930
4931 MONO_ARCH_SAVE_REGS;
4932
4933 if (assemblyb->dynamic_assembly)
4934 return;
4935
4936 #if HAVE_BOEHM_GC
4937 assembly = assemblyb->dynamic_assembly = GC_MALLOC (sizeof (MonoDynamicAssembly));
4938 #else
4939 assembly = assemblyb->dynamic_assembly = g_new0 (MonoDynamicAssembly, 1);
4940 #endif
4941
4942 mono_profiler_assembly_event (&assembly->assembly, MONO_PROFILE_START_LOAD);
4943
4944 assembly->assembly.ref_count = 1;
4945 assembly->assembly.dynamic = TRUE;
4946 assembly->assembly.corlib_internal = assemblyb->corlib_internal;
4947 assemblyb->assembly.assembly = (MonoAssembly*)assembly;
4948 assembly->assembly.basedir = mono_string_to_utf8 (assemblyb->dir);
4949 if (assemblyb->culture)
4950 assembly->assembly.aname.culture = mono_string_to_utf8 (assemblyb->culture);
4951 else
4952 assembly->assembly.aname.culture = g_strdup ("");
4953
4954 if (assemblyb->version) {
4955 char *vstr = mono_string_to_utf8 (assemblyb->version);
4956 char **version = g_strsplit (vstr, ".", 4);
4957 char **parts = version;
4958 assembly->assembly.aname.major = atoi (*parts++);
4959 assembly->assembly.aname.minor = atoi (*parts++);
4960 assembly->assembly.aname.build = *parts != NULL ? atoi (*parts++) : 0;
4961 assembly->assembly.aname.revision = *parts != NULL ? atoi (*parts) : 0;
4962
4963 g_strfreev (version);
4964 g_free (vstr);
4965 } else {
4966 assembly->assembly.aname.major = 0;
4967 assembly->assembly.aname.minor = 0;
4968 assembly->assembly.aname.build = 0;
4969 assembly->assembly.aname.revision = 0;
4970 }
4971
4972 assembly->run = assemblyb->access != 2;
4973 assembly->save = assemblyb->access != 1;
4974
4975 image = create_dynamic_mono_image (assembly, mono_string_to_utf8 (assemblyb->name), g_strdup ("RefEmit_YouForgotToDefineAModule"));
4976 image->initial_image = TRUE;
4977 assembly->assembly.aname.name = image->image.name;
4978 assembly->assembly.image = &image->image;
4979
4980 mono_domain_assemblies_lock (domain);
4981 domain->domain_assemblies = g_slist_prepend (domain->domain_assemblies, assembly);
4982 mono_domain_assemblies_unlock (domain);
4983
4984 register_assembly (mono_object_domain (assemblyb), &assemblyb->assembly, &assembly->assembly);
4985
4986 mono_profiler_assembly_loaded (&assembly->assembly, MONO_PROFILE_OK);
4987
4988 mono_assembly_invoke_load_hook ((MonoAssembly*)assembly);
4989 }
4990
4991 #endif /* !DISABLE_REFLECTION_EMIT */
4992
4993 #ifndef DISABLE_REFLECTION_EMIT_SAVE
4994
4995 static int
4996 calc_section_size (MonoDynamicImage *assembly)
4997 {
4998 int nsections = 0;
4999
5000 /* alignment constraints */
5001 mono_image_add_stream_zero (&assembly->code, 4 - (assembly->code.index % 4));
5002 g_assert ((assembly->code.index % 4) == 0);
5003 assembly->meta_size += 3;
5004 assembly->meta_size &= ~3;
5005 mono_image_add_stream_zero (&assembly->resources, 4 - (assembly->resources.index % 4));
5006 g_assert ((assembly->resources.index % 4) == 0);
5007
5008 assembly->sections [MONO_SECTION_TEXT].size = assembly->meta_size + assembly->code.index + assembly->resources.index + assembly->strong_name_size;
5009 assembly->sections [MONO_SECTION_TEXT].attrs = SECT_FLAGS_HAS_CODE | SECT_FLAGS_MEM_EXECUTE | SECT_FLAGS_MEM_READ;
5010 nsections++;
5011
5012 if (assembly->win32_res) {
5013 guint32 res_size = (assembly->win32_res_size + 3) & ~3;
5014
5015 assembly->sections [MONO_SECTION_RSRC].size = res_size;
5016 assembly->sections [MONO_SECTION_RSRC].attrs = SECT_FLAGS_HAS_INITIALIZED_DATA | SECT_FLAGS_MEM_READ;
5017 nsections++;
5018 }
5019
5020 assembly->sections [MONO_SECTION_RELOC].size = 12;
5021 assembly->sections [MONO_SECTION_RELOC].attrs = SECT_FLAGS_MEM_READ | SECT_FLAGS_MEM_DISCARDABLE | SECT_FLAGS_HAS_INITIALIZED_DATA;
5022 nsections++;
5023
5024 return nsections;
5025 }
5026
5027 typedef struct {
5028 guint32 id;
5029 guint32 offset;
5030 GSList *children;
5031 MonoReflectionWin32Resource *win32_res; /* Only for leaf nodes */
5032 } ResTreeNode;
5033
5034 static int
5035 resource_tree_compare_by_id (gconstpointer a, gconstpointer b)
5036 {
5037 ResTreeNode *t1 = (ResTreeNode*)a;
5038 ResTreeNode *t2 = (ResTreeNode*)b;
5039
5040 return t1->id - t2->id;
5041 }
5042
5043 /*
5044 * resource_tree_create:
5045 *
5046 * Organize the resources into a resource tree.
5047 */
5048 static ResTreeNode *
5049 resource_tree_create (MonoArray *win32_resources)
5050 {
5051 ResTreeNode *tree, *res_node, *type_node, *lang_node;
5052 GSList *l;
5053 int i;
5054
5055 tree = g_new0 (ResTreeNode, 1);
5056
5057 for (i = 0; i < mono_array_length (win32_resources); ++i) {
5058 MonoReflectionWin32Resource *win32_res =
5059 (MonoReflectionWin32Resource*)mono_array_addr (win32_resources, MonoReflectionWin32Resource, i);
5060
5061 /* Create node */
5062
5063 /* FIXME: BUG: this stores managed references in unmanaged memory */
5064 lang_node = g_new0 (ResTreeNode, 1);
5065 lang_node->id = win32_res->lang_id;
5066 lang_node->win32_res = win32_res;
5067
5068 /* Create type node if neccesary */
5069 type_node = NULL;
5070 for (l = tree->children; l; l = l->next)
5071 if (((ResTreeNode*)(l->data))->id == win32_res->res_type) {
5072 type_node = (ResTreeNode*)l->data;
5073 break;
5074 }
5075
5076 if (!type_node) {
5077 type_node = g_new0 (ResTreeNode, 1);
5078 type_node->id = win32_res->res_type;
5079
5080 /*
5081 * The resource types have to be sorted otherwise
5082 * Windows Explorer can't display the version information.
5083 */
5084 tree->children = g_slist_insert_sorted (tree->children,
5085 type_node, resource_tree_compare_by_id);
5086 }
5087
5088 /* Create res node if neccesary */
5089 res_node = NULL;
5090 for (l = type_node->children; l; l = l->next)
5091 if (((ResTreeNode*)(l->data))->id == win32_res->res_id) {
5092 res_node = (ResTreeNode*)l->data;
5093 break;
5094 }
5095
5096 if (!res_node) {
5097 res_node = g_new0 (ResTreeNode, 1);
5098 res_node->id = win32_res->res_id;
5099 type_node->children = g_slist_append (type_node->children, res_node);
5100 }
5101
5102 res_node->children = g_slist_append (res_node->children, lang_node);
5103 }
5104
5105 return tree;
5106 }
5107
5108 /*
5109 * resource_tree_encode:
5110 *
5111 * Encode the resource tree into the format used in the PE file.
5112 */
5113 static void
5114 resource_tree_encode (ResTreeNode *node, char *begin, char *p, char **endbuf)
5115 {
5116 char *entries;
5117 MonoPEResourceDir dir;
5118 MonoPEResourceDirEntry dir_entry;
5119 MonoPEResourceDataEntry data_entry;
5120 GSList *l;
5121 guint32 res_id_entries;
5122
5123 /*
5124 * For the format of the resource directory, see the article
5125 * "An In-Depth Look into the Win32 Portable Executable File Format" by
5126 * Matt Pietrek
5127 */
5128
5129 memset (&dir, 0, sizeof (dir));
5130 memset (&dir_entry, 0, sizeof (dir_entry));
5131 memset (&data_entry, 0, sizeof (data_entry));
5132
5133 g_assert (sizeof (dir) == 16);
5134 g_assert (sizeof (dir_entry) == 8);
5135 g_assert (sizeof (data_entry) == 16);
5136
5137 node->offset = p - begin;
5138
5139 /* IMAGE_RESOURCE_DIRECTORY */
5140 res_id_entries = g_slist_length (node->children);
5141 dir.res_id_entries = GUINT16_TO_LE (res_id_entries);
5142
5143 memcpy (p, &dir, sizeof (dir));
5144 p += sizeof (dir);
5145
5146 /* Reserve space for entries */
5147 entries = p;
5148 p += sizeof (dir_entry) * res_id_entries;
5149
5150 /* Write children */
5151 for (l = node->children; l; l = l->next) {
5152 ResTreeNode *child = (ResTreeNode*)l->data;
5153
5154 if (child->win32_res) {
5155 guint32 size;
5156
5157 child->offset = p - begin;
5158
5159 /* IMAGE_RESOURCE_DATA_ENTRY */
5160 data_entry.rde_data_offset = GUINT32_TO_LE (p - begin + sizeof (data_entry));
5161 size = mono_array_length (child->win32_res->res_data);
5162 data_entry.rde_size = GUINT32_TO_LE (size);
5163
5164 memcpy (p, &data_entry, sizeof (data_entry));
5165 p += sizeof (data_entry);
5166
5167 memcpy (p, mono_array_addr (child->win32_res->res_data, char, 0), size);
5168 p += size;
5169 } else {
5170 resource_tree_encode (child, begin, p, &p);
5171 }
5172 }
5173
5174 /* IMAGE_RESOURCE_ENTRY */
5175 for (l = node->children; l; l = l->next) {
5176 ResTreeNode *child = (ResTreeNode*)l->data;
5177
5178 MONO_PE_RES_DIR_ENTRY_SET_NAME (dir_entry, FALSE, child->id);
5179 MONO_PE_RES_DIR_ENTRY_SET_DIR (dir_entry, !child->win32_res, child->offset);
5180
5181 memcpy (entries, &dir_entry, sizeof (dir_entry));
5182 entries += sizeof (dir_entry);
5183 }
5184
5185 *endbuf = p;
5186 }
5187
5188 static void
5189 resource_tree_free (ResTreeNode * node)
5190 {
5191 GSList * list;
5192 for (list = node->children; list; list = list->next)
5193 resource_tree_free ((ResTreeNode*)list->data);
5194 g_slist_free(node->children);
5195 g_free (node);
5196 }
5197
5198 static void
5199 assembly_add_win32_resources (MonoDynamicImage *assembly, MonoReflectionAssemblyBuilder *assemblyb)
5200 {
5201 char *buf;
5202 char *p;
5203 guint32 size, i;
5204 MonoReflectionWin32Resource *win32_res;
5205 ResTreeNode *tree;
5206
5207 if (!assemblyb->win32_resources)
5208 return;
5209
5210 /*
5211 * Resources are stored in a three level tree inside the PE file.
5212 * - level one contains a node for each type of resource
5213 * - level two contains a node for each resource
5214 * - level three contains a node for each instance of a resource for a
5215 * specific language.
5216 */
5217
5218 tree = resource_tree_create (assemblyb->win32_resources);
5219
5220 /* Estimate the size of the encoded tree */
5221 size = 0;
5222 for (i = 0; i < mono_array_length (assemblyb->win32_resources); ++i) {
5223 win32_res = (MonoReflectionWin32Resource*)mono_array_addr (assemblyb->win32_resources, MonoReflectionWin32Resource, i);
5224 size += mono_array_length (win32_res->res_data);
5225 }
5226 /* Directory structure */
5227 size += mono_array_length (assemblyb->win32_resources) * 256;
5228 p = buf = g_malloc (size);
5229
5230 resource_tree_encode (tree, p, p, &p);
5231
5232 g_assert (p - buf <= size);
5233
5234 assembly->win32_res = g_malloc (p - buf);
5235 assembly->win32_res_size = p - buf;
5236 memcpy (assembly->win32_res, buf, p - buf);
5237
5238 g_free (buf);
5239 resource_tree_free (tree);
5240 }
5241
5242 static void
5243 fixup_resource_directory (char *res_section, char *p, guint32 rva)
5244 {
5245 MonoPEResourceDir *dir = (MonoPEResourceDir*)p;
5246 int i;
5247
5248 p += sizeof (MonoPEResourceDir);
5249 for (i = 0; i < GUINT16_FROM_LE (dir->res_named_entries) + GUINT16_FROM_LE (dir->res_id_entries); ++i) {
5250 MonoPEResourceDirEntry *dir_entry = (MonoPEResourceDirEntry*)p;
5251 char *child = res_section + MONO_PE_RES_DIR_ENTRY_DIR_OFFSET (*dir_entry);
5252 if (MONO_PE_RES_DIR_ENTRY_IS_DIR (*dir_entry)) {
5253 fixup_resource_directory (res_section, child, rva);
5254 } else {
5255 MonoPEResourceDataEntry *data_entry = (MonoPEResourceDataEntry*)child;
5256 data_entry->rde_data_offset = GUINT32_TO_LE (GUINT32_FROM_LE (data_entry->rde_data_offset) + rva);
5257 }
5258
5259 p += sizeof (MonoPEResourceDirEntry);
5260 }
5261 }
5262
5263 static void
5264 checked_write_file (HANDLE f, gconstpointer buffer, guint32 numbytes)
5265 {
5266 guint32 dummy;
5267 if (!WriteFile (f, buffer, numbytes, &dummy, NULL))
5268 g_error ("WriteFile returned %d\n", GetLastError ());
5269 }
5270
5271 /*
5272 * mono_image_create_pefile:
5273 * @mb: a module builder object
5274 *
5275 * This function creates the PE-COFF header, the image sections, the CLI header * etc. all the data is written in
5276 * assembly->pefile where it can be easily retrieved later in chunks.
5277 */
5278 void
5279 mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file)
5280 {
5281 MonoMSDOSHeader *msdos;
5282 MonoDotNetHeader *header;
5283 MonoSectionTable *section;
5284 MonoCLIHeader *cli_header;
5285 guint32 size, image_size, virtual_base, text_offset;
5286 guint32 header_start, section_start, file_offset, virtual_offset;
5287 MonoDynamicImage *assembly;
5288 MonoReflectionAssemblyBuilder *assemblyb;
5289 MonoDynamicStream pefile_stream = {0};
5290 MonoDynamicStream *pefile = &pefile_stream;
5291 int i, nsections;
5292 guint32 *rva, value;
5293 guchar *p;
5294 static const unsigned char msheader[] = {
5295 0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
5296 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5297 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5298 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
5299 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21, 0x54, 0x68,
5300 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f,
5301 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
5302 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
5303 };
5304
5305 assemblyb = mb->assemblyb;
5306
5307 mono_image_basic_init (assemblyb);
5308 assembly = mb->dynamic_image;
5309
5310 assembly->pe_kind = assemblyb->pe_kind;
5311 assembly->machine = assemblyb->machine;
5312 ((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->pe_kind = assemblyb->pe_kind;
5313 ((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->machine = assemblyb->machine;
5314
5315 mono_image_build_metadata (mb);
5316
5317 if (mb->is_main && assemblyb->resources) {
5318 int len = mono_array_length (assemblyb->resources);
5319 for (i = 0; i < len; ++i)
5320 assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (assemblyb->resources, MonoReflectionResource, i));
5321 }
5322
5323 if (mb->resources) {
5324 int len = mono_array_length (mb->resources);
5325 for (i = 0; i < len; ++i)
5326 assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (mb->resources, MonoReflectionResource, i));
5327 }
5328
5329 build_compressed_metadata (assembly);
5330
5331 if (mb->is_main)
5332 assembly_add_win32_resources (assembly, assemblyb);
5333
5334 nsections = calc_section_size (assembly);
5335
5336 /* The DOS header and stub */
5337 g_assert (sizeof (MonoMSDOSHeader) == sizeof (msheader));
5338 mono_image_add_stream_data (pefile, (char*)msheader, sizeof (msheader));
5339
5340 /* the dotnet header */
5341 header_start = mono_image_add_stream_zero (pefile, sizeof (MonoDotNetHeader));
5342
5343 /* the section tables */
5344 section_start = mono_image_add_stream_zero (pefile, sizeof (MonoSectionTable) * nsections);
5345
5346 file_offset = section_start + sizeof (MonoSectionTable) * nsections;
5347 virtual_offset = VIRT_ALIGN;
5348 image_size = 0;
5349
5350 for (i = 0; i < MONO_SECTION_MAX; ++i) {
5351 if (!assembly->sections [i].size)
5352 continue;
5353 /* align offsets */
5354 file_offset += FILE_ALIGN - 1;
5355 file_offset &= ~(FILE_ALIGN - 1);
5356 virtual_offset += VIRT_ALIGN - 1;
5357 virtual_offset &= ~(VIRT_ALIGN - 1);
5358
5359 assembly->sections [i].offset = file_offset;
5360 assembly->sections [i].rva = virtual_offset;
5361
5362 file_offset += assembly->sections [i].size;
5363 virtual_offset += assembly->sections [i].size;
5364 image_size += (assembly->sections [i].size + VIRT_ALIGN - 1) & ~(VIRT_ALIGN - 1);
5365 }
5366
5367 file_offset += FILE_ALIGN - 1;
5368 file_offset &= ~(FILE_ALIGN - 1);
5369
5370 image_size += section_start + sizeof (MonoSectionTable) * nsections;
5371
5372 /* back-patch info */
5373 msdos = (MonoMSDOSHeader*)pefile->data;
5374 msdos->pe_offset = GUINT32_FROM_LE (sizeof (MonoMSDOSHeader));
5375
5376 header = (MonoDotNetHeader*)(pefile->data + header_start);
5377 header->pesig [0] = 'P';
5378 header->pesig [1] = 'E';
5379
5380 header->coff.coff_machine = GUINT16_FROM_LE (assemblyb->machine);
5381 header->coff.coff_sections = GUINT16_FROM_LE (nsections);
5382 header->coff.coff_time = GUINT32_FROM_LE (time (NULL));
5383 header->coff.coff_opt_header_size = GUINT16_FROM_LE (sizeof (MonoDotNetHeader) - sizeof (MonoCOFFHeader) - 4);
5384 if (assemblyb->pekind == 1) {
5385 /* it's a dll */
5386 header->coff.coff_attributes = GUINT16_FROM_LE (0x210e);
5387 } else {
5388 /* it's an exe */
5389 header->coff.coff_attributes = GUINT16_FROM_LE (0x010e);
5390 }
5391
5392 virtual_base = 0x400000; /* FIXME: 0x10000000 if a DLL */
5393
5394 header->pe.pe_magic = GUINT16_FROM_LE (0x10B);
5395 header->pe.pe_major = 6;
5396 header->pe.pe_minor = 0;
5397 size = assembly->sections [MONO_SECTION_TEXT].size;
5398 size += FILE_ALIGN - 1;
5399 size &= ~(FILE_ALIGN - 1);
5400 header->pe.pe_code_size = GUINT32_FROM_LE(size);
5401 size = assembly->sections [MONO_SECTION_RSRC].size;
5402 size += FILE_ALIGN - 1;
5403 size &= ~(FILE_ALIGN - 1);
5404 header->pe.pe_data_size = GUINT32_FROM_LE(size);
5405 g_assert (START_TEXT_RVA == assembly->sections [MONO_SECTION_TEXT].rva);
5406 header->pe.pe_rva_code_base = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_TEXT].rva);
5407 header->pe.pe_rva_data_base = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].rva);
5408 /* pe_rva_entry_point always at the beginning of the text section */
5409 header->pe.pe_rva_entry_point = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_TEXT].rva);
5410
5411 header->nt.pe_image_base = GUINT32_FROM_LE (virtual_base);
5412 header->nt.pe_section_align = GUINT32_FROM_LE (VIRT_ALIGN);
5413 header->nt.pe_file_alignment = GUINT32_FROM_LE (FILE_ALIGN);
5414 header->nt.pe_os_major = GUINT16_FROM_LE (4);
5415 header->nt.pe_os_minor = GUINT16_FROM_LE (0);
5416 header->nt.pe_subsys_major = GUINT16_FROM_LE (4);
5417 size = section_start;
5418 size += FILE_ALIGN - 1;
5419 size &= ~(FILE_ALIGN - 1);
5420 header->nt.pe_header_size = GUINT32_FROM_LE (size);
5421 size = image_size;
5422 size += VIRT_ALIGN - 1;
5423 size &= ~(VIRT_ALIGN - 1);
5424 header->nt.pe_image_size = GUINT32_FROM_LE (size);
5425
5426 /*
5427 // Translate the PEFileKind value to the value expected by the Windows loader
5428 */
5429 {
5430 short kind;
5431
5432 /*
5433 // PEFileKinds.Dll == 1
5434 // PEFileKinds.ConsoleApplication == 2
5435 // PEFileKinds.WindowApplication == 3
5436 //
5437 // need to get:
5438 // IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem.
5439 // IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem.
5440 */
5441 if (assemblyb->pekind == 3)
5442 kind = 2;
5443 else
5444 kind = 3;
5445
5446 header->nt.pe_subsys_required = GUINT16_FROM_LE (kind);
5447 }
5448 header->nt.pe_stack_reserve = GUINT32_FROM_LE (0x00100000);
5449 header->nt.pe_stack_commit = GUINT32_FROM_LE (0x00001000);
5450 header->nt.pe_heap_reserve = GUINT32_FROM_LE (0x00100000);
5451 header->nt.pe_heap_commit = GUINT32_FROM_LE (0x00001000);
5452 header->nt.pe_loader_flags = GUINT32_FROM_LE (0);
5453 header->nt.pe_data_dir_count = GUINT32_FROM_LE (16);
5454
5455 /* fill data directory entries */
5456
5457 header->datadir.pe_resource_table.size = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].size);
5458 header->datadir.pe_resource_table.rva = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].rva);
5459
5460 header->datadir.pe_reloc_table.size = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RELOC].size);
5461 header->datadir.pe_reloc_table.rva = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RELOC].rva);
5462
5463 header->datadir.pe_cli_header.size = GUINT32_FROM_LE (72);
5464 header->datadir.pe_cli_header.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->cli_header_offset);
5465 header->datadir.pe_iat.size = GUINT32_FROM_LE (8);
5466 header->datadir.pe_iat.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->iat_offset);
5467 /* patch entrypoint name */
5468 if (assemblyb->pekind == 1)
5469 memcpy (assembly->code.data + assembly->imp_names_offset + 2, "_CorDllMain", 12);
5470 else
5471 memcpy (assembly->code.data + assembly->imp_names_offset + 2, "_CorExeMain", 12);
5472 /* patch imported function RVA name */
5473 rva = (guint32*)(assembly->code.data + assembly->iat_offset);
5474 *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->imp_names_offset);
5475
5476 /* the import table */
5477 header->datadir.pe_import_table.size = GUINT32_FROM_LE (79); /* FIXME: magic number? */
5478 header->datadir.pe_import_table.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->idt_offset);
5479 /* patch imported dll RVA name and other entries in the dir */
5480 rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, name_rva));
5481 *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->imp_names_offset + 14); /* 14 is hint+strlen+1 of func name */
5482 rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, import_address_table_rva));
5483 *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->iat_offset);
5484 rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, import_lookup_table));
5485 *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->ilt_offset);
5486
5487 p = (guchar*)(assembly->code.data + assembly->ilt_offset);
5488 value = (assembly->text_rva + assembly->imp_names_offset);
5489 *p++ = (value) & 0xff;
5490 *p++ = (value >> 8) & (0xff);
5491 *p++ = (value >> 16) & (0xff);
5492 *p++ = (value >> 24) & (0xff);
5493
5494 /* the CLI header info */
5495 cli_header = (MonoCLIHeader*)(assembly->code.data + assembly->cli_header_offset);
5496 cli_header->ch_size = GUINT32_FROM_LE (72);
5497 cli_header->ch_runtime_major = GUINT16_FROM_LE (2);
5498 if (mono_framework_version () > 1)
5499 cli_header->ch_runtime_minor = GUINT16_FROM_LE (5);
5500 else
5501 cli_header->ch_runtime_minor = GUINT16_FROM_LE (0);
5502 cli_header->ch_flags = GUINT32_FROM_LE (assemblyb->pe_kind);
5503 if (assemblyb->entry_point) {
5504 guint32 table_idx = 0;
5505 if (!strcmp (assemblyb->entry_point->object.vtable->klass->name, "MethodBuilder")) {
5506 MonoReflectionMethodBuilder *methodb = (MonoReflectionMethodBuilder*)assemblyb->entry_point;
5507 table_idx = methodb->table_idx;
5508 } else {
5509 table_idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, assemblyb->entry_point->method));
5510 }
5511 cli_header->ch_entry_point = GUINT32_FROM_LE (table_idx | MONO_TOKEN_METHOD_DEF);
5512 } else {
5513 cli_header->ch_entry_point = GUINT32_FROM_LE (0);
5514 }
5515 /* The embedded managed resources */
5516 text_offset = assembly->text_rva + assembly->code.index;
5517 cli_header->ch_resources.rva = GUINT32_FROM_LE (text_offset);
5518 cli_header->ch_resources.size = GUINT32_FROM_LE (assembly->resources.index);
5519 text_offset += assembly->resources.index;
5520 cli_header->ch_metadata.rva = GUINT32_FROM_LE (text_offset);
5521 cli_header->ch_metadata.size = GUINT32_FROM_LE (assembly->meta_size);
5522 text_offset += assembly->meta_size;
5523 if (assembly->strong_name_size) {
5524 cli_header->ch_strong_name.rva = GUINT32_FROM_LE (text_offset);
5525 cli_header->ch_strong_name.size = GUINT32_FROM_LE (assembly->strong_name_size);
5526 text_offset += assembly->strong_name_size;
5527 }
5528
5529 /* write the section tables and section content */
5530 section = (MonoSectionTable*)(pefile->data + section_start);
5531 for (i = 0; i < MONO_SECTION_MAX; ++i) {
5532 static const char section_names [][7] = {
5533 ".text", ".rsrc", ".reloc"
5534 };
5535 if (!assembly->sections [i].size)
5536 continue;
5537 strcpy (section->st_name, section_names [i]);
5538 /*g_print ("output section %s (%d), size: %d\n", section->st_name, i, assembly->sections [i].size);*/
5539 section->st_virtual_address = GUINT32_FROM_LE (assembly->sections [i].rva);
5540 section->st_virtual_size = GUINT32_FROM_LE (assembly->sections [i].size);
5541 section->st_raw_data_size = GUINT32_FROM_LE (GUINT32_TO_LE (section->st_virtual_size) + (FILE_ALIGN - 1));
5542 section->st_raw_data_size &= GUINT32_FROM_LE (~(FILE_ALIGN - 1));
5543 section->st_raw_data_ptr = GUINT32_FROM_LE (assembly->sections [i].offset);
5544 section->st_flags = GUINT32_FROM_LE (assembly->sections [i].attrs);
5545 section ++;
5546 }
5547
5548 checked_write_file (file, pefile->data, pefile->index);
5549
5550 mono_dynamic_stream_reset (pefile);
5551
5552 for (i = 0; i < MONO_SECTION_MAX; ++i) {
5553 if (!assembly->sections [i].size)
5554 continue;
5555
5556 if (SetFilePointer (file, assembly->sections [i].offset, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
5557 g_error ("SetFilePointer returned %d\n", GetLastError ());
5558
5559 switch (i) {
5560 case MONO_SECTION_TEXT:
5561 /* patch entry point */
5562 p = (guchar*)(assembly->code.data + 2);
5563 value = (virtual_base + assembly->text_rva + assembly->iat_offset);
5564 *p++ = (value) & 0xff;
5565 *p++ = (value >> 8) & 0xff;
5566 *p++ = (value >> 16) & 0xff;
5567 *p++ = (value >> 24) & 0xff;
5568
5569 checked_write_file (file, assembly->code.data, assembly->code.index);
5570 checked_write_file (file, assembly->resources.data, assembly->resources.index);
5571 checked_write_file (file, assembly->image.raw_metadata, assembly->meta_size);
5572 checked_write_file (file, assembly->strong_name, assembly->strong_name_size);
5573
5574
5575 g_free (assembly->image.raw_metadata);
5576 break;
5577 case MONO_SECTION_RELOC: {
5578 struct {
5579 guint32 page_rva;
5580 guint32 block_size;
5581 guint16 type_and_offset;
5582 guint16 term;
5583 } reloc;
5584
5585 g_assert (sizeof (reloc) == 12);
5586
5587 reloc.page_rva = GUINT32_FROM_LE (assembly->text_rva);
5588 reloc.block_size = GUINT32_FROM_LE (12);
5589
5590 /*
5591 * the entrypoint is always at the start of the text section
5592 * 3 is IMAGE_REL_BASED_HIGHLOW
5593 * 2 is patch_size_rva - text_rva
5594 */
5595 reloc.type_and_offset = GUINT16_FROM_LE ((3 << 12) + (2));
5596 reloc.term = 0;
5597
5598 checked_write_file (file, &reloc, sizeof (reloc));
5599
5600 break;
5601 }
5602 case MONO_SECTION_RSRC:
5603 if (assembly->win32_res) {
5604
5605 /* Fixup the offsets in the IMAGE_RESOURCE_DATA_ENTRY structures */
5606 fixup_resource_directory (assembly->win32_res, assembly->win32_res, assembly->sections [i].rva);
5607 checked_write_file (file, assembly->win32_res, assembly->win32_res_size);
5608 }
5609 break;
5610 default:
5611 g_assert_not_reached ();
5612 }
5613 }
5614
5615 /* check that the file is properly padded */
5616 if (SetFilePointer (file, file_offset, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
5617 g_error ("SetFilePointer returned %d\n", GetLastError ());
5618 if (! SetEndOfFile (file))
5619 g_error ("SetEndOfFile returned %d\n", GetLastError ());
5620
5621 mono_dynamic_stream_reset (&assembly->code);
5622 mono_dynamic_stream_reset (&assembly->us);
5623 mono_dynamic_stream_reset (&assembly->blob);
5624 mono_dynamic_stream_reset (&assembly->guid);
5625 mono_dynamic_stream_reset (&assembly->sheap);
5626
5627 g_hash_table_foreach (assembly->blob_cache, (GHFunc)g_free, NULL);
5628 g_hash_table_destroy (assembly->blob_cache);
5629 assembly->blob_cache = NULL;
5630 }
5631
5632 #else /* DISABLE_REFLECTION_EMIT_SAVE */
5633
5634 void
5635 mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file)
5636 {
5637 g_assert_not_reached ();
5638 }
5639
5640 #endif /* DISABLE_REFLECTION_EMIT_SAVE */
5641
5642 #ifndef DISABLE_REFLECTION_EMIT
5643
5644 MonoReflectionModule *
5645 mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *ab, MonoString *fileName)
5646 {
5647 char *name;
5648 MonoImage *image;
5649 MonoImageOpenStatus status;
5650 MonoDynamicAssembly *assembly;
5651 guint32 module_count;
5652 MonoImage **new_modules;
5653 gboolean *new_modules_loaded;
5654
5655 name = mono_string_to_utf8 (fileName);
5656
5657 image = mono_image_open (name, &status);
5658 if (!image) {
5659 MonoException *exc;
5660 if (status == MONO_IMAGE_ERROR_ERRNO)
5661 exc = mono_get_exception_file_not_found (fileName);
5662 else
5663 exc = mono_get_exception_bad_image_format (name);
5664 g_free (name);
5665 mono_raise_exception (exc);
5666 }
5667
5668 g_free (name);
5669
5670 assembly = ab->dynamic_assembly;
5671 image->assembly = (MonoAssembly*)assembly;
5672
5673 module_count = image->assembly->image->module_count;
5674 new_modules = g_new0 (MonoImage *, module_count + 1);
5675 new_modules_loaded = g_new0 (gboolean, module_count + 1);
5676
5677 if (image->assembly->image->modules)
5678 memcpy (new_modules, image->assembly->image->modules, module_count * sizeof (MonoImage *));
5679 if (image->assembly->image->modules_loaded)
5680 memcpy (new_modules_loaded, image->assembly->image->modules_loaded, module_count * sizeof (gboolean));
5681 new_modules [module_count] = image;
5682 new_modules_loaded [module_count] = TRUE;
5683 mono_image_addref (image);
5684
5685 g_free (image->assembly->image->modules);
5686 image->assembly->image->modules = new_modules;
5687 image->assembly->image->modules_loaded = new_modules_loaded;
5688 image->assembly->image->module_count ++;
5689
5690 mono_assembly_load_references (image, &status);
5691 if (status) {
5692 mono_image_close (image);
5693 mono_raise_exception (mono_get_exception_file_not_found (fileName));
5694 }
5695
5696 return mono_module_get_object (mono_domain_get (), image);
5697 }
5698
5699 #endif /* DISABLE_REFLECTION_EMIT */
5700
5701 /*
5702 * We need to return always the same object for MethodInfo, FieldInfo etc..
5703 * but we need to consider the reflected type.
5704 * type uses a different hash, since it uses custom hash/equal functions.
5705 */
5706
5707 typedef struct {
5708 gpointer item;
5709 MonoClass *refclass;
5710 } ReflectedEntry;
5711
5712 static gboolean
5713 reflected_equal (gconstpointer a, gconstpointer b) {
5714 const ReflectedEntry *ea = a;
5715 const ReflectedEntry *eb = b;
5716
5717 return (ea->item == eb->item) && (ea->refclass == eb->refclass);
5718 }
5719
5720 static guint
5721 reflected_hash (gconstpointer a) {
5722 const ReflectedEntry *ea = a;
5723 return mono_aligned_addr_hash (ea->item);
5724 }
5725
5726 #define CHECK_OBJECT(t,p,k) \
5727 do { \
5728 t _obj; \
5729 ReflectedEntry e; \
5730 e.item = (p); \
5731 e.refclass = (k); \
5732 mono_domain_lock (domain); \
5733 if (!domain->refobject_hash) \
5734 domain->refobject_hash = mono_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC); \
5735 if ((_obj = mono_g_hash_table_lookup (domain->refobject_hash, &e))) { \
5736 mono_domain_unlock (domain); \
5737 return _obj; \
5738 } \
5739 mono_domain_unlock (domain); \
5740 } while (0)
5741
5742 #ifdef HAVE_BOEHM_GC
5743 /* ReflectedEntry doesn't need to be GC tracked */
5744 #define ALLOC_REFENTRY g_new0 (ReflectedEntry, 1)
5745 #define FREE_REFENTRY(entry) g_free ((entry))
5746 #define REFENTRY_REQUIRES_CLEANUP
5747 #else
5748 #define ALLOC_REFENTRY mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
5749 /* FIXME: */
5750 #define FREE_REFENTRY(entry)
5751 #endif
5752
5753 #define CACHE_OBJECT(t,p,o,k) \
5754 do { \
5755 t _obj; \
5756 ReflectedEntry pe; \
5757 pe.item = (p); \
5758 pe.refclass = (k); \
5759 mono_domain_lock (domain); \
5760 if (!domain->refobject_hash) \
5761 domain->refobject_hash = mono_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC); \
5762 _obj = mono_g_hash_table_lookup (domain->refobject_hash, &pe); \
5763 if (!_obj) { \
5764 ReflectedEntry *e = ALLOC_REFENTRY; \
5765 e->item = (p); \
5766 e->refclass = (k); \
5767 mono_g_hash_table_insert (domain->refobject_hash, e,o); \
5768 _obj = o; \
5769 } \
5770 mono_domain_unlock (domain); \
5771 return _obj; \
5772 } while (0)
5773
5774 static void
5775 clear_cached_object (MonoDomain *domain, gpointer o, MonoClass *klass)
5776 {
5777 mono_domain_lock (domain);
5778 if (domain->refobject_hash) {
5779 ReflectedEntry pe;
5780 gpointer orig_pe, orig_value;
5781
5782 pe.item = o;
5783 pe.refclass = klass;
5784 if (mono_g_hash_table_lookup_extended (domain->refobject_hash, &pe, &orig_pe, &orig_value)) {
5785 mono_g_hash_table_remove (domain->refobject_hash, &pe);
5786 FREE_REFENTRY (orig_pe);
5787 }
5788 }
5789 mono_domain_unlock (domain);
5790 }
5791
5792 #ifdef REFENTRY_REQUIRES_CLEANUP
5793 static void
5794 cleanup_refobject_hash (gpointer key, gpointer value, gpointer user_data)
5795 {
5796 FREE_REFENTRY (key);
5797 }
5798 #endif
5799
5800 void
5801 mono_reflection_cleanup_domain (MonoDomain *domain)
5802 {
5803 if (domain->refobject_hash) {
5804 /*let's avoid scanning the whole hashtable if not needed*/
5805 #ifdef REFENTRY_REQUIRES_CLEANUP
5806 mono_g_hash_table_foreach (domain->refobject_hash, cleanup_refobject_hash, NULL);
5807 #endif
5808 mono_g_hash_table_destroy (domain->refobject_hash);
5809 domain->refobject_hash = NULL;
5810 }
5811 }
5812
5813 #ifndef DISABLE_REFLECTION_EMIT
5814 static gpointer
5815 register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly)
5816 {
5817 CACHE_OBJECT (MonoReflectionAssembly *, assembly, res, NULL);
5818 }
5819
5820 static gpointer
5821 register_module (MonoDomain *domain, MonoReflectionModuleBuilder *res, MonoDynamicImage *module)
5822 {
5823 CACHE_OBJECT (MonoReflectionModuleBuilder *, module, res, NULL);
5824 }
5825
5826 void
5827 mono_image_module_basic_init (MonoReflectionModuleBuilder *moduleb)
5828 {
5829 MonoDynamicImage *image = moduleb->dynamic_image;
5830 MonoReflectionAssemblyBuilder *ab = moduleb->assemblyb;
5831 if (!image) {
5832 int module_count;
5833 MonoImage **new_modules;
5834 MonoImage *ass;
5835 /*
5836 * FIXME: we already created an image in mono_image_basic_init (), but
5837 * we don't know which module it belongs to, since that is only
5838 * determined at assembly save time.
5839 */
5840 /*image = (MonoDynamicImage*)ab->dynamic_assembly->assembly.image; */
5841 image = create_dynamic_mono_image (ab->dynamic_assembly, mono_string_to_utf8 (ab->name), mono_string_to_utf8 (moduleb->module.fqname));
5842
5843 moduleb->module.image = &image->image;
5844 moduleb->dynamic_image = image;
5845 register_module (mono_object_domain (moduleb), moduleb, image);
5846
5847 /* register the module with the assembly */
5848 ass = ab->dynamic_assembly->assembly.image;
5849 module_count = ass->module_count;
5850 new_modules = g_new0 (MonoImage *, module_count + 1);
5851
5852 if (ass->modules)
5853 memcpy (new_modules, ass->modules, module_count * sizeof (MonoImage *));
5854 new_modules [module_count] = &image->image;
5855 mono_image_addref (&image->image);
5856
5857 g_free (ass->modules);
5858 ass->modules = new_modules;
5859 ass->module_count ++;
5860 }
5861 }
5862
5863 #endif
5864
5865 /*
5866 * mono_assembly_get_object:
5867 * @domain: an app domain
5868 * @assembly: an assembly
5869 *
5870 * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
5871 */
5872 MonoReflectionAssembly*
5873 mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
5874 {
5875 static MonoClass *System_Reflection_Assembly;
5876 MonoReflectionAssembly *res;
5877
5878 CHECK_OBJECT (MonoReflectionAssembly *, assembly, NULL);
5879 if (!System_Reflection_Assembly)
5880 System_Reflection_Assembly = mono_class_from_name (
5881 mono_defaults.corlib, "System.Reflection", "Assembly");
5882 res = (MonoReflectionAssembly *)mono_object_new (domain, System_Reflection_Assembly);
5883 res->assembly = assembly;
5884
5885 CACHE_OBJECT (MonoReflectionAssembly *, assembly, res, NULL);
5886 }
5887
5888
5889
5890 MonoReflectionModule*
5891 mono_module_get_object (MonoDomain *domain, MonoImage *image)
5892 {
5893 static MonoClass *System_Reflection_Module;
5894 MonoReflectionModule *res;
5895 char* basename;
5896
5897 CHECK_OBJECT (MonoReflectionModule *, image, NULL);
5898 if (!System_Reflection_Module)
5899 System_Reflection_Module = mono_class_from_name (
5900 mono_defaults.corlib, "System.Reflection", "Module");
5901 res = (MonoReflectionModule *)mono_object_new (domain, System_Reflection_Module);
5902
5903 res->image = image;
5904 MONO_OBJECT_SETREF (res, assembly, (MonoReflectionAssembly *) mono_assembly_get_object(domain, image->assembly));
5905
5906 MONO_OBJECT_SETREF (res, fqname, mono_string_new (domain, image->name));
5907 basename = g_path_get_basename (image->name);
5908 MONO_OBJECT_SETREF (res, name, mono_string_new (domain, basename));
5909 MONO_OBJECT_SETREF (res, scopename, mono_string_new (domain, image->module_name));
5910
5911 g_free (basename);
5912
5913 if (image->assembly->image == image) {
5914 res->token = mono_metadata_make_token (MONO_TABLE_MODULE, 1);
5915 } else {
5916 int i;
5917 res->token = 0;
5918 if (image->assembly->image->modules) {
5919 for (i = 0; i < image->assembly->image->module_count; i++) {
5920 if (image->assembly->image->modules [i] == image)
5921 res->token = mono_metadata_make_token (MONO_TABLE_MODULEREF, i + 1);
5922 }
5923 g_assert (res->token);
5924 }
5925 }
5926
5927 CACHE_OBJECT (MonoReflectionModule *, image, res, NULL);
5928 }
5929
5930 MonoReflectionModule*
5931 mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index)
5932 {
5933 static MonoClass *System_Reflection_Module;
5934 MonoReflectionModule *res;
5935 MonoTableInfo *table;
5936 guint32 cols [MONO_FILE_SIZE];
5937 const char *name;
5938 guint32 i, name_idx;
5939 const char *val;
5940
5941 if (!System_Reflection_Module)
5942 System_Reflection_Module = mono_class_from_name (
5943 mono_defaults.corlib, "System.Reflection", "Module");
5944 res = (MonoReflectionModule *)mono_object_new (domain, System_Reflection_Module);
5945
5946 table = &image->tables [MONO_TABLE_FILE];
5947 g_assert (table_index < table->rows);
5948 mono_metadata_decode_row (table, table_index, cols, MONO_FILE_SIZE);
5949
5950 res->image = NULL;
5951 MONO_OBJECT_SETREF (res, assembly, (MonoReflectionAssembly *) mono_assembly_get_object(domain, image->assembly));
5952 name = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]);
5953
5954 /* Check whenever the row has a corresponding row in the moduleref table */
5955 table = &image->tables [MONO_TABLE_MODULEREF];
5956 for (i = 0; i < table->rows; ++i) {
5957 name_idx = mono_metadata_decode_row_col (table, i, MONO_MODULEREF_NAME);
5958 val = mono_metadata_string_heap (image, name_idx);
5959 if (strcmp (val, name) == 0)
5960 res->image = image->modules [i];
5961 }
5962
5963 MONO_OBJECT_SETREF (res, fqname, mono_string_new (domain, name));
5964 MONO_OBJECT_SETREF (res, name, mono_string_new (domain, name));
5965 MONO_OBJECT_SETREF (res, scopename, mono_string_new (domain, name));
5966 res->is_resource = cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA;
5967 res->token = mono_metadata_make_token (MONO_TABLE_FILE, table_index + 1);
5968
5969 return res;
5970 }
5971
5972 static gboolean
5973 mymono_metadata_type_equal (MonoType *t1, MonoType *t2)
5974 {
5975 if ((t1->type != t2->type) ||
5976 (t1->byref != t2->byref))
5977 return FALSE;
5978
5979 switch (t1->type) {
5980 case MONO_TYPE_VOID:
5981 case MONO_TYPE_BOOLEAN:
5982 case MONO_TYPE_CHAR:
5983 case MONO_TYPE_I1:
5984 case MONO_TYPE_U1:
5985 case MONO_TYPE_I2:
5986 case MONO_TYPE_U2:
5987 case MONO_TYPE_I4:
5988 case MONO_TYPE_U4:
5989 case MONO_TYPE_I8:
5990 case MONO_TYPE_U8:
5991 case MONO_TYPE_R4:
5992 case MONO_TYPE_R8:
5993 case MONO_TYPE_STRING:
5994 case MONO_TYPE_I:
5995 case MONO_TYPE_U:
5996 case MONO_TYPE_OBJECT:
5997 case MONO_TYPE_TYPEDBYREF:
5998 return TRUE;
5999 case MONO_TYPE_VALUETYPE:
6000 case MONO_TYPE_CLASS:
6001 case MONO_TYPE_SZARRAY:
6002 return t1->data.klass == t2->data.klass;
6003 case MONO_TYPE_PTR:
6004 return mymono_metadata_type_equal (t1->data.type, t2->data.type);
6005 case MONO_TYPE_ARRAY:
6006 if (t1->data.array->rank != t2->data.array->rank)
6007 return FALSE;
6008 return t1->data.array->eklass == t2->data.array->eklass;
6009 case MONO_TYPE_GENERICINST: {
6010 int i;
6011 MonoGenericInst *i1 = t1->data.generic_class->context.class_inst;
6012 MonoGenericInst *i2 = t2->data.generic_class->context.class_inst;
6013 if (i1->type_argc != i2->type_argc)
6014 return FALSE;
6015 if (!mono_metadata_type_equal (&t1->data.generic_class->container_class->byval_arg,
6016 &t2->data.generic_class->container_class->byval_arg))
6017 return FALSE;
6018 /* FIXME: we should probably just compare the instance pointers directly. */
6019 for (i = 0; i < i1->type_argc; ++i) {
6020 if (!mono_metadata_type_equal (i1->type_argv [i], i2->type_argv [i]))
6021 return FALSE;
6022 }
6023 return TRUE;
6024 }
6025 case MONO_TYPE_VAR:
6026 case MONO_TYPE_MVAR:
6027 return t1->data.generic_param == t2->data.generic_param;
6028 default:
6029 g_error ("implement type compare for %0x!", t1->type);
6030 return FALSE;
6031 }
6032
6033 return FALSE;
6034 }
6035
6036 static guint
6037 mymono_metadata_type_hash (MonoType *t1)
6038 {
6039 guint hash;
6040
6041 hash = t1->type;
6042
6043 hash |= t1->byref << 6; /* do not collide with t1->type values */
6044 switch (t1->type) {
6045 case MONO_TYPE_VALUETYPE:
6046 case MONO_TYPE_CLASS:
6047 case MONO_TYPE_SZARRAY:
6048 /* check if the distribution is good enough */
6049 return ((hash << 5) - hash) ^ g_str_hash (t1->data.klass->name);
6050 case MONO_TYPE_PTR:
6051 return ((hash << 5) - hash) ^ mymono_metadata_type_hash (t1->data.type);
6052 case MONO_TYPE_GENERICINST: {
6053 int i;
6054 MonoGenericInst *inst = t1->data.generic_class->context.class_inst;
6055 hash += g_str_hash (t1->data.generic_class->container_class->name);
6056 hash *= 13;
6057 for (i = 0; i < inst->type_argc; ++i) {
6058 hash += mymono_metadata_type_hash (inst->type_argv [i]);
6059 hash *= 13;
6060 }
6061 return hash;
6062 }
6063 }
6064 return hash;
6065 }
6066
6067 static MonoReflectionGenericClass*
6068 mono_generic_class_get_object (MonoDomain *domain, MonoType *geninst)
6069 {
6070 static MonoClass *System_Reflection_MonoGenericClass;
6071 MonoReflectionGenericClass *res;
6072 MonoClass *klass, *gklass;
6073
6074 if (!System_Reflection_MonoGenericClass) {
6075 System_Reflection_MonoGenericClass = mono_class_from_name (
6076 mono_defaults.corlib, "System.Reflection", "MonoGenericClass");
6077 g_assert (System_Reflection_MonoGenericClass);
6078 }
6079
6080 klass = mono_class_from_mono_type (geninst);
6081 gklass = klass->generic_class->container_class;
6082
6083 mono_class_init (klass);
6084
6085 #ifdef HAVE_SGEN_GC
6086 res = (MonoReflectionGenericClass *) mono_gc_alloc_pinned_obj (mono_class_vtable (domain, System_Reflection_MonoGenericClass), mono_class_instance_size (System_Reflection_MonoGenericClass));
6087 #else
6088 res = (MonoReflectionGenericClass *) mono_object_new (domain, System_Reflection_MonoGenericClass);
6089 #endif
6090
6091 res->type.type = geninst;
6092 g_assert (gklass->reflection_info);
6093 g_assert (!strcmp (((MonoObject*)gklass->reflection_info)->vtable->klass->name, "TypeBuilder"));
6094 MONO_OBJECT_SETREF (res, generic_type, gklass->reflection_info);
6095
6096 return res;
6097 }
6098
6099 static gboolean
6100 verify_safe_for_managed_space (MonoType *type)
6101 {
6102 switch (type->type) {
6103 #ifdef DEBUG_HARDER
6104 case MONO_TYPE_ARRAY:
6105 return verify_safe_for_managed_space (&type->data.array->eklass->byval_arg);
6106 case MONO_TYPE_PTR:
6107 return verify_safe_for_managed_space (type->data.type);
6108 case MONO_TYPE_SZARRAY:
6109 return verify_safe_for_managed_space (&type->data.klass->byval_arg);
6110 case MONO_TYPE_GENERICINST: {
6111 MonoGenericInst *inst = type->data.generic_class->inst;
6112 int i;
6113 if (!inst->is_open)
6114 break;
6115 for (i = 0; i < inst->type_argc; ++i)
6116 if (!verify_safe_for_managed_space (inst->type_argv [i]))
6117 return FALSE;
6118 break;
6119 }
6120 #endif
6121 case MONO_TYPE_VAR:
6122 case MONO_TYPE_MVAR:
6123 return TRUE;
6124 }
6125 return TRUE;
6126 }
6127
6128 /*
6129 * mono_type_get_object:
6130 * @domain: an app domain
6131 * @type: a type
6132 *
6133 * Return an System.MonoType object representing the type @type.
6134 */
6135 MonoReflectionType*
6136 mono_type_get_object (MonoDomain *domain, MonoType *type)
6137 {
6138 MonoReflectionType *res;
6139 MonoClass *klass = mono_class_from_mono_type (type);
6140
6141 /*we must avoid using @type as it might have come
6142 * from a mono_metadata_type_dup and the caller
6143 * expects that is can be freed.
6144 * Using the right type from
6145 */
6146 type = klass->byval_arg.byref == type->byref ? &klass->byval_arg : &klass->this_arg;
6147
6148 /* void is very common */
6149 if (type->type == MONO_TYPE_VOID && domain->typeof_void)
6150 return (MonoReflectionType*)domain->typeof_void;
6151
6152 /*
6153 * If the vtable of the given class was already created, we can use
6154 * the MonoType from there and avoid all locking and hash table lookups.
6155 *
6156 * We cannot do this for TypeBuilders as mono_reflection_create_runtime_class expects
6157 * that the resulting object is diferent.
6158 */
6159 if (type == &klass->byval_arg && !klass->image->dynamic) {
6160 MonoVTable *vtable = mono_class_try_get_vtable (domain, klass);
6161 if (vtable && vtable->type)
6162 return vtable->type;
6163 }
6164
6165 mono_loader_lock (); /*FIXME mono_class_init and mono_class_vtable acquire it*/
6166 mono_domain_lock (domain);
6167 if (!domain->type_hash)
6168 domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mymono_metadata_type_hash,
6169 (GCompareFunc)mymono_metadata_type_equal, MONO_HASH_VALUE_GC);
6170 if ((res = mono_g_hash_table_lookup (domain->type_hash, type))) {
6171 mono_domain_unlock (domain);
6172 mono_loader_unlock ();
6173 return res;
6174 }
6175 /* Create a MonoGenericClass object for instantiations of not finished TypeBuilders */
6176 if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_class->is_dynamic && !type->data.generic_class->container_class->wastypebuilder) {
6177 res = (MonoReflectionType *)mono_generic_class_get_object (domain, type);
6178 mono_g_hash_table_insert (domain->type_hash, type, res);
6179 mono_domain_unlock (domain);
6180 mono_loader_unlock ();
6181 return res;
6182 }
6183
6184 if (!verify_safe_for_managed_space (type)) {
6185 mono_domain_unlock (domain);
6186 mono_loader_unlock ();
6187 mono_raise_exception (mono_get_exception_invalid_operation ("This type cannot be propagated to managed space"));
6188 }
6189
6190 if (klass->reflection_info && !klass->wastypebuilder) {
6191 /* g_assert_not_reached (); */
6192 /* should this be considered an error condition? */
6193 if (!type->byref) {
6194 mono_domain_unlock (domain);
6195 mono_loader_unlock ();
6196 return klass->reflection_info;
6197 }
6198 }
6199 // FIXME: Get rid of this, do it in the icalls for Type
6200 mono_class_init (klass);
6201 #ifdef HAVE_SGEN_GC
6202 res = (MonoReflectionType *)mono_gc_alloc_pinned_obj (mono_class_vtable (domain, mono_defaults.monotype_class), mono_class_instance_size (mono_defaults.monotype_class));
6203 #else
6204 res = (MonoReflectionType *)mono_object_new (domain, mono_defaults.monotype_class);
6205 #endif
6206 res->type = type;
6207 mono_g_hash_table_insert (domain->type_hash, type, res);
6208
6209 if (type->type == MONO_TYPE_VOID)
6210 MONO_OBJECT_SETREF (domain, typeof_void, res);
6211
6212 mono_domain_unlock (domain);
6213 mono_loader_unlock ();
6214 return res;
6215 }
6216
6217 /*
6218 * mono_method_get_object:
6219 * @domain: an app domain
6220 * @method: a method
6221 * @refclass: the reflected type (can be NULL)
6222 *
6223 * Return an System.Reflection.MonoMethod object representing the method @method.
6224 */
6225 MonoReflectionMethod*
6226 mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
6227 {
6228 /*
6229 * We use the same C representation for methods and constructors, but the type
6230 * name in C# is different.
6231 */
6232 static MonoClass *System_Reflection_MonoMethod = NULL;
6233 static MonoClass *System_Reflection_MonoCMethod = NULL;
6234 static MonoClass *System_Reflection_MonoGenericMethod = NULL;
6235 static MonoClass *System_Reflection_MonoGenericCMethod = NULL;
6236 MonoClass *klass;
6237 MonoReflectionMethod *ret;
6238
6239 if (method->is_inflated) {
6240 MonoReflectionGenericMethod *gret;
6241
6242 refclass = method->klass;
6243 CHECK_OBJECT (MonoReflectionMethod *, method, refclass);
6244 if ((*method->name == '.') && (!strcmp (method->name, ".ctor") || !strcmp (method->name, ".cctor"))) {
6245 if (!System_Reflection_MonoGenericCMethod)
6246 System_Reflection_MonoGenericCMethod = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoGenericCMethod");
6247 klass = System_Reflection_MonoGenericCMethod;
6248 } else {
6249 if (!System_Reflection_MonoGenericMethod)
6250 System_Reflection_MonoGenericMethod = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoGenericMethod");
6251 klass = System_Reflection_MonoGenericMethod;
6252 }
6253 gret = (MonoReflectionGenericMethod*)mono_object_new (domain, klass);
6254 gret->method.method = method;
6255 MONO_OBJECT_SETREF (gret, method.name, mono_string_new (domain, method->name));
6256 MONO_OBJECT_SETREF (gret, method.reftype, mono_type_get_object (domain, &refclass->byval_arg));
6257 CACHE_OBJECT (MonoReflectionMethod *, method, (MonoReflectionMethod*)gret, refclass);
6258 }
6259
6260 if (!refclass)
6261 refclass = method->klass;
6262
6263 CHECK_OBJECT (MonoReflectionMethod *, method, refclass);
6264 if (*method->name == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0)) {
6265 if (!System_Reflection_MonoCMethod)
6266 System_Reflection_MonoCMethod = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoCMethod");
6267 klass = System_Reflection_MonoCMethod;
6268 }
6269 else {
6270 if (!System_Reflection_MonoMethod)
6271 System_Reflection_MonoMethod = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoMethod");
6272 klass = System_Reflection_MonoMethod;
6273 }
6274 ret = (MonoReflectionMethod*)mono_object_new (domain, klass);
6275 ret->method = method;
6276 MONO_OBJECT_SETREF (ret, reftype, mono_type_get_object (domain, &refclass->byval_arg));
6277 CACHE_OBJECT (MonoReflectionMethod *, method, ret, refclass);
6278 }
6279
6280 /*
6281 * mono_method_clear_object:
6282 *
6283 * Clear the cached reflection objects for the dynamic method METHOD.
6284 */
6285 void
6286 mono_method_clear_object (MonoDomain *domain, MonoMethod *method)
6287 {
6288 g_assert (method->dynamic);
6289
6290 clear_cached_object (domain, method, method->klass);
6291 /* Added by mono_param_get_objects () */
6292 clear_cached_object (domain, &(method->signature), NULL);
6293 }
6294
6295 /*
6296 * mono_field_get_object:
6297 * @domain: an app domain
6298 * @klass: a type
6299 * @field: a field
6300 *
6301 * Return an System.Reflection.MonoField object representing the field @field
6302 * in class @klass.
6303 */
6304 MonoReflectionField*
6305 mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field)
6306 {
6307 MonoReflectionField *res;
6308 static MonoClass *monofield_klass;
6309
6310 CHECK_OBJECT (MonoReflectionField *, field, klass);
6311 if (!monofield_klass)
6312 monofield_klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoField");
6313 res = (MonoReflectionField *)mono_object_new (domain, monofield_klass);
6314 res->klass = klass;
6315 res->field = field;
6316 MONO_OBJECT_SETREF (res, name, mono_string_new (domain, mono_field_get_name (field)));
6317 if (is_field_on_inst (field))
6318 res->attrs = get_field_on_inst_generic_type (field)->attrs;
6319 else
6320 res->attrs = field->type->attrs;
6321 MONO_OBJECT_SETREF (res, type, mono_type_get_object (domain, field->type));
6322 CACHE_OBJECT (MonoReflectionField *, field, res, klass);
6323 }
6324
6325 /*
6326 * mono_property_get_object:
6327 * @domain: an app domain
6328 * @klass: a type
6329 * @property: a property
6330 *
6331 * Return an System.Reflection.MonoProperty object representing the property @property
6332 * in class @klass.
6333 */
6334 MonoReflectionProperty*
6335 mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property)
6336 {
6337 MonoReflectionProperty *res;
6338 static MonoClass *monoproperty_klass;
6339
6340 CHECK_OBJECT (MonoReflectionProperty *, property, klass);
6341 if (!monoproperty_klass)
6342 monoproperty_klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoProperty");
6343 res = (MonoReflectionProperty *)mono_object_new (domain, monoproperty_klass);
6344 res->klass = klass;
6345 res->property = property;
6346 CACHE_OBJECT (MonoReflectionProperty *, property, res, klass);
6347 }
6348
6349 /*
6350 * mono_event_get_object:
6351 * @domain: an app domain
6352 * @klass: a type
6353 * @event: a event
6354 *
6355 * Return an System.Reflection.MonoEvent object representing the event @event
6356 * in class @klass.
6357 */
6358 MonoReflectionEvent*
6359 mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
6360 {
6361 MonoReflectionEvent *res;
6362 MonoReflectionMonoEvent *mono_event;
6363 static MonoClass *monoevent_klass;
6364
6365 CHECK_OBJECT (MonoReflectionEvent *, event, klass);
6366 if (!monoevent_klass)
6367 monoevent_klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoEvent");
6368 mono_event = (MonoReflectionMonoEvent *)mono_object_new (domain, monoevent_klass);
6369 mono_event->klass = klass;
6370 mono_event->event = event;
6371 res = (MonoReflectionEvent*)mono_event;
6372 CACHE_OBJECT (MonoReflectionEvent *, event, res, klass);
6373 }
6374
6375 /**
6376 * mono_get_reflection_missing_object:
6377 * @domain: Domain where the object lives
6378 *
6379 * Returns the System.Reflection.Missing.Value singleton object
6380 * (of type System.Reflection.Missing).
6381 *
6382 * Used as the value for ParameterInfo.DefaultValue when Optional
6383 * is present
6384 */
6385 static MonoObject *
6386 mono_get_reflection_missing_object (MonoDomain *domain)
6387 {
6388 MonoObject *obj;
6389 static MonoClassField *missing_value_field = NULL;
6390
6391 if (!missing_value_field) {
6392 MonoClass *missing_klass;
6393 missing_klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Missing");
6394 mono_class_init (missing_klass);
6395 missing_value_field = mono_class_get_field_from_name (missing_klass, "Value");
6396 g_assert (missing_value_field);
6397 }
6398 obj = mono_field_get_value_object (domain, missing_value_field, NULL);
6399 g_assert (obj);
6400 return obj;
6401 }
6402
6403 static MonoObject*
6404 get_dbnull (MonoDomain *domain, MonoObject **dbnull)
6405 {
6406 if (!*dbnull)
6407 *dbnull = mono_get_dbnull_object (domain);
6408 return *dbnull;
6409 }
6410
6411 static MonoObject*
6412 get_reflection_missing (MonoDomain *domain, MonoObject **reflection_missing)
6413 {
6414 if (!*reflection_missing)
6415 *reflection_missing = mono_get_reflection_missing_object (domain);
6416 return *reflection_missing;
6417 }
6418
6419 /*
6420 * mono_param_get_objects:
6421 * @domain: an app domain
6422 * @method: a method
6423 *
6424 * Return an System.Reflection.ParameterInfo array object representing the parameters
6425 * in the method @method.
6426 */
6427 MonoArray*
6428 mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
6429 {
6430 static MonoClass *System_Reflection_ParameterInfo;
6431 static MonoClass *System_Reflection_ParameterInfo_array;
6432 MonoArray *res = NULL;
6433 MonoReflectionMethod *member = NULL;
6434 MonoReflectionParameter *param = NULL;
6435 char **names, **blobs = NULL;
6436 guint32 *types = NULL;
6437 MonoType *type = NULL;
6438 MonoObject *dbnull = NULL;
6439 MonoObject *missing = NULL;
6440 MonoMarshalSpec **mspecs;
6441 MonoMethodSignature *sig;
6442 MonoVTable *pinfo_vtable;
6443 int i;
6444
6445 if (!System_Reflection_ParameterInfo_array) {
6446 MonoClass *klass;
6447
6448 klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "ParameterInfo");
6449 mono_memory_barrier ();
6450 System_Reflection_ParameterInfo = klass;
6451
6452 klass = mono_array_class_get (klass, 1);
6453 mono_memory_barrier ();
6454 System_Reflection_ParameterInfo_array = klass;
6455 }
6456
6457 if (!mono_method_signature (method)->param_count)
6458 return mono_array_new_specific (mono_class_vtable (domain, System_Reflection_ParameterInfo_array), 0);
6459
6460 /* Note: the cache is based on the address of the signature into the method
6461 * since we already cache MethodInfos with the method as keys.
6462 */
6463 CHECK_OBJECT (MonoArray*, &(method->signature), refclass);
6464
6465 sig = mono_method_signature (method);
6466 member = mono_method_get_object (domain, method, refclass);
6467 names = g_new (char *, sig->param_count);
6468 mono_method_get_param_names (method, (const char **) names);
6469
6470 mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
6471 mono_method_get_marshal_info (method, mspecs);
6472
6473 res = mono_array_new_specific (mono_class_vtable (domain, System_Reflection_ParameterInfo_array), sig->param_count);
6474 pinfo_vtable = mono_class_vtable (domain, System_Reflection_ParameterInfo);
6475 for (i = 0; i < sig->param_count; ++i) {
6476 param = (MonoReflectionParameter *)mono_object_new_specific (pinfo_vtable);
6477 MONO_OBJECT_SETREF (param, ClassImpl, mono_type_get_object (domain, sig->params [i]));
6478 MONO_OBJECT_SETREF (param, MemberImpl, (MonoObject*)member);
6479 MONO_OBJECT_SETREF (param, NameImpl, mono_string_new (domain, names [i]));
6480 param->PositionImpl = i;
6481 param->AttrsImpl = sig->params [i]->attrs;
6482
6483 if (!(param->AttrsImpl & PARAM_ATTRIBUTE_HAS_DEFAULT)) {
6484 if (param->AttrsImpl & PARAM_ATTRIBUTE_OPTIONAL)
6485 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_reflection_missing (domain, &missing));
6486 else
6487 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_dbnull (domain, &dbnull));
6488 } else {
6489
6490 if (!blobs) {
6491 blobs = g_new0 (char *, sig->param_count);
6492 types = g_new0 (guint32, sig->param_count);
6493 get_default_param_value_blobs (method, blobs, types);
6494 }
6495
6496 /* Build MonoType for the type from the Constant Table */
6497 if (!type)
6498 type = g_new0 (MonoType, 1);
6499 type->type = types [i];
6500 type->data.klass = NULL;
6501 if (types [i] == MONO_TYPE_CLASS)
6502 type->data.klass = mono_defaults.object_class;
6503 else if ((sig->params [i]->type == MONO_TYPE_VALUETYPE) && sig->params [i]->data.klass->enumtype) {
6504 /* For enums, types [i] contains the base type */
6505
6506 type->type = MONO_TYPE_VALUETYPE;
6507 type->data.klass = mono_class_from_mono_type (sig->params [i]);
6508 } else
6509 type->data.klass = mono_class_from_mono_type (type);
6510
6511 MONO_OBJECT_SETREF (param, DefaultValueImpl, mono_get_object_from_blob (domain, type, blobs [i]));
6512
6513 /* Type in the Constant table is MONO_TYPE_CLASS for nulls */
6514 if (types [i] != MONO_TYPE_CLASS && !param->DefaultValueImpl) {
6515 if (param->AttrsImpl & PARAM_ATTRIBUTE_OPTIONAL)
6516 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_reflection_missing (domain, &missing));
6517 else
6518 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_dbnull (domain, &dbnull));
6519 }
6520
6521 }
6522
6523 if (mspecs [i + 1])
6524 MONO_OBJECT_SETREF (param, MarshalAsImpl, (MonoObject*)mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [i + 1]));
6525
6526 mono_array_setref (res, i, param);
6527 }
6528 g_free (names);
6529 g_free (blobs);
6530 g_free (types);
6531 g_free (type);
6532
6533 for (i = mono_method_signature (method)->param_count; i >= 0; i--)
6534 if (mspecs [i])
6535 mono_metadata_free_marshal_spec (mspecs [i]);
6536 g_free (mspecs);
6537
6538 CACHE_OBJECT (MonoArray *, &(method->signature), res, refclass);
6539 }
6540
6541 MonoArray*
6542 mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
6543 {
6544 return mono_param_get_objects_internal (domain, method, NULL);
6545 }
6546
6547 /*
6548 * mono_method_body_get_object:
6549 * @domain: an app domain
6550 * @method: a method
6551 *
6552 * Return an System.Reflection.MethodBody object representing the method @method.
6553 */
6554 MonoReflectionMethodBody*
6555 mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
6556 {
6557 static MonoClass *System_Reflection_MethodBody = NULL;
6558 static MonoClass *System_Reflection_LocalVariableInfo = NULL;
6559 static MonoClass *System_Reflection_ExceptionHandlingClause = NULL;
6560 MonoReflectionMethodBody *ret;
6561 MonoMethodNormal *mn;
6562 MonoMethodHeader *header;
6563 guint32 method_rva, local_var_sig_token;
6564 char *ptr;
6565 unsigned char format, flags;
6566 int i;
6567
6568 if (!System_Reflection_MethodBody)
6569 System_Reflection_MethodBody = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MethodBody");
6570 if (!System_Reflection_LocalVariableInfo)
6571 System_Reflection_LocalVariableInfo = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "LocalVariableInfo");
6572 if (!System_Reflection_ExceptionHandlingClause)
6573 System_Reflection_ExceptionHandlingClause = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "ExceptionHandlingClause");
6574
6575 CHECK_OBJECT (MonoReflectionMethodBody *, method, NULL);
6576
6577 if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
6578 (method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
6579 (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
6580 (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME))
6581 return NULL;
6582 mn = (MonoMethodNormal *)method;
6583 header = mono_method_get_header (method);
6584
6585 /* Obtain local vars signature token */
6586 method_rva = mono_metadata_decode_row_col (&method->klass->image->tables [MONO_TABLE_METHOD], mono_metadata_token_index (method->token) - 1, MONO_METHOD_RVA);
6587 ptr = mono_image_rva_map (method->klass->image, method_rva);
6588 flags = *(const unsigned char *) ptr;
6589 format = flags & METHOD_HEADER_FORMAT_MASK;
6590 switch (format){
6591 case METHOD_HEADER_TINY_FORMAT:
6592 case METHOD_HEADER_TINY_FORMAT1:
6593 local_var_sig_token = 0;
6594 break;
6595 case METHOD_HEADER_FAT_FORMAT:
6596 ptr += 2;
6597 ptr += 2;
6598 ptr += 4;
6599 local_var_sig_token = read32 (ptr);
6600 break;
6601 default:
6602 g_assert_not_reached ();
6603 }
6604
6605 ret = (MonoReflectionMethodBody*)mono_object_new (domain, System_Reflection_MethodBody);
6606
6607 ret->init_locals = header->init_locals;
6608 ret->max_stack = header->max_stack;
6609 ret->local_var_sig_token = local_var_sig_token;
6610 MONO_OBJECT_SETREF (ret, il, mono_array_new_cached (domain, mono_defaults.byte_class, header->code_size));
6611 memcpy (mono_array_addr (ret->il, guint8, 0), header->code, header->code_size);
6612
6613 /* Locals */
6614 MONO_OBJECT_SETREF (ret, locals, mono_array_new_cached (domain, System_Reflection_LocalVariableInfo, header->num_locals));
6615 for (i = 0; i < header->num_locals; ++i) {
6616 MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new (domain, System_Reflection_LocalVariableInfo);
6617 MONO_OBJECT_SETREF (info, local_type, mono_type_get_object (domain, header->locals [i]));
6618 info->is_pinned = header->locals [i]->pinned;
6619 info->local_index = i;
6620 mono_array_setref (ret->locals, i, info);
6621 }
6622
6623 /* Exceptions */
6624 MONO_OBJECT_SETREF (ret, clauses, mono_array_new_cached (domain, System_Reflection_ExceptionHandlingClause, header->num_clauses));
6625 for (i = 0; i < header->num_clauses; ++i) {
6626 MonoReflectionExceptionHandlingClause *info = (MonoReflectionExceptionHandlingClause*)mono_object_new (domain, System_Reflection_ExceptionHandlingClause);
6627 MonoExceptionClause *clause = &header->clauses [i];
6628
6629 info->flags = clause->flags;
6630 info->try_offset = clause->try_offset;
6631 info->try_length = clause->try_len;
6632 info->handler_offset = clause->handler_offset;
6633 info->handler_length = clause->handler_len;
6634 if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER)
6635 info->filter_offset = clause->data.filter_offset;
6636 else if (clause->data.catch_class)
6637 MONO_OBJECT_SETREF (info, catch_type, mono_type_get_object (mono_domain_get (), &clause->data.catch_class->byval_arg));
6638
6639 mono_array_setref (ret->clauses, i, info);
6640 }
6641
6642 CACHE_OBJECT (MonoReflectionMethodBody *, method, ret, NULL);
6643 return ret;
6644 }
6645
6646 /**
6647 * mono_get_dbnull_object:
6648 * @domain: Domain where the object lives
6649 *
6650 * Returns the System.DBNull.Value singleton object
6651 *
6652 * Used as the value for ParameterInfo.DefaultValue
6653 */
6654 MonoObject *
6655 mono_get_dbnull_object (MonoDomain *domain)
6656 {
6657 MonoObject *obj;
6658 static MonoClassField *dbnull_value_field = NULL;
6659
6660 if (!dbnull_value_field) {
6661 MonoClass *dbnull_klass;
6662 dbnull_klass = mono_class_from_name (mono_defaults.corlib, "System", "DBNull");
6663 mono_class_init (dbnull_klass);
6664 dbnull_value_field = mono_class_get_field_from_name (dbnull_klass, "Value");
6665 g_assert (dbnull_value_field);
6666 }
6667 obj = mono_field_get_value_object (domain, dbnull_value_field, NULL);
6668 g_assert (obj);
6669 return obj;
6670 }
6671
6672 static void
6673 get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types)
6674 {
6675 guint32 param_index, i, lastp, crow = 0;
6676 guint32 param_cols [MONO_PARAM_SIZE], const_cols [MONO_CONSTANT_SIZE];
6677 gint32 idx;
6678
6679 MonoClass *klass = method->klass;
6680 MonoImage *image = klass->image;
6681 MonoMethodSignature *methodsig = mono_method_signature (method);
6682
6683 MonoTableInfo *constt;
6684 MonoTableInfo *methodt;
6685 MonoTableInfo *paramt;
6686
6687 if (!methodsig->param_count)
6688 return;
6689
6690 mono_class_init (klass);
6691
6692 if (klass->image->dynamic) {
6693 MonoReflectionMethodAux *aux;
6694 if (method->is_inflated)
6695 method = ((MonoMethodInflated*)method)->declaring;
6696 aux = g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
6697 if (aux && aux->param_defaults) {
6698 memcpy (blobs, &(aux->param_defaults [1]), methodsig->param_count * sizeof (char*));
6699 memcpy (types, &(aux->param_default_types [1]), methodsig->param_count * sizeof (guint32));
6700 }
6701 return;
6702 }
6703
6704 methodt = &klass->image->tables [MONO_TABLE_METHOD];
6705 paramt = &klass->image->tables [MONO_TABLE_PARAM];
6706 constt = &image->tables [MONO_TABLE_CONSTANT];
6707
6708 idx = mono_method_get_index (method) - 1;
6709 g_assert (idx != -1);
6710
6711 param_index = mono_metadata_decode_row_col (methodt, idx, MONO_METHOD_PARAMLIST);
6712 if (idx + 1 < methodt->rows)
6713 lastp = mono_metadata_decode_row_col (methodt, idx + 1, MONO_METHOD_PARAMLIST);
6714 else
6715 lastp = paramt->rows + 1;
6716
6717 for (i = param_index; i < lastp; ++i) {
6718 guint32 paramseq;
6719
6720 mono_metadata_decode_row (paramt, i - 1, param_cols, MONO_PARAM_SIZE);
6721 paramseq = param_cols [MONO_PARAM_SEQUENCE];
6722
6723 if (!param_cols [MONO_PARAM_FLAGS] & PARAM_ATTRIBUTE_HAS_DEFAULT)
6724 continue;
6725
6726 crow = mono_metadata_get_constant_index (image, MONO_TOKEN_PARAM_DEF | i, crow + 1);
6727 if (!crow) {
6728 continue;
6729 }
6730
6731 mono_metadata_decode_row (constt, crow - 1, const_cols, MONO_CONSTANT_SIZE);
6732 blobs [paramseq - 1] = (gpointer) mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
6733 types [paramseq - 1] = const_cols [MONO_CONSTANT_TYPE];
6734 }
6735
6736 return;
6737 }
6738
6739 static MonoObject *
6740 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob)
6741 {
6742 void *retval;
6743 MonoClass *klass;
6744 MonoObject *object;
6745 MonoType *basetype = type;
6746
6747 if (!blob)
6748 return NULL;
6749
6750 klass = mono_class_from_mono_type (type);
6751 if (klass->valuetype) {
6752 object = mono_object_new (domain, klass);
6753 retval = ((gchar *) object + sizeof (MonoObject));
6754 if (klass->enumtype)
6755 basetype = mono_class_enum_basetype (klass);
6756 } else {
6757 retval = &object;
6758 }
6759
6760 if (!mono_get_constant_value_from_blob (domain, basetype->type, blob, retval))
6761 return object;
6762 else
6763 return NULL;
6764 }
6765
6766 static int
6767 assembly_name_to_aname (MonoAssemblyName *assembly, char *p) {
6768 int found_sep;
6769 char *s;
6770
6771 memset (assembly, 0, sizeof (MonoAssemblyName));
6772 assembly->name = p;
6773 assembly->culture = "";
6774 memset (assembly->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
6775
6776 while (*p && (isalnum (*p) || *p == '.' || *p == '-' || *p == '_' || *p == '$' || *p == '@'))
6777 p++;
6778 found_sep = 0;
6779 while (g_ascii_isspace (*p) || *p == ',') {
6780 *p++ = 0;
6781 found_sep = 1;
6782 continue;
6783 }
6784 /* failed */
6785 if (!found_sep)
6786 return 1;
6787 while (*p) {
6788 if (*p == 'V' && g_ascii_strncasecmp (p, "Version=", 8) == 0) {
6789 p += 8;
6790 assembly->major = strtoul (p, &s, 10);
6791 if (s == p || *s != '.')
6792 return 1;
6793 p = ++s;
6794 assembly->minor = strtoul (p, &s, 10);
6795 if (s == p || *s != '.')
6796 return 1;
6797 p = ++s;
6798 assembly->build = strtoul (p, &s, 10);
6799 if (s == p || *s != '.')
6800 return 1;
6801 p = ++s;
6802 assembly->revision = strtoul (p, &s, 10);
6803 if (s == p)
6804 return 1;
6805 p = s;
6806 } else if (*p == 'C' && g_ascii_strncasecmp (p, "Culture=", 8) == 0) {
6807 p += 8;
6808 if (g_ascii_strncasecmp (p, "neutral", 7) == 0) {
6809 assembly->culture = "";
6810 p += 7;
6811 } else {
6812 assembly->culture = p;
6813 while (*p && *p != ',') {
6814 p++;
6815 }
6816 }
6817 } else if (*p == 'P' && g_ascii_strncasecmp (p, "PublicKeyToken=", 15) == 0) {
6818 p += 15;
6819 if (strncmp (p, "null", 4) == 0) {
6820 p += 4;
6821 } else {
6822 int len;
6823 gchar *start = p;
6824 while (*p && *p != ',') {
6825 p++;
6826 }
6827 len = (p - start + 1);
6828 if (len > MONO_PUBLIC_KEY_TOKEN_LENGTH)
6829 len = MONO_PUBLIC_KEY_TOKEN_LENGTH;
6830 g_strlcpy ((char*)assembly->public_key_token, start, len);
6831 }
6832 } else {
6833 while (*p && *p != ',')
6834 p++;
6835 }
6836 found_sep = 0;
6837 while (g_ascii_isspace (*p) || *p == ',') {
6838 *p++ = 0;
6839 found_sep = 1;
6840 continue;
6841 }
6842 /* failed */
6843 if (!found_sep)
6844 return 1;
6845 }
6846
6847 return 0;
6848 }
6849
6850 /*
6851 * mono_reflection_parse_type:
6852 * @name: type name
6853 *
6854 * Parse a type name as accepted by the GetType () method and output the info
6855 * extracted in the info structure.
6856 * the name param will be mangled, so, make a copy before passing it to this function.
6857 * The fields in info will be valid until the memory pointed to by name is valid.
6858 *
6859 * See also mono_type_get_name () below.
6860 *
6861 * Returns: 0 on parse error.
6862 */
6863 static int
6864 _mono_reflection_parse_type (char *name, char **endptr, gboolean is_recursed,
6865 MonoTypeNameParse *info)
6866 {
6867 char *start, *p, *w, *temp, *last_point, *startn;
6868 int in_modifiers = 0;
6869 int isbyref = 0, rank, arity = 0, i;
6870
6871 start = p = w = name;
6872
6873 //FIXME could we just zero the whole struct? memset (&info, 0, sizeof (MonoTypeNameParse))
6874 memset (&info->assembly, 0, sizeof (MonoAssemblyName));
6875 info->name = info->name_space = NULL;
6876 info->nested = NULL;
6877 info->modifiers = NULL;
6878 info->type_arguments = NULL;
6879
6880 /* last_point separates the namespace from the name */
6881 last_point = NULL;
6882 /* Skips spaces */
6883 while (*p == ' ') p++, start++, w++, name++;
6884
6885 while (*p) {
6886 switch (*p) {
6887 case '+':
6888 *p = 0; /* NULL terminate the name */
6889 startn = p + 1;
6890 info->nested = g_list_append (info->nested, startn);
6891 /* we have parsed the nesting namespace + name */
6892 if (info->name)
6893 break;
6894 if (last_point) {
6895 info->name_space = start;
6896 *last_point = 0;
6897 info->name = last_point + 1;
6898 } else {
6899 info->name_space = (char *)"";
6900 info->name = start;
6901 }
6902 break;
6903 case '.':
6904 last_point = p;
6905 break;
6906 case '\\':
6907 ++p;
6908 break;
6909 case '&':
6910 case '*':
6911 case '[':
6912 case ',':
6913 case ']':
6914 in_modifiers = 1;
6915 break;
6916 case '`':
6917 ++p;
6918 i = strtol (p, &temp, 10);
6919 arity += i;
6920 if (p == temp)
6921 return 0;
6922 p = temp-1;
6923 break;
6924 default:
6925 break;
6926 }
6927 if (in_modifiers)
6928 break;
6929 // *w++ = *p++;
6930 p++;
6931 }
6932
6933 if (!info->name) {
6934 if (last_point) {
6935 info->name_space = start;
6936 *last_point = 0;
6937 info->name = last_point + 1;
6938 } else {
6939 info->name_space = (char *)"";
6940 info->name = start;
6941 }
6942 }
6943 while (*p) {
6944 switch (*p) {
6945 case '&':
6946 if (isbyref) /* only one level allowed by the spec */
6947 return 0;
6948 isbyref = 1;
6949 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (0));
6950 *p++ = 0;
6951 break;
6952 case '*':
6953 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-1));
6954 *p++ = 0;
6955 break;
6956 case '[':
6957 if (arity != 0) {
6958 *p++ = 0;
6959 info->type_arguments = g_ptr_array_new ();
6960 for (i = 0; i < arity; i++) {
6961 MonoTypeNameParse *subinfo = g_new0 (MonoTypeNameParse, 1);
6962 gboolean fqname = FALSE;
6963
6964 g_ptr_array_add (info->type_arguments, subinfo);
6965
6966 if (*p == '[') {
6967 p++;
6968 fqname = TRUE;
6969 }
6970
6971 if (!_mono_reflection_parse_type (p, &p, TRUE, subinfo))
6972 return 0;
6973
6974 if (fqname) {
6975 char *aname;
6976
6977 if (*p != ',')
6978 return 0;
6979 *p++ = 0;
6980
6981 aname = p;
6982 while (*p && (*p != ']'))
6983 p++;
6984
6985 if (*p != ']')
6986 return 0;
6987
6988 *p++ = 0;
6989 while (*aname) {
6990 if (g_ascii_isspace (*aname)) {
6991 ++aname;
6992 continue;
6993 }
6994 break;
6995 }
6996 if (!*aname ||
6997 !assembly_name_to_aname (&subinfo->assembly, aname))
6998 return 0;
6999 }
7000
7001 if (i + 1 < arity) {
7002 if (*p != ',')
7003 return 0;
7004 } else {
7005 if (*p != ']')
7006 return 0;
7007 }
7008 *p++ = 0;
7009 }
7010
7011 arity = 0;
7012 break;
7013 }
7014 rank = 1;
7015 *p++ = 0;
7016 while (*p) {
7017 if (*p == ']')
7018 break;
7019 if (*p == ',')
7020 rank++;
7021 else if (*p == '*') /* '*' means unknown lower bound */
7022 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-2));
7023 else
7024 return 0;
7025 ++p;
7026 }
7027 if (*p++ != ']')
7028 return 0;
7029 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (rank));
7030 break;
7031 case ']':
7032 if (is_recursed)
7033 goto end;
7034 return 0;
7035 case ',':
7036 if (is_recursed)
7037 goto end;
7038 *p++ = 0;
7039 while (*p) {
7040 if (g_ascii_isspace (*p)) {
7041 ++p;
7042 continue;
7043 }
7044 break;
7045 }
7046 if (!*p)
7047 return 0; /* missing assembly name */
7048 if (!assembly_name_to_aname (&info->assembly, p))
7049 return 0;
7050 break;
7051 default:
7052 return 0;
7053 }
7054 if (info->assembly.name)
7055 break;
7056 }
7057 // *w = 0; /* terminate class name */
7058 end:
7059 if (!info->name || !*info->name)
7060 return 0;
7061 if (endptr)
7062 *endptr = p;
7063 /* add other consistency checks */
7064 return 1;
7065 }
7066
7067 int
7068 mono_reflection_parse_type (char *name, MonoTypeNameParse *info)
7069 {
7070 return _mono_reflection_parse_type (name, NULL, FALSE, info);
7071 }
7072
7073 static MonoType*
7074 _mono_reflection_get_type_from_info (MonoTypeNameParse *info, MonoImage *image, gboolean ignorecase)
7075 {
7076 gboolean type_resolve = FALSE;
7077 MonoType *type;
7078 MonoImage *rootimage = image;
7079
7080 if (info->assembly.name) {
7081 MonoAssembly *assembly = mono_assembly_loaded (&info->assembly);
7082 if (!assembly && image && image->assembly && mono_assembly_names_equal (&info->assembly, &image->assembly->aname))
7083 /*
7084 * This could happen in the AOT compiler case when the search hook is not
7085 * installed.
7086 */
7087 assembly = image->assembly;
7088 if (!assembly) {
7089 /* then we must load the assembly ourselve - see #60439 */
7090 assembly = mono_assembly_load (&info->assembly, NULL, NULL);
7091 if (!assembly)
7092 return NULL;
7093 }
7094 image = assembly->image;
7095 } else if (!image) {
7096 image = mono_defaults.corlib;
7097 }
7098
7099 type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
7100 if (type == NULL && !info->assembly.name && image != mono_defaults.corlib) {
7101 image = mono_defaults.corlib;
7102 type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve);
7103 }
7104
7105 return type;
7106 }
7107
7108 static MonoType*
7109 mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase)
7110 {
7111 MonoClass *klass;
7112 GList *mod;
7113 int modval;
7114 gboolean bounded = FALSE;
7115
7116 if (!image)
7117 image = mono_defaults.corlib;
7118
7119 if (ignorecase)
7120 klass = mono_class_from_name_case (image, info->name_space, info->name);
7121 else
7122 klass = mono_class_from_name (image, info->name_space, info->name);
7123 if (!klass)
7124 return NULL;
7125 for (mod = info->nested; mod; mod = mod->next) {
7126 gpointer iter = NULL;
7127 MonoClass *parent;
7128
7129 parent = klass;
7130 mono_class_init (parent);
7131
7132 while ((klass = mono_class_get_nested_types (parent, &iter))) {
7133 if (ignorecase) {
7134 if (g_strcasecmp (klass->name, mod->data) == 0)
7135 break;
7136 } else {
7137 if (strcmp (klass->name, mod->data) == 0)
7138 break;
7139 }
7140 }
7141 if (!klass)
7142 break;
7143 }
7144 if (!klass)
7145 return NULL;
7146 mono_class_init (klass);
7147
7148 if (info->type_arguments) {
7149 MonoType **type_args = g_new0 (MonoType *, info->type_arguments->len);
7150 MonoReflectionType *the_type;
7151 MonoType *instance;
7152 int i;
7153
7154 for (i = 0; i < info->type_arguments->len; i++) {
7155 MonoTypeNameParse *subinfo = g_ptr_array_index (info->type_arguments, i);
7156
7157 type_args [i] = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase);
7158 if (!type_args [i]) {
7159 g_free (type_args);
7160 return NULL;
7161 }
7162 }
7163
7164 the_type = mono_type_get_object (mono_domain_get (), &klass->byval_arg);
7165
7166 instance = mono_reflection_bind_generic_parameters (
7167 the_type, info->type_arguments->len, type_args);
7168
7169 g_free (type_args);
7170 if (!instance)
7171 return NULL;
7172
7173 klass = mono_class_from_mono_type (instance);
7174 }
7175
7176 for (mod = info->modifiers; mod; mod = mod->next) {
7177 modval = GPOINTER_TO_UINT (mod->data);
7178 if (!modval) { /* byref: must be last modifier */
7179 return &klass->this_arg;
7180 } else if (modval == -1) {
7181 klass = mono_ptr_class_get (&klass->byval_arg);
7182 } else if (modval == -2) {
7183 bounded = TRUE;
7184 } else { /* array rank */
7185 klass = mono_bounded_array_class_get (klass, modval, bounded);
7186 }
7187 mono_class_init (klass);
7188 }
7189
7190 return &klass->byval_arg;
7191 }
7192
7193 /*
7194 * mono_reflection_get_type:
7195 * @image: a metadata context
7196 * @info: type description structure
7197 * @ignorecase: flag for case-insensitive string compares
7198 * @type_resolve: whenever type resolve was already tried
7199 *
7200 * Build a MonoType from the type description in @info.
7201 *
7202 */
7203
7204 MonoType*
7205 mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve) {
7206 return mono_reflection_get_type_with_rootimage(image, image, info, ignorecase, type_resolve);
7207 }
7208
7209 static MonoType*
7210 mono_reflection_get_type_internal_dynamic (MonoImage *rootimage, MonoAssembly *assembly, MonoTypeNameParse *info, gboolean ignorecase)
7211 {
7212 MonoReflectionAssemblyBuilder *abuilder = (MonoReflectionAssemblyBuilder*)mono_assembly_get_object (mono_domain_get (), assembly);
7213 MonoType *type;
7214 int i;
7215
7216 g_assert (assembly->dynamic);
7217
7218 /* Enumerate all modules */
7219
7220 type = NULL;
7221 if (abuilder->modules) {
7222 for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
7223 MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
7224 type = mono_reflection_get_type_internal (rootimage, &mb->dynamic_image->image, info, ignorecase);
7225 if (type)
7226 break;
7227 }
7228 }
7229
7230 if (!type && abuilder->loaded_modules) {
7231 for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
7232 MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
7233 type = mono_reflection_get_type_internal (rootimage, mod->image, info, ignorecase);
7234 if (type)
7235 break;
7236 }
7237 }
7238
7239 return type;
7240 }
7241
7242 MonoType*
7243 mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve)
7244 {
7245 MonoType *type;
7246 MonoReflectionAssembly *assembly;
7247 GString *fullName;
7248 GList *mod;
7249
7250 if (image && image->dynamic)
7251 type = mono_reflection_get_type_internal_dynamic (rootimage, image->assembly, info, ignorecase);
7252 else
7253 type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase);
7254 if (type)
7255 return type;
7256 if (!mono_domain_has_type_resolve (mono_domain_get ()))
7257 return NULL;
7258
7259 if (type_resolve) {
7260 if (*type_resolve)
7261 return NULL;
7262 else
7263 *type_resolve = TRUE;
7264 }
7265
7266 /* Reconstruct the type name */
7267 fullName = g_string_new ("");
7268 if (info->name_space && (info->name_space [0] != '\0'))
7269 g_string_printf (fullName, "%s.%s", info->name_space, info->name);
7270 else
7271 g_string_printf (fullName, info->name);
7272 for (mod = info->nested; mod; mod = mod->next)
7273 g_string_append_printf (fullName, "+%s", (char*)mod->data);
7274
7275 assembly = mono_domain_try_type_resolve ( mono_domain_get (), fullName->str, NULL);
7276 if (assembly) {
7277 if (assembly->assembly->dynamic)
7278 type = mono_reflection_get_type_internal_dynamic (rootimage, assembly->assembly, info, ignorecase);
7279 else
7280 type = mono_reflection_get_type_internal (rootimage, assembly->assembly->image,
7281 info, ignorecase);
7282 }
7283 g_string_free (fullName, TRUE);
7284 return type;
7285 }
7286
7287 void
7288 mono_reflection_free_type_info (MonoTypeNameParse *info)
7289 {
7290 g_list_free (info->modifiers);
7291 g_list_free (info->nested);
7292
7293 if (info->type_arguments) {
7294 int i;
7295
7296 for (i = 0; i < info->type_arguments->len; i++) {
7297 MonoTypeNameParse *subinfo = g_ptr_array_index (info->type_arguments, i);
7298
7299 mono_reflection_free_type_info (subinfo);
7300 /*We free the subinfo since it is allocated by _mono_reflection_parse_type*/
7301 g_free (subinfo);
7302 }
7303
7304 g_ptr_array_free (info->type_arguments, TRUE);
7305 }
7306 }
7307
7308 /*
7309 * mono_reflection_type_from_name:
7310 * @name: type name.
7311 * @image: a metadata context (can be NULL).
7312 *
7313 * Retrieves a MonoType from its @name. If the name is not fully qualified,
7314 * it defaults to get the type from @image or, if @image is NULL or loading
7315 * from it fails, uses corlib.
7316 *
7317 */
7318 MonoType*
7319 mono_reflection_type_from_name (char *name, MonoImage *image)
7320 {
7321 MonoType *type = NULL;
7322 MonoTypeNameParse info;
7323 char *tmp;
7324
7325 /* Make a copy since parse_type modifies its argument */
7326 tmp = g_strdup (name);
7327
7328 /*g_print ("requested type %s\n", str);*/
7329 if (mono_reflection_parse_type (tmp, &info)) {
7330 type = _mono_reflection_get_type_from_info (&info, image, FALSE);
7331 }
7332
7333 g_free (tmp);
7334 mono_reflection_free_type_info (&info);
7335 return type;
7336 }
7337
7338 /*
7339 * mono_reflection_get_token:
7340 *
7341 * Return the metadata token of OBJ which should be an object
7342 * representing a metadata element.
7343 */
7344 guint32
7345 mono_reflection_get_token (MonoObject *obj)
7346 {
7347 MonoClass *klass;
7348 guint32 token = 0;
7349
7350 klass = obj->vtable->klass;
7351
7352 if (strcmp (klass->name, "MethodBuilder") == 0) {
7353 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
7354
7355 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
7356 } else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
7357 MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
7358
7359 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
7360 } else if (strcmp (klass->name, "FieldBuilder") == 0) {
7361 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
7362
7363 /* Call mono_image_create_token so the object gets added to the tokens hash table */
7364 token = mono_image_create_token (((MonoReflectionTypeBuilder*)fb->typeb)->module->dynamic_image, obj, FALSE, TRUE);
7365 } else if (strcmp (klass->name, "TypeBuilder") == 0) {
7366 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
7367 token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
7368 } else if (strcmp (klass->name, "MonoType") == 0) {
7369 MonoReflectionType *tb = (MonoReflectionType *)obj;
7370 token = mono_class_from_mono_type (tb->type)->type_token;
7371 } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
7372 strcmp (klass->name, "MonoMethod") == 0 ||
7373 strcmp (klass->name, "MonoGenericMethod") == 0 ||
7374 strcmp (klass->name, "MonoGenericCMethod") == 0) {
7375 MonoReflectionMethod *m = (MonoReflectionMethod *)obj;
7376 if (m->method->is_inflated) {
7377 MonoMethodInflated *inflated = (MonoMethodInflated *) m->method;
7378 return inflated->declaring->token;
7379 } else {
7380 token = m->method->token;
7381 }
7382 } else if (strcmp (klass->name, "MonoField") == 0) {
7383 MonoReflectionField *f = (MonoReflectionField*)obj;
7384
7385 if (is_field_on_inst (f->field)) {
7386 MonoDynamicGenericClass *dgclass = (MonoDynamicGenericClass*)f->field->parent->generic_class;
7387 int field_index = f->field - dgclass->fields;
7388 MonoObject *obj;
7389
7390 g_assert (field_index >= 0 && field_index < dgclass->count_fields);
7391 obj = dgclass->field_objects [field_index];
7392 return mono_reflection_get_token (obj);
7393 }
7394 token = mono_class_get_field_token (f->field);
7395 } else if (strcmp (klass->name, "MonoProperty") == 0) {
7396 MonoReflectionProperty *p = (MonoReflectionProperty*)obj;
7397
7398 token = mono_class_get_property_token (p->property);
7399 } else if (strcmp (klass->name, "MonoEvent") == 0) {
7400 MonoReflectionMonoEvent *p = (MonoReflectionMonoEvent*)obj;
7401
7402 token = mono_class_get_event_token (p->event);
7403 } else if (strcmp (klass->name, "ParameterInfo") == 0) {
7404 MonoReflectionParameter *p = (MonoReflectionParameter*)obj;
7405
7406 token = mono_method_get_param_token (((MonoReflectionMethod*)p->MemberImpl)->method, p->PositionImpl);
7407 } else if (strcmp (klass->name, "Module") == 0) {
7408 MonoReflectionModule *m = (MonoReflectionModule*)obj;
7409
7410 token = m->token;
7411 } else if (strcmp (klass->name, "Assembly") == 0) {
7412 token = mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1);
7413 } else {
7414 gchar *msg = g_strdup_printf ("MetadataToken is not supported for type '%s.%s'", klass->name_space, klass->name);
7415 MonoException *ex = mono_get_exception_not_implemented (msg);
7416 g_free (msg);
7417 mono_raise_exception (ex);
7418 }
7419
7420 return token;
7421 }
7422
7423 static void*
7424 load_cattr_value (MonoImage *image, MonoType *t, const char *p, const char **end)
7425 {
7426 int slen, type = t->type;
7427 MonoClass *tklass = t->data.klass;
7428
7429 handle_enum:
7430 switch (type) {
7431 case MONO_TYPE_U1:
7432 case MONO_TYPE_I1:
7433 case MONO_TYPE_BOOLEAN: {
7434 MonoBoolean *bval = g_malloc (sizeof (MonoBoolean));
7435 *bval = *p;
7436 *end = p + 1;
7437 return bval;
7438 }
7439 case MONO_TYPE_CHAR:
7440 case MONO_TYPE_U2:
7441 case MONO_TYPE_I2: {
7442 guint16 *val = g_malloc (sizeof (guint16));
7443 *val = read16 (p);
7444 *end = p + 2;
7445 return val;
7446 }
7447 #if SIZEOF_VOID_P == 4
7448 case MONO_TYPE_U:
7449 case MONO_TYPE_I:
7450 #endif
7451 case MONO_TYPE_R4:
7452 case MONO_TYPE_U4:
7453 case MONO_TYPE_I4: {
7454 guint32 *val = g_malloc (sizeof (guint32));
7455 *val = read32 (p);
7456 *end = p + 4;
7457 return val;
7458 }
7459 #if SIZEOF_VOID_P == 8
7460 case MONO_TYPE_U: /* error out instead? this should probably not happen */
7461 case MONO_TYPE_I:
7462 #endif
7463 case MONO_TYPE_U8:
7464 case MONO_TYPE_I8: {
7465 guint64 *val = g_malloc (sizeof (guint64));
7466 *val = read64 (p);
7467 *end = p + 8;
7468 return val;
7469 }
7470 case MONO_TYPE_R8: {
7471 double *val = g_malloc (sizeof (double));
7472 readr8 (p, val);
7473 *end = p + 8;
7474 return val;
7475 }
7476 case MONO_TYPE_VALUETYPE:
7477 if (t->data.klass->enumtype) {
7478 type = mono_class_enum_basetype (t->data.klass)->type;
7479 goto handle_enum;
7480 } else {
7481 g_error ("generic valutype %s not handled in custom attr value decoding", t->data.klass->name);
7482 }
7483 break;
7484 case MONO_TYPE_STRING:
7485 if (*p == (char)0xFF) {
7486 *end = p + 1;
7487 return NULL;
7488 }
7489 slen = mono_metadata_decode_value (p, &p);
7490 *end = p + slen;
7491 return mono_string_new_len (mono_domain_get (), p, slen);
7492 case MONO_TYPE_CLASS: {
7493 char *n;
7494 MonoType *t;
7495 if (*p == (char)0xFF) {
7496 *end = p + 1;
7497 return NULL;
7498 }
7499 handle_type:
7500 slen = mono_metadata_decode_value (p, &p);
7501 n = g_memdup (p, slen + 1);
7502 n [slen] = 0;
7503 t = mono_reflection_type_from_name (n, image);
7504 if (!t)
7505 g_warning ("Cannot load type '%s'", n);
7506 g_free (n);
7507 *end = p + slen;
7508 if (t)
7509 return mono_type_get_object (mono_domain_get (), t);
7510 else
7511 return NULL;
7512 }
7513 case MONO_TYPE_OBJECT: {
7514 char subt = *p++;
7515 MonoObject *obj;
7516 MonoClass *subc = NULL;
7517 void *val;
7518
7519 if (subt == 0x50) {
7520 goto handle_type;
7521 } else if (subt == 0x0E) {
7522 type = MONO_TYPE_STRING;
7523 goto handle_enum;
7524 } else if (subt == 0x1D) {
7525 MonoType simple_type = {{0}};
7526 int etype = *p;
7527 p ++;
7528
7529 if (etype == 0x51)
7530 /* See Partition II, Appendix B3 */
7531 etype = MONO_TYPE_OBJECT;
7532 type = MONO_TYPE_SZARRAY;
7533 simple_type.type = etype;
7534 tklass = mono_class_from_mono_type (&simple_type);
7535 goto handle_enum;
7536 } else if (subt == 0x55) {
7537 char *n;
7538 MonoType *t;
7539 slen = mono_metadata_decode_value (p, &p);
7540 n = g_memdup (p, slen + 1);
7541 n [slen] = 0;
7542 t = mono_reflection_type_from_name (n, image);
7543 if (!t)
7544 g_error ("Cannot load type '%s'", n);
7545 g_free (n);
7546 p += slen;
7547 subc = mono_class_from_mono_type (t);
7548 } else if (subt >= MONO_TYPE_BOOLEAN && subt <= MONO_TYPE_R8) {
7549 MonoType simple_type = {{0}};
7550 simple_type.type = subt;
7551 subc = mono_class_from_mono_type (&simple_type);
7552 } else {
7553 g_error ("Unknown type 0x%02x for object type encoding in custom attr", subt);
7554 }
7555 val = load_cattr_value (image, &subc->byval_arg, p, end);
7556 obj = mono_object_new (mono_domain_get (), subc);
7557 memcpy ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
7558 g_free (val);
7559 return obj;
7560 }
7561 case MONO_TYPE_SZARRAY: {
7562 MonoArray *arr;
7563 guint32 i, alen, basetype;
7564 alen = read32 (p);
7565 p += 4;
7566 if (alen == 0xffffffff) {
7567 *end = p;
7568 return NULL;
7569 }
7570 arr = mono_array_new (mono_domain_get(), tklass, alen);
7571 basetype = tklass->byval_arg.type;
7572 if (basetype == MONO_TYPE_VALUETYPE && tklass->enumtype)
7573 basetype = mono_class_enum_basetype (tklass)->type;
7574 switch (basetype)
7575 {
7576 case MONO_TYPE_U1:
7577 case MONO_TYPE_I1:
7578 case MONO_TYPE_BOOLEAN:
7579 for (i = 0; i < alen; i++) {
7580 MonoBoolean val = *p++;
7581 mono_array_set (arr, MonoBoolean, i, val);
7582 }
7583 break;
7584 case MONO_TYPE_CHAR:
7585 case MONO_TYPE_U2:
7586 case MONO_TYPE_I2:
7587 for (i = 0; i < alen; i++) {
7588 guint16 val = read16 (p);
7589 mono_array_set (arr, guint16, i, val);
7590 p += 2;
7591 }
7592 break;
7593 case MONO_TYPE_R4:
7594 case MONO_TYPE_U4:
7595 case MONO_TYPE_I4:
7596 for (i = 0; i < alen; i++) {
7597 guint32 val = read32 (p);
7598 mono_array_set (arr, guint32, i, val);
7599 p += 4;
7600 }
7601 break;
7602 case MONO_TYPE_R8:
7603 for (i = 0; i < alen; i++) {
7604 double val;
7605 readr8 (p, &val);
7606 mono_array_set (arr, double, i, val);
7607 p += 8;
7608 }
7609 break;
7610 case MONO_TYPE_U8:
7611 case MONO_TYPE_I8:
7612 for (i = 0; i < alen; i++) {
7613 guint64 val = read64 (p);
7614 mono_array_set (arr, guint64, i, val);
7615 p += 8;
7616 }
7617 break;
7618 case MONO_TYPE_CLASS:
7619 case MONO_TYPE_OBJECT:
7620 case MONO_TYPE_STRING:
7621 for (i = 0; i < alen; i++) {
7622 MonoObject *item = load_cattr_value (image, &tklass->byval_arg, p, &p);
7623 mono_array_setref (arr, i, item);
7624 }
7625 break;
7626 default:
7627 g_error ("Type 0x%02x not handled in custom attr array decoding", basetype);
7628 }
7629 *end=p;
7630 return arr;
7631 }
7632 default:
7633 g_error ("Type 0x%02x not handled in custom attr value decoding", type);
7634 }
7635 return NULL;
7636 }
7637
7638 static MonoObject*
7639 create_cattr_typed_arg (MonoType *t, MonoObject *val)
7640 {
7641 static MonoClass *klass;
7642 static MonoMethod *ctor;
7643 MonoObject *retval;
7644 void *params [2], *unboxed;
7645
7646 if (!klass)
7647 klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "CustomAttributeTypedArgument");
7648 if (!ctor)
7649 ctor = mono_class_get_method_from_name (klass, ".ctor", 2);
7650
7651 params [0] = mono_type_get_object (mono_domain_get (), t);
7652 params [1] = val;
7653 retval = mono_object_new (mono_domain_get (), klass);
7654 unboxed = mono_object_unbox (retval);
7655 mono_runtime_invoke (ctor, unboxed, params, NULL);
7656
7657 return retval;
7658 }
7659
7660 static MonoObject*
7661 create_cattr_named_arg (void *minfo, MonoObject *typedarg)
7662 {
7663 static MonoClass *klass;
7664 static MonoMethod *ctor;
7665 MonoObject *retval;
7666 void *unboxed, *params [2];
7667
7668 if (!klass)
7669 klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "CustomAttributeNamedArgument");
7670 if (!ctor)
7671 ctor = mono_class_get_method_from_name (klass, ".ctor", 2);
7672
7673 params [0] = minfo;
7674 params [1] = typedarg;
7675 retval = mono_object_new (mono_domain_get (), klass);
7676 unboxed = mono_object_unbox (retval);
7677 mono_runtime_invoke (ctor, unboxed, params, NULL);
7678
7679 return retval;
7680 }
7681
7682 static gboolean
7683 type_is_reference (MonoType *type)
7684 {
7685 switch (type->type) {
7686 case MONO_TYPE_BOOLEAN:
7687 case MONO_TYPE_CHAR:
7688 case MONO_TYPE_U:
7689 case MONO_TYPE_I:
7690 case MONO_TYPE_U1:
7691 case MONO_TYPE_I1:
7692 case MONO_TYPE_U2:
7693 case MONO_TYPE_I2:
7694 case MONO_TYPE_U4:
7695 case MONO_TYPE_I4:
7696 case MONO_TYPE_U8:
7697 case MONO_TYPE_I8:
7698 case MONO_TYPE_R8:
7699 case MONO_TYPE_R4:
7700 case MONO_TYPE_VALUETYPE:
7701 return FALSE;
7702 default:
7703 return TRUE;
7704 }
7705 }
7706
7707 static void
7708 free_param_data (MonoMethodSignature *sig, void **params) {
7709 int i;
7710 for (i = 0; i < sig->param_count; ++i) {
7711 if (!type_is_reference (sig->params [i]))
7712 g_free (params [i]);
7713 }
7714 }
7715
7716 /*
7717 * Find the field index in the metadata FieldDef table.
7718 */
7719 static guint32
7720 find_field_index (MonoClass *klass, MonoClassField *field) {
7721 int i;
7722
7723 for (i = 0; i < klass->field.count; ++i) {
7724 if (field == &klass->fields [i])
7725 return klass->field.first + 1 + i;
7726 }
7727 return 0;
7728 }
7729
7730 /*
7731 * Find the property index in the metadata Property table.
7732 */
7733 static guint32
7734 find_property_index (MonoClass *klass, MonoProperty *property) {
7735 int i;
7736
7737 for (i = 0; i < klass->ext->property.count; ++i) {
7738 if (property == &klass->ext->properties [i])
7739 return klass->ext->property.first + 1 + i;
7740 }
7741 return 0;
7742 }
7743
7744 /*
7745 * Find the event index in the metadata Event table.
7746 */
7747 static guint32
7748 find_event_index (MonoClass *klass, MonoEvent *event) {
7749 int i;
7750
7751 for (i = 0; i < klass->ext->event.count; ++i) {
7752 if (event == &klass->ext->events [i])
7753 return klass->ext->event.first + 1 + i;
7754 }
7755 return 0;
7756 }
7757
7758 static MonoObject*
7759 create_custom_attr (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len)
7760 {
7761 const char *p = (const char*)data;
7762 const char *named;
7763 guint32 i, j, num_named;
7764 MonoObject *attr;
7765 void *params_buf [32];
7766 void **params;
7767 MonoMethodSignature *sig;
7768
7769 mono_class_init (method->klass);
7770
7771 if (len == 0) {
7772 attr = mono_object_new (mono_domain_get (), method->klass);
7773 mono_runtime_invoke (method, attr, NULL, NULL);
7774 return attr;
7775 }
7776
7777 if (len < 2 || read16 (p) != 0x0001) /* Prolog */
7778 return NULL;
7779
7780 /*g_print ("got attr %s\n", method->klass->name);*/
7781
7782 sig = mono_method_signature (method);
7783 if (sig->param_count < 32)
7784 params = params_buf;
7785 else
7786 /* Allocate using GC so it gets GC tracking */
7787 params = mono_gc_alloc_fixed (sig->param_count * sizeof (void*), NULL);
7788
7789 /* skip prolog */
7790 p += 2;
7791 for (i = 0; i < mono_method_signature (method)->param_count; ++i) {
7792 params [i] = load_cattr_value (image, mono_method_signature (method)->params [i], p, &p);
7793 }
7794
7795 named = p;
7796 attr = mono_object_new (mono_domain_get (), method->klass);
7797 mono_runtime_invoke (method, attr, params, NULL);
7798 free_param_data (method->signature, params);
7799 num_named = read16 (named);
7800 named += 2;
7801 for (j = 0; j < num_named; j++) {
7802 gint name_len;
7803 char *name, named_type, data_type;
7804 named_type = *named++;
7805 data_type = *named++; /* type of data */
7806 if (data_type == MONO_TYPE_SZARRAY)
7807 data_type = *named++;
7808 if (data_type == MONO_TYPE_ENUM) {
7809 gint type_len;
7810 char *type_name;
7811 type_len = mono_metadata_decode_blob_size (named, &named);
7812 type_name = g_malloc (type_len + 1);
7813 memcpy (type_name, named, type_len);
7814 type_name [type_len] = 0;
7815 named += type_len;
7816 /* FIXME: lookup the type and check type consistency */
7817 g_free (type_name);
7818 }
7819 name_len = mono_metadata_decode_blob_size (named, &named);
7820 name = g_malloc (name_len + 1);
7821 memcpy (name, named, name_len);
7822 name [name_len] = 0;
7823 named += name_len;
7824 if (named_type == 0x53) {
7825 MonoClassField *field = mono_class_get_field_from_name (mono_object_class (attr), name);
7826 void *val = load_cattr_value (image, field->type, named, &named);
7827 mono_field_set_value (attr, field, val);
7828 if (!type_is_reference (field->type))
7829 g_free (val);
7830 } else if (named_type == 0x54) {
7831 MonoProperty *prop;
7832 void *pparams [1];
7833 MonoType *prop_type;
7834
7835 prop = mono_class_get_property_from_name (mono_object_class (attr), name);
7836 /* can we have more that 1 arg in a custom attr named property? */
7837 prop_type = prop->get? mono_method_signature (prop->get)->ret :
7838 mono_method_signature (prop->set)->params [mono_method_signature (prop->set)->param_count - 1];
7839 pparams [0] = load_cattr_value (image, prop_type, named, &named);
7840 mono_property_set_value (prop, attr, pparams, NULL);
7841 if (!type_is_reference (prop_type))
7842 g_free (pparams [0]);
7843 }
7844 g_free (name);
7845 }
7846
7847 if (params != params_buf)
7848 mono_gc_free_fixed (params);
7849
7850 return attr;
7851 }
7852
7853 static MonoObject*
7854 create_custom_attr_data (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len)
7855 {
7856 MonoArray *typedargs, *namedargs;
7857 MonoClass *attrklass;
7858 static MonoMethod *ctor;
7859 MonoDomain *domain;
7860 MonoObject *attr;
7861 const char *p = (const char*)data;
7862 const char *named;
7863 guint32 i, j, num_named;
7864 void *params [3];
7865
7866 mono_class_init (method->klass);
7867
7868 if (!ctor)
7869 ctor = mono_class_get_method_from_name (mono_defaults.customattribute_data_class, ".ctor", 3);
7870
7871 domain = mono_domain_get ();
7872 if (len == 0) {
7873 /* This is for Attributes with no parameters */
7874 attr = mono_object_new (domain, mono_defaults.customattribute_data_class);
7875 params [0] = mono_method_get_object (domain, method, NULL);
7876 params [1] = params [2] = NULL;
7877 mono_runtime_invoke (method, attr, params, NULL);
7878 return attr;
7879 }
7880
7881 if (len < 2 || read16 (p) != 0x0001) /* Prolog */
7882 return NULL;
7883
7884 typedargs = mono_array_new (domain, mono_get_object_class (), mono_method_signature (method)->param_count);
7885
7886 /* skip prolog */
7887 p += 2;
7888 for (i = 0; i < mono_method_signature (method)->param_count; ++i) {
7889 MonoObject *obj, *typedarg;
7890 void *val;
7891
7892 val = load_cattr_value (image, mono_method_signature (method)->params [i], p, &p);
7893 obj = type_is_reference (mono_method_signature (method)->params [i]) ?
7894 val : mono_value_box (domain, mono_class_from_mono_type (mono_method_signature (method)->params [i]), val);
7895 typedarg = create_cattr_typed_arg (mono_method_signature (method)->params [i], obj);
7896 mono_array_setref (typedargs, i, typedarg);
7897
7898 if (!type_is_reference (mono_method_signature (method)->params [i]))
7899 g_free (val);
7900 }
7901
7902 named = p;
7903 num_named = read16 (named);
7904 namedargs = mono_array_new (domain, mono_get_object_class (), num_named);
7905 named += 2;
7906 attrklass = method->klass;
7907 for (j = 0; j < num_named; j++) {
7908 gint name_len;
7909 char *name, named_type, data_type;
7910 named_type = *named++;
7911 data_type = *named++; /* type of data */
7912 if (data_type == MONO_TYPE_SZARRAY)
7913 data_type = *named++;
7914 if (data_type == MONO_TYPE_ENUM) {
7915 gint type_len;
7916 char *type_name;
7917 type_len = mono_metadata_decode_blob_size (named, &named);
7918 type_name = g_malloc (type_len + 1);
7919 memcpy (type_name, named, type_len);
7920 type_name [type_len] = 0;
7921 named += type_len;
7922 /* FIXME: lookup the type and check type consistency */
7923 g_free (type_name);
7924 }
7925 name_len = mono_metadata_decode_blob_size (named, &named);
7926 name = g_malloc (name_len + 1);
7927 memcpy (name, named, name_len);
7928 name [name_len] = 0;
7929 named += name_len;
7930 if (named_type == 0x53) {
7931 MonoObject *obj, *typedarg, *namedarg;
7932 MonoClassField *field = mono_class_get_field_from_name (attrklass, name);
7933 void *minfo, *val = load_cattr_value (image, field->type, named, &named);
7934
7935 minfo = mono_field_get_object (domain, NULL, field);
7936 obj = type_is_reference (field->type) ? val : mono_value_box (domain, mono_class_from_mono_type (field->type), val);
7937 typedarg = create_cattr_typed_arg (field->type, obj);
7938 namedarg = create_cattr_named_arg (minfo, typedarg);
7939 mono_array_setref (namedargs, j, namedarg);
7940 if (!type_is_reference (field->type))
7941 g_free (val);
7942 } else if (named_type == 0x54) {
7943 MonoObject *obj, *typedarg, *namedarg;
7944 MonoType *prop_type;
7945 void *val, *minfo;
7946 MonoProperty *prop = mono_class_get_property_from_name (attrklass, name);
7947
7948 prop_type = prop->get? mono_method_signature (prop->get)->ret :
7949 mono_method_signature (prop->set)->params [mono_method_signature (prop->set)->param_count - 1];
7950 minfo = mono_property_get_object (domain, NULL, prop);
7951 val = load_cattr_value (image, prop_type, named, &named);
7952 obj = type_is_reference (prop_type) ? val : mono_value_box (domain, mono_class_from_mono_type (prop_type), val);
7953 typedarg = create_cattr_typed_arg (prop_type, obj);
7954 namedarg = create_cattr_named_arg (minfo, typedarg);
7955 mono_array_setref (namedargs, j, namedarg);
7956 if (!type_is_reference (prop_type))
7957 g_free (val);
7958 }
7959 g_free (name);
7960 }
7961 attr = mono_object_new (domain, mono_defaults.customattribute_data_class);
7962 params [0] = mono_method_get_object (domain, method, NULL);
7963 params [1] = typedargs;
7964 params [2] = namedargs;
7965 mono_runtime_invoke (ctor, attr, params, NULL);
7966 return attr;
7967 }
7968
7969 MonoArray*
7970 mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo)
7971 {
7972 MonoArray *result;
7973 MonoObject *attr;
7974 int i;
7975
7976 result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, cinfo->num_attrs);
7977 for (i = 0; i < cinfo->num_attrs; ++i) {
7978 if (!cinfo->attrs [i].ctor)
7979 /* The cattr type is not finished yet */
7980 /* We should include the type name but cinfo doesn't contain it */
7981 mono_raise_exception (mono_get_exception_type_load (NULL, NULL));
7982 attr = create_custom_attr (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size);
7983 mono_array_setref (result, i, attr);
7984 }
7985 return result;
7986 }
7987
7988 static MonoArray*
7989 mono_custom_attrs_construct_by_type (MonoCustomAttrInfo *cinfo, MonoClass *attr_klass)
7990 {
7991 MonoArray *result;
7992 MonoObject *attr;
7993 int i, n;
7994
7995 n = 0;
7996 for (i = 0; i < cinfo->num_attrs; ++i) {
7997 if (mono_class_is_assignable_from (attr_klass, cinfo->attrs [i].ctor->klass))
7998 n ++;
7999 }
8000
8001 result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, n);
8002 n = 0;
8003 for (i = 0; i < cinfo->num_attrs; ++i) {
8004 if (mono_class_is_assignable_from (attr_klass, cinfo->attrs [i].ctor->klass)) {
8005 attr = create_custom_attr (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size);
8006 mono_array_setref (result, n, attr);
8007 n ++;
8008 }
8009 }
8010 return result;
8011 }
8012
8013 static MonoArray*
8014 mono_custom_attrs_data_construct (MonoCustomAttrInfo *cinfo)
8015 {
8016 MonoArray *result;
8017 MonoObject *attr;
8018 int i;
8019
8020 result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, cinfo->num_attrs);
8021 for (i = 0; i < cinfo->num_attrs; ++i) {
8022 attr = create_custom_attr_data (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size);
8023 mono_array_setref (result, i, attr);
8024 }
8025 return result;
8026 }
8027
8028 /**
8029 * mono_custom_attrs_from_index:
8030 *
8031 * Returns: NULL if no attributes are found or if a loading error occurs.
8032 */
8033 MonoCustomAttrInfo*
8034 mono_custom_attrs_from_index (MonoImage *image, guint32 idx)
8035 {
8036 guint32 mtoken, i, len;
8037 guint32 cols [MONO_CUSTOM_ATTR_SIZE];
8038 MonoTableInfo *ca;
8039 MonoCustomAttrInfo *ainfo;
8040 GList *tmp, *list = NULL;
8041 const char *data;
8042
8043 ca = &image->tables [MONO_TABLE_CUSTOMATTRIBUTE];
8044
8045 i = mono_metadata_custom_attrs_from_index (image, idx);
8046 if (!i)
8047 return NULL;
8048 i --;
8049 while (i < ca->rows) {
8050 if (mono_metadata_decode_row_col (ca, i, MONO_CUSTOM_ATTR_PARENT) != idx)
8051 break;
8052 list = g_list_prepend (list, GUINT_TO_POINTER (i));
8053 ++i;
8054 }
8055 len = g_list_length (list);
8056 if (!len)
8057 return NULL;
8058 ainfo = g_malloc0 (sizeof (MonoCustomAttrInfo) + sizeof (MonoCustomAttrEntry) * (len - MONO_ZERO_LEN_ARRAY));
8059 ainfo->num_attrs = len;
8060 ainfo->image = image;
8061 for (i = 0, tmp = list; i < len; ++i, tmp = tmp->next) {
8062 mono_metadata_decode_row (ca, GPOINTER_TO_UINT (tmp->data), cols, MONO_CUSTOM_ATTR_SIZE);
8063 mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> MONO_CUSTOM_ATTR_TYPE_BITS;
8064 switch (cols [MONO_CUSTOM_ATTR_TYPE] & MONO_CUSTOM_ATTR_TYPE_MASK) {
8065 case MONO_CUSTOM_ATTR_TYPE_METHODDEF:
8066 mtoken |= MONO_TOKEN_METHOD_DEF;
8067 break;
8068 case MONO_CUSTOM_ATTR_TYPE_MEMBERREF:
8069 mtoken |= MONO_TOKEN_MEMBER_REF;
8070 break;
8071 default:
8072 g_error ("Unknown table for custom attr type %08x", cols [MONO_CUSTOM_ATTR_TYPE]);
8073 break;
8074 }
8075 ainfo->attrs [i].ctor = mono_get_method (image, mtoken, NULL);
8076 if (!ainfo->attrs [i].ctor) {
8077 g_warning ("Can't find custom attr constructor image: %s mtoken: 0x%08x", image->name, mtoken);
8078 g_list_free (list);
8079 g_free (ainfo);
8080 return NULL;
8081 }
8082 data = mono_metadata_blob_heap (image, cols [MONO_CUSTOM_ATTR_VALUE]);
8083 ainfo->attrs [i].data_size = mono_metadata_decode_value (data, &data);
8084 ainfo->attrs [i].data = (guchar*)data;
8085 }
8086 g_list_free (list);
8087
8088 return ainfo;
8089 }
8090
8091 MonoCustomAttrInfo*
8092 mono_custom_attrs_from_method (MonoMethod *method)
8093 {
8094 guint32 idx;
8095
8096 /*
8097 * An instantiated method has the same cattrs as the generic method definition.
8098 *
8099 * LAMESPEC: The .NET SRE throws an exception for instantiations of generic method builders
8100 * Note that this stanza is not necessary for non-SRE types, but it's a micro-optimization
8101 */
8102 if (method->is_inflated)
8103 method = ((MonoMethodInflated *) method)->declaring;
8104
8105 if (method->dynamic || method->klass->image->dynamic)
8106 return lookup_custom_attr (method->klass->image, method);
8107
8108 if (!method->token)
8109 /* Synthetic methods */
8110 return NULL;
8111
8112 idx = mono_method_get_index (method);
8113 idx <<= MONO_CUSTOM_ATTR_BITS;
8114 idx |= MONO_CUSTOM_ATTR_METHODDEF;
8115 return mono_custom_attrs_from_index (method->klass->image, idx);
8116 }
8117
8118 MonoCustomAttrInfo*
8119 mono_custom_attrs_from_class (MonoClass *klass)
8120 {
8121 guint32 idx;
8122
8123 if (klass->generic_class)
8124 klass = klass->generic_class->container_class;
8125
8126 if (klass->image->dynamic)
8127 return lookup_custom_attr (klass->image, klass);
8128
8129 if (klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR) {
8130 idx = mono_metadata_token_index (klass->sizes.generic_param_token);
8131 idx <<= MONO_CUSTOM_ATTR_BITS;
8132 idx |= MONO_CUSTOM_ATTR_GENERICPAR;
8133 } else {
8134 idx = mono_metadata_token_index (klass->type_token);
8135 idx <<= MONO_CUSTOM_ATTR_BITS;
8136 idx |= MONO_CUSTOM_ATTR_TYPEDEF;
8137 }
8138 return mono_custom_attrs_from_index (klass->image, idx);
8139 }
8140
8141 MonoCustomAttrInfo*
8142 mono_custom_attrs_from_assembly (MonoAssembly *assembly)
8143 {
8144 guint32 idx;
8145
8146 if (assembly->image->dynamic)
8147 return lookup_custom_attr (assembly->image, assembly);
8148 idx = 1; /* there is only one assembly */
8149 idx <<= MONO_CUSTOM_ATTR_BITS;
8150 idx |= MONO_CUSTOM_ATTR_ASSEMBLY;
8151 return mono_custom_attrs_from_index (assembly->image, idx);
8152 }
8153
8154 static MonoCustomAttrInfo*
8155 mono_custom_attrs_from_module (MonoImage *image)
8156 {
8157 guint32 idx;
8158
8159 if (image->dynamic)
8160 return lookup_custom_attr (image, image);
8161 idx = 1; /* there is only one module */
8162 idx <<= MONO_CUSTOM_ATTR_BITS;
8163 idx |= MONO_CUSTOM_ATTR_MODULE;
8164 return mono_custom_attrs_from_index (image, idx);
8165 }
8166
8167 MonoCustomAttrInfo*
8168 mono_custom_attrs_from_property (MonoClass *klass, MonoProperty *property)
8169 {
8170 guint32 idx;
8171
8172 if (klass->image->dynamic) {
8173 property = mono_metadata_get_corresponding_property_from_generic_type_definition (property);
8174 return lookup_custom_attr (klass->image, property);
8175 }
8176 idx = find_property_index (klass, property);
8177 idx <<= MONO_CUSTOM_ATTR_BITS;
8178 idx |= MONO_CUSTOM_ATTR_PROPERTY;
8179 return mono_custom_attrs_from_index (klass->image, idx);
8180 }
8181
8182 MonoCustomAttrInfo*
8183 mono_custom_attrs_from_event (MonoClass *klass, MonoEvent *event)
8184 {
8185 guint32 idx;
8186
8187 if (klass->image->dynamic) {
8188 event = mono_metadata_get_corresponding_event_from_generic_type_definition (event);
8189 return lookup_custom_attr (klass->image, event);
8190 }
8191 idx = find_event_index (klass, event);
8192 idx <<= MONO_CUSTOM_ATTR_BITS;
8193 idx |= MONO_CUSTOM_ATTR_EVENT;
8194 return mono_custom_attrs_from_index (klass->image, idx);
8195 }
8196
8197 MonoCustomAttrInfo*
8198 mono_custom_attrs_from_field (MonoClass *klass, MonoClassField *field)
8199 {
8200 guint32 idx;
8201 if (klass->image->dynamic) {
8202 field = mono_metadata_get_corresponding_field_from_generic_type_definition (field);
8203 return lookup_custom_attr (klass->image, field);
8204 }
8205 idx = find_field_index (klass, field);
8206 idx <<= MONO_CUSTOM_ATTR_BITS;
8207 idx |= MONO_CUSTOM_ATTR_FIELDDEF;
8208 return mono_custom_attrs_from_index (klass->image, idx);
8209 }
8210
8211 MonoCustomAttrInfo*
8212 mono_custom_attrs_from_param (MonoMethod *method, guint32 param)
8213 {
8214 MonoTableInfo *ca;
8215 guint32 i, idx, method_index;
8216 guint32 param_list, param_last, param_pos, found;
8217 MonoImage *image;
8218 MonoReflectionMethodAux *aux;
8219
8220 /*
8221 * An instantiated method has the same cattrs as the generic method definition.
8222 *
8223 * LAMESPEC: The .NET SRE throws an exception for instantiations of generic method builders
8224 * Note that this stanza is not necessary for non-SRE types, but it's a micro-optimization
8225 */
8226 if (method->is_inflated)
8227 method = ((MonoMethodInflated *) method)->declaring;
8228
8229 if (method->klass->image->dynamic) {
8230 MonoCustomAttrInfo *res, *ainfo;
8231 int size;
8232
8233 aux = g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
8234 if (!aux || !aux->param_cattr)
8235 return NULL;
8236
8237 /* Need to copy since it will be freed later */
8238 ainfo = aux->param_cattr [param];
8239 size = sizeof (MonoCustomAttrInfo) + sizeof (MonoCustomAttrEntry) * (ainfo->num_attrs - MONO_ZERO_LEN_ARRAY);
8240 res = g_malloc0 (size);
8241 memcpy (res, ainfo, size);
8242 return res;
8243 }
8244
8245 image = method->klass->image;
8246 method_index = mono_method_get_index (method);
8247 ca = &image->tables [MONO_TABLE_METHOD];
8248
8249 param_list = mono_metadata_decode_row_col (ca, method_index - 1, MONO_METHOD_PARAMLIST);
8250 if (method_index == ca->rows) {
8251 ca = &image->tables [MONO_TABLE_PARAM];
8252 param_last = ca->rows + 1;
8253 } else {
8254 param_last = mono_metadata_decode_row_col (ca, method_index, MONO_METHOD_PARAMLIST);
8255 ca = &image->tables [MONO_TABLE_PARAM];
8256 }
8257 found = FALSE;
8258 for (i = param_list; i < param_last; ++i) {
8259 param_pos = mono_metadata_decode_row_col (ca, i - 1, MONO_PARAM_SEQUENCE);
8260 if (param_pos == param) {
8261 found = TRUE;
8262 break;
8263 }
8264 }
8265 if (!found)
8266 return NULL;
8267 idx = i;
8268 idx <<= MONO_CUSTOM_ATTR_BITS;
8269 idx |= MONO_CUSTOM_ATTR_PARAMDEF;
8270 return mono_custom_attrs_from_index (image, idx);
8271 }
8272
8273 gboolean
8274 mono_custom_attrs_has_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass)
8275 {
8276 int i;
8277 MonoClass *klass;
8278 for (i = 0; i < ainfo->num_attrs; ++i) {
8279 klass = ainfo->attrs [i].ctor->klass;
8280 if (mono_class_has_parent (klass, attr_klass) || (MONO_CLASS_IS_INTERFACE (attr_klass) && mono_class_is_assignable_from (attr_klass, klass)))
8281 return TRUE;
8282 }
8283 return FALSE;
8284 }
8285
8286 MonoObject*
8287 mono_custom_attrs_get_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass)
8288 {
8289 int i, attr_index;
8290 MonoClass *klass;
8291 MonoArray *attrs;
8292
8293 attr_index = -1;
8294 for (i = 0; i < ainfo->num_attrs; ++i) {
8295 klass = ainfo->attrs [i].ctor->klass;
8296 if (mono_class_has_parent (klass, attr_klass)) {
8297 attr_index = i;
8298 break;
8299 }
8300 }
8301 if (attr_index == -1)
8302 return NULL;
8303
8304 attrs = mono_custom_attrs_construct (ainfo);
8305 if (attrs)
8306 return mono_array_get (attrs, MonoObject*, attr_index);
8307 else
8308 return NULL;
8309 }
8310
8311 /*
8312 * mono_reflection_get_custom_attrs_info:
8313 * @obj: a reflection object handle
8314 *
8315 * Return the custom attribute info for attributes defined for the
8316 * reflection handle @obj. The objects.
8317 *
8318 * FIXME this function leaks like a sieve for SRE objects.
8319 */
8320 MonoCustomAttrInfo*
8321 mono_reflection_get_custom_attrs_info (MonoObject *obj)
8322 {
8323 MonoClass *klass;
8324 MonoCustomAttrInfo *cinfo = NULL;
8325
8326 klass = obj->vtable->klass;
8327 if (klass == mono_defaults.monotype_class) {
8328 MonoReflectionType *rtype = (MonoReflectionType*)obj;
8329 klass = mono_class_from_mono_type (rtype->type);
8330 cinfo = mono_custom_attrs_from_class (klass);
8331 } else if (strcmp ("Assembly", klass->name) == 0) {
8332 MonoReflectionAssembly *rassembly = (MonoReflectionAssembly*)obj;
8333 cinfo = mono_custom_attrs_from_assembly (rassembly->assembly);
8334 } else if (strcmp ("Module", klass->name) == 0) {
8335 MonoReflectionModule *module = (MonoReflectionModule*)obj;
8336 cinfo = mono_custom_attrs_from_module (module->image);
8337 } else if (strcmp ("MonoProperty", klass->name) == 0) {
8338 MonoReflectionProperty *rprop = (MonoReflectionProperty*)obj;
8339 cinfo = mono_custom_attrs_from_property (rprop->property->parent, rprop->property);
8340 } else if (strcmp ("MonoEvent", klass->name) == 0) {
8341 MonoReflectionMonoEvent *revent = (MonoReflectionMonoEvent*)obj;
8342 cinfo = mono_custom_attrs_from_event (revent->event->parent, revent->event);
8343 } else if (strcmp ("MonoField", klass->name) == 0) {
8344 MonoReflectionField *rfield = (MonoReflectionField*)obj;
8345 cinfo = mono_custom_attrs_from_field (rfield->field->parent, rfield->field);
8346 } else if ((strcmp ("MonoMethod", klass->name) == 0) || (strcmp ("MonoCMethod", klass->name) == 0)) {
8347 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)obj;
8348 cinfo = mono_custom_attrs_from_method (rmethod->method);
8349 } else if ((strcmp ("MonoGenericMethod", klass->name) == 0) || (strcmp ("MonoGenericCMethod", klass->name) == 0)) {
8350 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)obj;
8351 cinfo = mono_custom_attrs_from_method (rmethod->method);
8352 } else if (strcmp ("ParameterInfo", klass->name) == 0) {
8353 MonoReflectionParameter *param = (MonoReflectionParameter*)obj;
8354 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)param->MemberImpl;
8355 cinfo = mono_custom_attrs_from_param (rmethod->method, param->PositionImpl + 1);
8356 } else if (strcmp ("AssemblyBuilder", klass->name) == 0) {
8357 MonoReflectionAssemblyBuilder *assemblyb = (MonoReflectionAssemblyBuilder*)obj;
8358 cinfo = mono_custom_attrs_from_builders (NULL, assemblyb->assembly.assembly->image, assemblyb->cattrs);
8359 } else if (strcmp ("TypeBuilder", klass->name) == 0) {
8360 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)obj;
8361 cinfo = mono_custom_attrs_from_builders (NULL, &tb->module->dynamic_image->image, tb->cattrs);
8362 } else if (strcmp ("ModuleBuilder", klass->name) == 0) {
8363 MonoReflectionModuleBuilder *mb = (MonoReflectionModuleBuilder*)obj;
8364 cinfo = mono_custom_attrs_from_builders (NULL, &mb->dynamic_image->image, mb->cattrs);
8365 } else if (strcmp ("ConstructorBuilder", klass->name) == 0) {
8366 MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder*)obj;
8367 cinfo = mono_custom_attrs_from_builders (NULL, cb->mhandle->klass->image, cb->cattrs);
8368 } else if (strcmp ("MethodBuilder", klass->name) == 0) {
8369 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)obj;
8370 cinfo = mono_custom_attrs_from_builders (NULL, mb->mhandle->klass->image, mb->cattrs);
8371 } else if (strcmp ("FieldBuilder", klass->name) == 0) {
8372 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder*)obj;
8373 cinfo = mono_custom_attrs_from_builders (NULL, &((MonoReflectionTypeBuilder*)fb->typeb)->module->dynamic_image->image, fb->cattrs);
8374 } else if (strcmp ("MonoGenericClass", klass->name) == 0) {
8375 MonoReflectionGenericClass *gclass = (MonoReflectionGenericClass*)obj;
8376 cinfo = mono_reflection_get_custom_attrs_info ((MonoObject*)gclass->generic_type);
8377 } else { /* handle other types here... */
8378 g_error ("get custom attrs not yet supported for %s", klass->name);
8379 }
8380
8381 return cinfo;
8382 }
8383
8384 /*
8385 * mono_reflection_get_custom_attrs_by_type:
8386 * @obj: a reflection object handle
8387 *
8388 * Return an array with all the custom attributes defined of the
8389 * reflection handle @obj. If @attr_klass is non-NULL, only custom attributes
8390 * of that type are returned. The objects are fully build. Return NULL if a loading error
8391 * occurs.
8392 */
8393 MonoArray*
8394 mono_reflection_get_custom_attrs_by_type (MonoObject *obj, MonoClass *attr_klass)
8395 {
8396 MonoArray *result;
8397 MonoCustomAttrInfo *cinfo;
8398
8399 cinfo = mono_reflection_get_custom_attrs_info (obj);
8400 if (cinfo) {
8401 if (attr_klass)
8402 result = mono_custom_attrs_construct_by_type (cinfo, attr_klass);
8403 else
8404 result = mono_custom_attrs_construct (cinfo);
8405 if (!cinfo->cached)
8406 mono_custom_attrs_free (cinfo);
8407 } else {
8408 if (mono_loader_get_last_error ())
8409 return NULL;
8410 result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, 0);
8411 }
8412
8413 return result;
8414 }
8415
8416 /*
8417 * mono_reflection_get_custom_attrs:
8418 * @obj: a reflection object handle
8419 *
8420 * Return an array with all the custom attributes defined of the
8421 * reflection handle @obj. The objects are fully build. Return NULL if a loading error
8422 * occurs.
8423 */
8424 MonoArray*
8425 mono_reflection_get_custom_attrs (MonoObject *obj)
8426 {
8427 return mono_reflection_get_custom_attrs_by_type (obj, NULL);
8428 }
8429
8430 /*
8431 * mono_reflection_get_custom_attrs_data:
8432 * @obj: a reflection obj handle
8433 *
8434 * Returns an array of System.Reflection.CustomAttributeData,
8435 * which include information about attributes reflected on
8436 * types loaded using the Reflection Only methods
8437 */
8438 MonoArray*
8439 mono_reflection_get_custom_attrs_data (MonoObject *obj)
8440 {
8441 MonoArray *result;
8442 MonoCustomAttrInfo *cinfo;
8443
8444 cinfo = mono_reflection_get_custom_attrs_info (obj);
8445 if (cinfo) {
8446 result = mono_custom_attrs_data_construct (cinfo);
8447 if (!cinfo->cached)
8448 mono_custom_attrs_free (cinfo);
8449 } else
8450 result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, 0);
8451
8452 return result;
8453 }
8454
8455 static MonoReflectionType*
8456 mono_reflection_type_get_underlying_system_type (MonoReflectionType* t)
8457 {
8458 MonoMethod *method_get_underlying_system_type;
8459
8460 method_get_underlying_system_type = mono_object_get_virtual_method ((MonoObject *) t,
8461 mono_class_get_method_from_name (mono_object_class (t),
8462 "get_UnderlyingSystemType",
8463 0));
8464 return (MonoReflectionType *) mono_runtime_invoke (method_get_underlying_system_type, t, NULL, NULL);
8465 }
8466
8467 #ifndef DISABLE_REFLECTION_EMIT
8468 static MonoType*
8469 mono_reflection_type_get_handle (MonoReflectionType* t)
8470 {
8471 if (t->type)
8472 return t->type;
8473
8474 t = mono_reflection_type_get_underlying_system_type (t);
8475 if (t)
8476 return t->type;
8477
8478 return NULL;
8479 }
8480
8481 /**
8482 * LOCKING: Assumes the loader lock is held.
8483 */
8484 static MonoMethodSignature*
8485 parameters_to_signature (MonoImage *image, MonoArray *parameters) {
8486 MonoMethodSignature *sig;
8487 int count, i;
8488
8489 count = parameters? mono_array_length (parameters): 0;
8490
8491 sig = image_g_malloc0 (image, sizeof (MonoMethodSignature) + sizeof (MonoType*) * count);
8492 sig->param_count = count;
8493 sig->sentinelpos = -1; /* FIXME */
8494 for (i = 0; i < count; ++i) {
8495 MonoReflectionType *pt = mono_type_array_get (parameters, i);
8496 sig->params [i] = mono_reflection_type_get_handle (pt);
8497 }
8498 return sig;
8499 }
8500
8501 /**
8502 * LOCKING: Assumes the loader lock is held.
8503 */
8504 static MonoMethodSignature*
8505 ctor_builder_to_signature (MonoImage *image, MonoReflectionCtorBuilder *ctor) {
8506 MonoMethodSignature *sig;
8507
8508 sig = parameters_to_signature (image, ctor->parameters);
8509 sig->hasthis = ctor->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
8510 sig->ret = &mono_defaults.void_class->byval_arg;
8511 return sig;
8512 }
8513
8514 /**
8515 * LOCKING: Assumes the loader lock is held.
8516 */
8517 static MonoMethodSignature*
8518 method_builder_to_signature (MonoImage *image, MonoReflectionMethodBuilder *method) {
8519 MonoMethodSignature *sig;
8520
8521 sig = parameters_to_signature (image, method->parameters);
8522 sig->hasthis = method->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
8523 sig->ret = method->rtype? monotype_cast (method->rtype)->type: &mono_defaults.void_class->byval_arg;
8524 sig->generic_param_count = method->generic_params ? mono_array_length (method->generic_params) : 0;
8525 return sig;
8526 }
8527
8528 static MonoMethodSignature*
8529 dynamic_method_to_signature (MonoReflectionDynamicMethod *method) {
8530 MonoMethodSignature *sig;
8531
8532 sig = parameters_to_signature (NULL, method->parameters);
8533 sig->hasthis = method->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
8534 sig->ret = method->rtype? method->rtype->type: &mono_defaults.void_class->byval_arg;
8535 sig->generic_param_count = 0;
8536 return sig;
8537 }
8538
8539 static void
8540 get_prop_name_and_type (MonoObject *prop, char **name, MonoType **type)
8541 {
8542 MonoClass *klass = mono_object_class (prop);
8543 if (strcmp (klass->name, "PropertyBuilder") == 0) {
8544 MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *)prop;
8545 *name = mono_string_to_utf8 (pb->name);
8546 *type = monotype_cast (pb->type)->type;
8547 } else {
8548 MonoReflectionProperty *p = (MonoReflectionProperty *)prop;
8549 *name = g_strdup (p->property->name);
8550 if (p->property->get)
8551 *type = mono_method_signature (p->property->get)->ret;
8552 else
8553 *type = mono_method_signature (p->property->set)->params [mono_method_signature (p->property->set)->param_count - 1];
8554 }
8555 }
8556
8557 static void
8558 get_field_name_and_type (MonoObject *field, char **name, MonoType **type)
8559 {
8560 MonoClass *klass = mono_object_class (field);
8561 if (strcmp (klass->name, "FieldBuilder") == 0) {
8562 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)field;
8563 *name = mono_string_to_utf8 (fb->name);
8564 *type = monotype_cast (fb->type)->type;
8565 } else {
8566 MonoReflectionField *f = (MonoReflectionField *)field;
8567 *name = g_strdup (mono_field_get_name (f->field));
8568 *type = f->field->type;
8569 }
8570 }
8571 #endif /* !DISABLE_REFLECTION_EMIT */
8572
8573 /*
8574 * Encode a value in a custom attribute stream of bytes.
8575 * The value to encode is either supplied as an object in argument val
8576 * (valuetypes are boxed), or as a pointer to the data in the
8577 * argument argval.
8578 * @type represents the type of the value
8579 * @buffer is the start of the buffer
8580 * @p the current position in the buffer
8581 * @buflen contains the size of the buffer and is used to return the new buffer size
8582 * if this needs to be realloced.
8583 * @retbuffer and @retp return the start and the position of the buffer
8584 */
8585 static void
8586 encode_cattr_value (MonoAssembly *assembly, char *buffer, char *p, char **retbuffer, char **retp, guint32 *buflen, MonoType *type, MonoObject *arg, char *argval)
8587 {
8588 MonoTypeEnum simple_type;
8589
8590 if ((p-buffer) + 10 >= *buflen) {
8591 char *newbuf;
8592 *buflen *= 2;
8593 newbuf = g_realloc (buffer, *buflen);
8594 p = newbuf + (p-buffer);
8595 buffer = newbuf;
8596 }
8597 if (!argval)
8598 argval = ((char*)arg + sizeof (MonoObject));
8599 simple_type = type->type;
8600 handle_enum:
8601 switch (simple_type) {
8602 case MONO_TYPE_BOOLEAN:
8603 case MONO_TYPE_U1:
8604 case MONO_TYPE_I1:
8605 *p++ = *argval;
8606 break;
8607 case MONO_TYPE_CHAR:
8608 case MONO_TYPE_U2:
8609 case MONO_TYPE_I2:
8610 swap_with_size (p, argval, 2, 1);
8611 p += 2;
8612 break;
8613 case MONO_TYPE_U4:
8614 case MONO_TYPE_I4:
8615 case MONO_TYPE_R4:
8616 swap_with_size (p, argval, 4, 1);
8617 p += 4;
8618 break;
8619 case MONO_TYPE_R8:
8620 #if defined(ARM_FPU_FPA) && G_BYTE_ORDER == G_LITTLE_ENDIAN
8621 p [0] = argval [4];
8622 p [1] = argval [5];
8623 p [2] = argval [6];
8624 p [3] = argval [7];
8625 p [4] = argval [0];
8626 p [5] = argval [1];
8627 p [6] = argval [2];
8628 p [7] = argval [3];
8629 #else
8630 swap_with_size (p, argval, 8, 1);
8631 #endif
8632 p += 8;
8633 break;
8634 case MONO_TYPE_U8:
8635 case MONO_TYPE_I8:
8636 swap_with_size (p, argval, 8, 1);
8637 p += 8;
8638 break;
8639 case MONO_TYPE_VALUETYPE:
8640 if (type->data.klass->enumtype) {
8641 simple_type = mono_class_enum_basetype (type->data.klass)->type;
8642 goto handle_enum;
8643 } else {
8644 g_warning ("generic valutype %s not handled in custom attr value decoding", type->data.klass->name);
8645 }
8646 break;
8647 case MONO_TYPE_STRING: {
8648 char *str;
8649 guint32 slen;
8650 if (!arg) {
8651 *p++ = 0xFF;
8652 break;
8653 }
8654 str = mono_string_to_utf8 ((MonoString*)arg);
8655 slen = strlen (str);
8656 if ((p-buffer) + 10 + slen >= *buflen) {
8657 char *newbuf;
8658 *buflen *= 2;
8659 *buflen += slen;
8660 newbuf = g_realloc (buffer, *buflen);
8661 p = newbuf + (p-buffer);
8662 buffer = newbuf;
8663 }
8664 mono_metadata_encode_value (slen, p, &p);
8665 memcpy (p, str, slen);
8666 p += slen;
8667 g_free (str);
8668 break;
8669 }
8670 case MONO_TYPE_CLASS: {
8671 char *str;
8672 guint32 slen;
8673 MonoClass *k;
8674 if (!arg) {
8675 *p++ = 0xFF;
8676 break;
8677 }
8678 k = mono_object_class (arg);
8679 if (!mono_object_isinst (arg, mono_defaults.monotype_class) &&
8680 (strcmp (k->name, "TypeBuilder") || strcmp (k->name_space, "System.Reflection.Emit"))) {
8681 MonoReflectionType* rt = mono_reflection_type_get_underlying_system_type ((MonoReflectionType*) arg);
8682 MonoClass *rtc;
8683
8684 if (rt && (rtc = mono_object_class (rt)) &&
8685 (mono_object_isinst ((MonoObject *) rt, mono_defaults.monotype_class) ||
8686 !strcmp (rtc->name, "TypeBuilder") || !strcmp (rtc->name_space, "System.Reflection.Emit"))) {
8687 arg = (MonoObject *) rt;
8688 k = rtc;
8689 } else
8690 g_error ("Only System.Type allowed, not %s.%s", k->name_space, k->name);
8691 }
8692 handle_type:
8693 str = type_get_qualified_name (((MonoReflectionType*)arg)->type, NULL);
8694 slen = strlen (str);
8695 if ((p-buffer) + 10 + slen >= *buflen) {
8696 char *newbuf;
8697 *buflen *= 2;
8698 *buflen += slen;
8699 newbuf = g_realloc (buffer, *buflen);
8700 p = newbuf + (p-buffer);
8701 buffer = newbuf;
8702 }
8703 mono_metadata_encode_value (slen, p, &p);
8704 memcpy (p, str, slen);
8705 p += slen;
8706 g_free (str);
8707 break;
8708 }
8709 case MONO_TYPE_SZARRAY: {
8710 int len, i;
8711 MonoClass *eclass, *arg_eclass;
8712
8713 if (!arg) {
8714 *p++ = 0xff; *p++ = 0xff; *p++ = 0xff; *p++ = 0xff;
8715 break;
8716 }
8717 len = mono_array_length ((MonoArray*)arg);
8718 *p++ = len & 0xff;
8719 *p++ = (len >> 8) & 0xff;
8720 *p++ = (len >> 16) & 0xff;
8721 *p++ = (len >> 24) & 0xff;
8722 *retp = p;
8723 *retbuffer = buffer;
8724 eclass = type->data.klass;
8725 arg_eclass = mono_object_class (arg)->element_class;
8726
8727 if (!eclass) {
8728 /* Happens when we are called from the MONO_TYPE_OBJECT case below */
8729 eclass = mono_defaults.object_class;
8730 }
8731 if (eclass == mono_defaults.object_class && arg_eclass->valuetype) {
8732 char *elptr = mono_array_addr ((MonoArray*)arg, char, 0);
8733 int elsize = mono_class_array_element_size (arg_eclass);
8734 for (i = 0; i < len; ++i) {
8735 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &arg_eclass->byval_arg, NULL, elptr);
8736 elptr += elsize;
8737 }
8738 } else if (eclass->valuetype && arg_eclass->valuetype) {
8739 char *elptr = mono_array_addr ((MonoArray*)arg, char, 0);
8740 int elsize = mono_class_array_element_size (eclass);
8741 for (i = 0; i < len; ++i) {
8742 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &eclass->byval_arg, NULL, elptr);
8743 elptr += elsize;
8744 }
8745 } else {
8746 for (i = 0; i < len; ++i) {
8747 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &eclass->byval_arg, mono_array_get ((MonoArray*)arg, MonoObject*, i), NULL);
8748 }
8749 }
8750 break;
8751 }
8752 case MONO_TYPE_OBJECT: {
8753 MonoClass *klass;
8754 char *str;
8755 guint32 slen;
8756
8757 /*
8758 * The parameter type is 'object' but the type of the actual
8759 * argument is not. So we have to add type information to the blob
8760 * too. This is completely undocumented in the spec.
8761 */
8762
8763 if (arg == NULL) {
8764 *p++ = MONO_TYPE_STRING; // It's same hack as MS uses
8765 *p++ = 0xFF;
8766 break;
8767 }
8768
8769 klass = mono_object_class (arg);
8770
8771 if (mono_object_isinst (arg, mono_defaults.systemtype_class)) {
8772 *p++ = 0x50;
8773 goto handle_type;
8774 } else if (klass->enumtype) {
8775 *p++ = 0x55;
8776 } else if (klass == mono_defaults.string_class) {
8777 simple_type = MONO_TYPE_STRING;
8778 *p++ = 0x0E;
8779 goto handle_enum;
8780 } else if (klass->rank == 1) {
8781 *p++ = 0x1D;
8782 if (klass->element_class->byval_arg.type == MONO_TYPE_OBJECT)
8783 /* See Partition II, Appendix B3 */
8784 *p++ = 0x51;
8785 else
8786 *p++ = klass->element_class->byval_arg.type;
8787 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &klass->byval_arg, arg, NULL);
8788 break;
8789 } else if (klass->byval_arg.type >= MONO_TYPE_BOOLEAN && klass->byval_arg.type <= MONO_TYPE_R8) {
8790 *p++ = simple_type = klass->byval_arg.type;
8791 goto handle_enum;
8792 } else {
8793 g_error ("unhandled type in custom attr");
8794 }
8795 str = type_get_qualified_name (mono_class_get_type(klass), NULL);
8796 slen = strlen (str);
8797 if ((p-buffer) + 10 + slen >= *buflen) {
8798 char *newbuf;
8799 *buflen *= 2;
8800 *buflen += slen;
8801 newbuf = g_realloc (buffer, *buflen);
8802 p = newbuf + (p-buffer);
8803 buffer = newbuf;
8804 }
8805 mono_metadata_encode_value (slen, p, &p);
8806 memcpy (p, str, slen);
8807 p += slen;
8808 g_free (str);
8809 simple_type = mono_class_enum_basetype (klass)->type;
8810 goto handle_enum;
8811 }
8812 default:
8813 g_error ("type 0x%02x not yet supported in custom attr encoder", simple_type);
8814 }
8815 *retp = p;
8816 *retbuffer = buffer;
8817 }
8818
8819 static void
8820 encode_field_or_prop_type (MonoType *type, char *p, char **retp)
8821 {
8822 if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
8823 char *str = type_get_qualified_name (type, NULL);
8824 int slen = strlen (str);
8825
8826 *p++ = 0x55;
8827 /*
8828 * This seems to be optional...
8829 * *p++ = 0x80;
8830 */
8831 mono_metadata_encode_value (slen, p, &p);
8832 memcpy (p, str, slen);
8833 p += slen;
8834 g_free (str);
8835 } else if (type->type == MONO_TYPE_OBJECT) {
8836 *p++ = 0x51;
8837 } else if (type->type == MONO_TYPE_CLASS) {
8838 /* it should be a type: encode_cattr_value () has the check */
8839 *p++ = 0x50;
8840 } else {
8841 mono_metadata_encode_value (type->type, p, &p);
8842 if (type->type == MONO_TYPE_SZARRAY)
8843 /* See the examples in Partition VI, Annex B */
8844 encode_field_or_prop_type (&type->data.klass->byval_arg, p, &p);
8845 }
8846
8847 *retp = p;
8848 }
8849
8850 #ifndef DISABLE_REFLECTION_EMIT
8851 static void
8852 encode_named_val (MonoReflectionAssembly *assembly, char *buffer, char *p, char **retbuffer, char **retp, guint32 *buflen, MonoType *type, char *name, MonoObject *value)
8853 {
8854 int len;
8855 /* Preallocate a large enough buffer */
8856 if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
8857 char *str = type_get_qualified_name (type, NULL);
8858 len = strlen (str);
8859 g_free (str);
8860 } else if (type->type == MONO_TYPE_SZARRAY && type->data.klass->enumtype) {
8861 char *str = type_get_qualified_name (&type->data.klass->byval_arg, NULL);
8862 len = strlen (str);
8863 g_free (str);
8864 } else {
8865 len = 0;
8866 }
8867 len += strlen (name);
8868
8869 if ((p-buffer) + 20 + len >= *buflen) {
8870 char *newbuf;
8871 *buflen *= 2;
8872 *buflen += len;
8873 newbuf = g_realloc (buffer, *buflen);
8874 p = newbuf + (p-buffer);
8875 buffer = newbuf;
8876 }
8877
8878 encode_field_or_prop_type (type, p, &p);
8879
8880 len = strlen (name);
8881 mono_metadata_encode_value (len, p, &p);
8882 memcpy (p, name, len);
8883 p += len;
8884 encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, buflen, type, value, NULL);
8885 *retp = p;
8886 *retbuffer = buffer;
8887 }
8888
8889 /*
8890 * mono_reflection_get_custom_attrs_blob:
8891 * @ctor: custom attribute constructor
8892 * @ctorArgs: arguments o the constructor
8893 * @properties:
8894 * @propValues:
8895 * @fields:
8896 * @fieldValues:
8897 *
8898 * Creates the blob of data that needs to be saved in the metadata and that represents
8899 * the custom attributed described by @ctor, @ctorArgs etc.
8900 * Returns: a Byte array representing the blob of data.
8901 */
8902 MonoArray*
8903 mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
8904 {
8905 MonoArray *result;
8906 MonoMethodSignature *sig;
8907 MonoObject *arg;
8908 char *buffer, *p;
8909 guint32 buflen, i;
8910
8911 MONO_ARCH_SAVE_REGS;
8912
8913 if (strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
8914 /* sig is freed later so allocate it in the heap */
8915 sig = ctor_builder_to_signature (NULL, (MonoReflectionCtorBuilder*)ctor);
8916 } else {
8917 sig = mono_method_signature (((MonoReflectionMethod*)ctor)->method);
8918 }
8919
8920 g_assert (mono_array_length (ctorArgs) == sig->param_count);
8921 buflen = 256;
8922 p = buffer = g_malloc (buflen);
8923 /* write the prolog */
8924 *p++ = 1;
8925 *p++ = 0;
8926 for (i = 0; i < sig->param_count; ++i) {
8927 arg = mono_array_get (ctorArgs, MonoObject*, i);
8928 encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, &buflen, sig->params [i], arg, NULL);
8929 }
8930 i = 0;
8931 if (properties)
8932 i += mono_array_length (properties);
8933 if (fields)
8934 i += mono_array_length (fields);
8935 *p++ = i & 0xff;
8936 *p++ = (i >> 8) & 0xff;
8937 if (properties) {
8938 MonoObject *prop;
8939 for (i = 0; i < mono_array_length (properties); ++i) {
8940 MonoType *ptype;
8941 char *pname;
8942
8943 prop = mono_array_get (properties, gpointer, i);
8944 get_prop_name_and_type (prop, &pname, &ptype);
8945 *p++ = 0x54; /* PROPERTY signature */
8946 encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ptype, pname, (MonoObject*)mono_array_get (propValues, gpointer, i));
8947 g_free (pname);
8948 }
8949 }
8950
8951 if (fields) {
8952 MonoObject *field;
8953 for (i = 0; i < mono_array_length (fields); ++i) {
8954 MonoType *ftype;
8955 char *fname;
8956
8957 field = mono_array_get (fields, gpointer, i);
8958 get_field_name_and_type (field, &fname, &ftype);
8959 *p++ = 0x53; /* FIELD signature */
8960 encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ftype, fname, (MonoObject*)mono_array_get (fieldValues, gpointer, i));
8961 g_free (fname);
8962 }
8963 }
8964
8965 g_assert (p - buffer <= buflen);
8966 buflen = p - buffer;
8967 result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
8968 p = mono_array_addr (result, char, 0);
8969 memcpy (p, buffer, buflen);
8970 g_free (buffer);
8971 if (strcmp (ctor->vtable->klass->name, "MonoCMethod"))
8972 g_free (sig);
8973 return result;
8974 }
8975
8976 /*
8977 * mono_reflection_setup_internal_class:
8978 * @tb: a TypeBuilder object
8979 *
8980 * Creates a MonoClass that represents the TypeBuilder.
8981 * This is a trick that lets us simplify a lot of reflection code
8982 * (and will allow us to support Build and Run assemblies easier).
8983 */
8984 void
8985 mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb)
8986 {
8987 MonoClass *klass, *parent;
8988
8989 MONO_ARCH_SAVE_REGS;
8990
8991 CHECK_MONOTYPE (tb->parent);
8992
8993 mono_loader_lock ();
8994
8995 if (tb->parent) {
8996 /* check so we can compile corlib correctly */
8997 if (strcmp (mono_object_class (tb->parent)->name, "TypeBuilder") == 0) {
8998 /* mono_class_setup_mono_type () guaranteess type->data.klass is valid */
8999 parent = monotype_cast (tb->parent)->type->data.klass;
9000 } else {
9001 parent = mono_class_from_mono_type (monotype_cast (tb->parent)->type);
9002 }
9003 } else {
9004 parent = NULL;
9005 }
9006
9007 /* the type has already being created: it means we just have to change the parent */
9008 if (tb->type.type) {
9009 klass = mono_class_from_mono_type (tb->type.type);
9010 klass->parent = NULL;
9011 /* fool mono_class_setup_parent */
9012 klass->supertypes = NULL;
9013 mono_class_setup_parent (klass, parent);
9014 mono_class_setup_mono_type (klass);
9015 mono_loader_unlock ();
9016 return;
9017 }
9018
9019 klass = mono_image_alloc0 (&tb->module->dynamic_image->image, sizeof (MonoClass));
9020
9021 klass->image = &tb->module->dynamic_image->image;
9022
9023 klass->inited = 1; /* we lie to the runtime */
9024 klass->name = mono_string_to_utf8_image (klass->image, tb->name);
9025 klass->name_space = mono_string_to_utf8_image (klass->image, tb->nspace);
9026 klass->type_token = MONO_TOKEN_TYPE_DEF | tb->table_idx;
9027 klass->flags = tb->attrs;
9028
9029 mono_profiler_class_event (klass, MONO_PROFILE_START_LOAD);
9030
9031 klass->element_class = klass;
9032
9033 MOVING_GC_REGISTER (&klass->reflection_info);
9034 klass->reflection_info = tb;
9035
9036 /* Put into cache so mono_class_get () will find it */
9037 mono_image_add_to_name_cache (klass->image, klass->name_space, klass->name, tb->table_idx);
9038
9039 mono_g_hash_table_insert (tb->module->dynamic_image->tokens,
9040 GUINT_TO_POINTER (MONO_TOKEN_TYPE_DEF | tb->table_idx), tb);
9041
9042 if (parent != NULL) {
9043 mono_class_setup_parent (klass, parent);
9044 } else if (strcmp (klass->name, "Object") == 0 && strcmp (klass->name_space, "System") == 0) {
9045 const char *old_n = klass->name;
9046 /* trick to get relative numbering right when compiling corlib */
9047 klass->name = "BuildingObject";
9048 mono_class_setup_parent (klass, mono_defaults.object_class);
9049 klass->name = old_n;
9050 }
9051
9052 if ((!strcmp (klass->name, "ValueType") && !strcmp (klass->name_space, "System")) ||
9053 (!strcmp (klass->name, "Object") && !strcmp (klass->name_space, "System")) ||
9054 (!strcmp (klass->name, "Enum") && !strcmp (klass->name_space, "System"))) {
9055 klass->instance_size = sizeof (MonoObject);
9056 klass->size_inited = 1;
9057 mono_class_setup_vtable_general (klass, NULL, 0);
9058 }
9059
9060 mono_class_setup_mono_type (klass);
9061
9062 mono_class_setup_supertypes (klass);
9063
9064 /*
9065 * FIXME: handle interfaces.
9066 */
9067
9068 tb->type.type = &klass->byval_arg;
9069
9070 if (tb->nesting_type) {
9071 g_assert (tb->nesting_type->type);
9072 klass->nested_in = mono_class_from_mono_type (tb->nesting_type->type);
9073 }
9074
9075 /*g_print ("setup %s as %s (%p)\n", klass->name, ((MonoObject*)tb)->vtable->klass->name, tb);*/
9076
9077 mono_profiler_class_loaded (klass, MONO_PROFILE_OK);
9078
9079 mono_loader_unlock ();
9080 }
9081
9082 /*
9083 * mono_reflection_setup_generic_class:
9084 * @tb: a TypeBuilder object
9085 *
9086 * Setup the generic class before adding the first generic parameter.
9087 */
9088 void
9089 mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb)
9090 {
9091 }
9092
9093 /*
9094 * mono_reflection_create_generic_class:
9095 * @tb: a TypeBuilder object
9096 *
9097 * Creates the generic class after all generic parameters have been added.
9098 */
9099 void
9100 mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb)
9101 {
9102 MonoClass *klass;
9103 int count, i;
9104
9105 MONO_ARCH_SAVE_REGS;
9106
9107 klass = mono_class_from_mono_type (tb->type.type);
9108
9109 count = tb->generic_params ? mono_array_length (tb->generic_params) : 0;
9110
9111 if (klass->generic_container || (count == 0))
9112 return;
9113
9114 g_assert (tb->generic_container && (tb->generic_container->owner.klass == klass));
9115
9116 klass->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
9117
9118 klass->generic_container->owner.klass = klass;
9119 klass->generic_container->type_argc = count;
9120 klass->generic_container->type_params = mono_image_alloc0 (klass->image, sizeof (MonoGenericParamFull) * count);
9121
9122 klass->is_generic = 1;
9123
9124 for (i = 0; i < count; i++) {
9125 MonoReflectionGenericParam *gparam = mono_array_get (tb->generic_params, gpointer, i);
9126 MonoGenericParamFull *param = (MonoGenericParamFull *) gparam->type.type->data.generic_param;
9127 klass->generic_container->type_params [i] = *param;
9128 /*Make sure we are a diferent type instance */
9129 klass->generic_container->type_params [i].param.owner = klass->generic_container;
9130 klass->generic_container->type_params [i].info.pklass = NULL;
9131
9132 g_assert (klass->generic_container->type_params [i].param.owner);
9133 }
9134
9135 klass->generic_container->context.class_inst = mono_get_shared_generic_inst (klass->generic_container);
9136 }
9137
9138 /*
9139 * mono_reflection_create_internal_class:
9140 * @tb: a TypeBuilder object
9141 *
9142 * Actually create the MonoClass that is associated with the TypeBuilder.
9143 */
9144 void
9145 mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb)
9146 {
9147 MonoClass *klass;
9148
9149 MONO_ARCH_SAVE_REGS;
9150
9151 klass = mono_class_from_mono_type (tb->type.type);
9152
9153 mono_loader_lock ();
9154 if (klass->enumtype && mono_class_enum_basetype (klass) == NULL) {
9155 MonoReflectionFieldBuilder *fb;
9156 MonoClass *ec;
9157 MonoType *enum_basetype;
9158
9159 g_assert (tb->fields != NULL);
9160 g_assert (mono_array_length (tb->fields) >= 1);
9161
9162 fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, 0);
9163
9164 if (!mono_type_is_valid_enum_basetype (monotype_cast (fb->type)->type)) {
9165 mono_loader_unlock ();
9166 return;
9167 }
9168
9169 enum_basetype = monotype_cast (fb->type)->type;
9170 klass->element_class = mono_class_from_mono_type (enum_basetype);
9171 if (!klass->element_class)
9172 klass->element_class = mono_class_from_mono_type (enum_basetype);
9173
9174 /*
9175 * get the element_class from the current corlib.
9176 */
9177 ec = default_class_from_mono_type (enum_basetype);
9178 klass->instance_size = ec->instance_size;
9179 klass->size_inited = 1;
9180 /*
9181 * this is almost safe to do with enums and it's needed to be able
9182 * to create objects of the enum type (for use in SetConstant).
9183 */
9184 /* FIXME: Does this mean enums can't have method overrides ? */
9185 mono_class_setup_vtable_general (klass, NULL, 0);
9186 }
9187 mono_loader_unlock ();
9188 }
9189
9190 static MonoMarshalSpec*
9191 mono_marshal_spec_from_builder (MonoImage *image, MonoAssembly *assembly,
9192 MonoReflectionMarshal *minfo)
9193 {
9194 MonoMarshalSpec *res;
9195
9196 res = image_g_new0 (image, MonoMarshalSpec, 1);
9197 res->native = minfo->type;
9198
9199 switch (minfo->type) {
9200 case MONO_NATIVE_LPARRAY:
9201 res->data.array_data.elem_type = minfo->eltype;
9202 if (minfo->has_size) {
9203 res->data.array_data.param_num = minfo->param_num;
9204 res->data.array_data.num_elem = minfo->count;
9205 res->data.array_data.elem_mult = minfo->param_num == -1 ? 0 : 1;
9206 }
9207 else {
9208 res->data.array_data.param_num = -1;
9209 res->data.array_data.num_elem = -1;
9210 res->data.array_data.elem_mult = -1;
9211 }
9212 break;
9213
9214 case MONO_NATIVE_BYVALTSTR:
9215 case MONO_NATIVE_BYVALARRAY:
9216 res->data.array_data.num_elem = minfo->count;
9217 break;
9218
9219 case MONO_NATIVE_CUSTOM:
9220 if (minfo->marshaltyperef)
9221 res->data.custom_data.custom_name =
9222 type_get_fully_qualified_name (monotype_cast (minfo->marshaltyperef)->type);
9223 if (minfo->mcookie)
9224 res->data.custom_data.cookie = mono_string_to_utf8 (minfo->mcookie);
9225 break;
9226
9227 default:
9228 break;
9229 }
9230
9231 return res;
9232 }
9233 #endif /* !DISABLE_REFLECTION_EMIT */
9234
9235 MonoReflectionMarshal*
9236 mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
9237 MonoMarshalSpec *spec)
9238 {
9239 static MonoClass *System_Reflection_Emit_UnmanagedMarshalClass;
9240 MonoReflectionMarshal *minfo;
9241 MonoType *mtype;
9242
9243 if (!System_Reflection_Emit_UnmanagedMarshalClass) {
9244 System_Reflection_Emit_UnmanagedMarshalClass = mono_class_from_name (
9245 mono_defaults.corlib, "System.Reflection.Emit", "UnmanagedMarshal");
9246 g_assert (System_Reflection_Emit_UnmanagedMarshalClass);
9247 }
9248
9249 minfo = (MonoReflectionMarshal*)mono_object_new (domain, System_Reflection_Emit_UnmanagedMarshalClass);
9250 minfo->type = spec->native;
9251
9252 switch (minfo->type) {
9253 case MONO_NATIVE_LPARRAY:
9254 minfo->eltype = spec->data.array_data.elem_type;
9255 minfo->count = spec->data.array_data.num_elem;
9256 minfo->param_num = spec->data.array_data.param_num;
9257 break;
9258
9259 case MONO_NATIVE_BYVALTSTR:
9260 case MONO_NATIVE_BYVALARRAY:
9261 minfo->count = spec->data.array_data.num_elem;
9262 break;
9263
9264 case MONO_NATIVE_CUSTOM:
9265 if (spec->data.custom_data.custom_name) {
9266 mtype = mono_reflection_type_from_name (spec->data.custom_data.custom_name, klass->image);
9267 if (mtype)
9268 MONO_OBJECT_SETREF (minfo, marshaltyperef, mono_type_get_object (domain, mtype));
9269
9270 MONO_OBJECT_SETREF (minfo, marshaltype, mono_string_new (domain, spec->data.custom_data.custom_name));
9271 }
9272 if (spec->data.custom_data.cookie)
9273 MONO_OBJECT_SETREF (minfo, mcookie, mono_string_new (domain, spec->data.custom_data.cookie));
9274 break;
9275
9276 default:
9277 break;
9278 }
9279
9280 return minfo;
9281 }
9282
9283 #ifndef DISABLE_REFLECTION_EMIT
9284 static MonoMethod*
9285 reflection_methodbuilder_to_mono_method (MonoClass *klass,
9286 ReflectionMethodBuilder *rmb,
9287 MonoMethodSignature *sig)
9288 {
9289 MonoMethod *m;
9290 MonoMethodNormal *pm;
9291 MonoMarshalSpec **specs;
9292 MonoReflectionMethodAux *method_aux;
9293 MonoImage *image;
9294 gboolean dynamic;
9295 int i;
9296
9297 /*
9298 * Methods created using a MethodBuilder should have their memory allocated
9299 * inside the image mempool, while dynamic methods should have their memory
9300 * malloc'd.
9301 */
9302 dynamic = rmb->refs != NULL;
9303 image = dynamic ? NULL : klass->image;
9304
9305 if (!dynamic)
9306 g_assert (!klass->generic_class);
9307
9308 mono_loader_lock ();
9309
9310 if ((rmb->attrs & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
9311 (rmb->iattrs & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
9312 m = (MonoMethod *)image_g_new0 (image, MonoMethodPInvoke, 1);
9313 else if (rmb->refs)
9314 m = (MonoMethod *)image_g_new0 (image, MonoMethodWrapper, 1);
9315 else
9316 m = (MonoMethod *)image_g_new0 (image, MonoMethodNormal, 1);
9317
9318 pm = (MonoMethodNormal*)m;
9319
9320 m->dynamic = dynamic;
9321 m->slot = -1;
9322 m->flags = rmb->attrs;
9323 m->iflags = rmb->iattrs;
9324 m->name = mono_string_to_utf8_image (image, rmb->name);
9325 m->klass = klass;
9326 m->signature = sig;
9327 m->skip_visibility = rmb->skip_visibility;
9328 if (rmb->table_idx)
9329 m->token = MONO_TOKEN_METHOD_DEF | (*rmb->table_idx);
9330
9331 if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
9332 if (klass == mono_defaults.string_class && !strcmp (m->name, ".ctor"))
9333 m->string_ctor = 1;
9334
9335 m->signature->pinvoke = 1;
9336 } else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
9337 m->signature->pinvoke = 1;
9338
9339 method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
9340
9341 method_aux->dllentry = rmb->dllentry ? mono_string_to_utf8_image (image, rmb->dllentry) : image_strdup (image, m->name);
9342 method_aux->dll = mono_string_to_utf8_image (image, rmb->dll);
9343
9344 ((MonoMethodPInvoke*)m)->piflags = (rmb->native_cc << 8) | (rmb->charset ? (rmb->charset - 1) * 2 : 0) | rmb->extra_flags;
9345
9346 if (klass->image->dynamic)
9347 g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
9348
9349 mono_loader_unlock ();
9350
9351 return m;
9352 } else if (!(m->flags & METHOD_ATTRIBUTE_ABSTRACT) &&
9353 !(m->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
9354 MonoMethodHeader *header;
9355 guint32 code_size;
9356 gint32 max_stack, i;
9357 gint32 num_locals = 0;
9358 gint32 num_clauses = 0;
9359 guint8 *code;
9360
9361 if (rmb->ilgen) {
9362 code = mono_array_addr (rmb->ilgen->code, guint8, 0);
9363 code_size = rmb->ilgen->code_len;
9364 max_stack = rmb->ilgen->max_stack;
9365 num_locals = rmb->ilgen->locals ? mono_array_length (rmb->ilgen->locals) : 0;
9366 if (rmb->ilgen->ex_handlers)
9367 num_clauses = method_count_clauses (rmb->ilgen);
9368 } else {
9369 if (rmb->code) {
9370 code = mono_array_addr (rmb->code, guint8, 0);
9371 code_size = mono_array_length (rmb->code);
9372 /* we probably need to run a verifier on the code... */
9373 max_stack = 8;
9374 }
9375 else {
9376 code = NULL;
9377 code_size = 0;
9378 max_stack = 8;
9379 }
9380 }
9381
9382 header = image_g_malloc0 (image, sizeof (MonoMethodHeader) +
9383 (num_locals - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*));
9384 header->code_size = code_size;
9385 header->code = image_g_malloc (image, code_size);
9386 memcpy ((char*)header->code, code, code_size);
9387 header->max_stack = max_stack;
9388 header->init_locals = rmb->init_locals;
9389 header->num_locals = num_locals;
9390
9391 for (i = 0; i < num_locals; ++i) {
9392 MonoReflectionLocalBuilder *lb =
9393 mono_array_get (rmb->ilgen->locals, MonoReflectionLocalBuilder*, i);
9394
9395 header->locals [i] = image_g_new0 (image, MonoType, 1);
9396 memcpy (header->locals [i], monotype_cast (lb->type)->type, sizeof (MonoType));
9397 }
9398
9399 header->num_clauses = num_clauses;
9400 if (num_clauses) {
9401 header->clauses = method_encode_clauses (image, (MonoDynamicImage*)klass->image,
9402 rmb->ilgen, num_clauses);
9403 }
9404
9405 pm->header = header;
9406 }
9407
9408 if (rmb->generic_params) {
9409 int count = mono_array_length (rmb->generic_params);
9410 MonoGenericContainer *container;
9411
9412 container = rmb->generic_container;
9413 if (container) {
9414 m->is_generic = TRUE;
9415 mono_method_set_generic_container (m, container);
9416 }
9417 container->type_argc = count;
9418 container->type_params = image_g_new0 (image, MonoGenericParamFull, count);
9419 container->owner.method = m;
9420
9421 for (i = 0; i < count; i++) {
9422 MonoReflectionGenericParam *gp =
9423 mono_array_get (rmb->generic_params, MonoReflectionGenericParam*, i);
9424 MonoGenericParamFull *param = (MonoGenericParamFull *) gp->type.type->data.generic_param;
9425 container->type_params [i] = *param;
9426 }
9427
9428 if (klass->generic_container) {
9429 container->parent = klass->generic_container;
9430 container->context.class_inst = klass->generic_container->context.class_inst;
9431 }
9432 container->context.method_inst = mono_get_shared_generic_inst (container);
9433 }
9434
9435 if (rmb->refs) {
9436 MonoMethodWrapper *mw = (MonoMethodWrapper*)m;
9437 int i;
9438 void **data;
9439
9440 m->wrapper_type = MONO_WRAPPER_DYNAMIC_METHOD;
9441
9442 mw->method_data = data = image_g_new (image, gpointer, rmb->nrefs + 1);
9443 data [0] = GUINT_TO_POINTER (rmb->nrefs);
9444 for (i = 0; i < rmb->nrefs; ++i)
9445 data [i + 1] = rmb->refs [i];
9446 }
9447
9448 method_aux = NULL;
9449
9450 /* Parameter info */
9451 if (rmb->pinfo) {
9452 if (!method_aux)
9453 method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
9454 method_aux->param_names = image_g_new0 (image, char *, mono_method_signature (m)->param_count + 1);
9455 for (i = 0; i <= m->signature->param_count; ++i) {
9456 MonoReflectionParamBuilder *pb;
9457 if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) {
9458 if ((i > 0) && (pb->attrs)) {
9459 /* Make a copy since it might point to a shared type structure */
9460 m->signature->params [i - 1] = mono_metadata_type_dup (klass->image, m->signature->params [i - 1]);
9461 m->signature->params [i - 1]->attrs = pb->attrs;
9462 }
9463
9464 if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
9465 MonoDynamicImage *assembly;
9466 guint32 idx, def_type, len;
9467 char *p;
9468 const char *p2;
9469
9470 if (!method_aux->param_defaults) {
9471 method_aux->param_defaults = image_g_new0 (image, guint8*, m->signature->param_count + 1);
9472 method_aux->param_default_types = image_g_new0 (image, guint32, m->signature->param_count + 1);
9473 }
9474 assembly = (MonoDynamicImage*)klass->image;
9475 idx = encode_constant (assembly, pb->def_value, &def_type);
9476 /* Copy the data from the blob since it might get realloc-ed */
9477 p = assembly->blob.data + idx;
9478 len = mono_metadata_decode_blob_size (p, &p2);
9479 len += p2 - p;
9480 method_aux->param_defaults [i] = image_g_malloc (image, len);
9481 method_aux->param_default_types [i] = def_type;
9482 memcpy ((gpointer)method_aux->param_defaults [i], p, len);
9483 }
9484
9485 if (pb->name)
9486 method_aux->param_names [i] = mono_string_to_utf8_image (image, pb->name);
9487 if (pb->cattrs) {
9488 if (!method_aux->param_cattr)
9489 method_aux->param_cattr = image_g_new0 (image, MonoCustomAttrInfo*, m->signature->param_count + 1);
9490 method_aux->param_cattr [i] = mono_custom_attrs_from_builders (image, klass->image, pb->cattrs);
9491 }
9492 }
9493 }
9494 }
9495
9496 /* Parameter marshalling */
9497 specs = NULL;
9498 if (rmb->pinfo)
9499 for (i = 0; i < mono_array_length (rmb->pinfo); ++i) {
9500 MonoReflectionParamBuilder *pb;
9501 if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) {
9502 if (pb->marshal_info) {
9503 if (specs == NULL)
9504 specs = image_g_new0 (image, MonoMarshalSpec*, sig->param_count + 1);
9505 specs [pb->position] =
9506 mono_marshal_spec_from_builder (image, klass->image->assembly, pb->marshal_info);
9507 }
9508 }
9509 }
9510 if (specs != NULL) {
9511 if (!method_aux)
9512 method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
9513 method_aux->param_marshall = specs;
9514 }
9515
9516 if (klass->image->dynamic && method_aux)
9517 g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
9518
9519 mono_loader_unlock ();
9520
9521 return m;
9522 }
9523
9524 static MonoMethod*
9525 ctorbuilder_to_mono_method (MonoClass *klass, MonoReflectionCtorBuilder* mb)
9526 {
9527 ReflectionMethodBuilder rmb;
9528 MonoMethodSignature *sig;
9529
9530 mono_loader_lock ();
9531 sig = ctor_builder_to_signature (klass->image, mb);
9532 mono_loader_unlock ();
9533
9534 reflection_methodbuilder_from_ctor_builder (&rmb, mb);
9535
9536 mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
9537 mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
9538
9539 /* If we are in a generic class, we might be called multiple times from inflate_method */
9540 if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save && !klass->generic_container) {
9541 /* ilgen is no longer needed */
9542 mb->ilgen = NULL;
9543 }
9544
9545 return mb->mhandle;
9546 }
9547
9548 static MonoMethod*
9549 methodbuilder_to_mono_method (MonoClass *klass, MonoReflectionMethodBuilder* mb)
9550 {
9551 ReflectionMethodBuilder rmb;
9552 MonoMethodSignature *sig;
9553
9554 mono_loader_lock ();
9555 sig = method_builder_to_signature (klass->image, mb);
9556 mono_loader_unlock ();
9557
9558 reflection_methodbuilder_from_method_builder (&rmb, mb);
9559
9560 mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
9561 mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
9562
9563 /* If we are in a generic class, we might be called multiple times from inflate_method */
9564 if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save && !klass->generic_container) {
9565 /* ilgen is no longer needed */
9566 mb->ilgen = NULL;
9567 }
9568 return mb->mhandle;
9569 }
9570
9571 static MonoClassField*
9572 fieldbuilder_to_mono_class_field (MonoClass *klass, MonoReflectionFieldBuilder* fb)
9573 {
9574 MonoClassField *field;
9575 MonoType *custom;
9576
9577 field = g_new0 (MonoClassField, 1);
9578
9579 field->name = mono_string_to_utf8 (fb->name);
9580 if (fb->attrs || fb->modreq || fb->modopt) {
9581 field->type = mono_metadata_type_dup (NULL, monotype_cast (fb->type)->type);
9582 field->type->attrs = fb->attrs;
9583
9584 g_assert (klass->image->dynamic);
9585 custom = add_custom_modifiers ((MonoDynamicImage*)klass->image, field->type, fb->modreq, fb->modopt);
9586 g_free (field->type);
9587 field->type = custom;
9588 } else {
9589 field->type = monotype_cast (fb->type)->type;
9590 }
9591 if (fb->offset != -1)
9592 field->offset = fb->offset;
9593 field->parent = klass;
9594 mono_save_custom_attrs (klass->image, field, fb->cattrs);
9595
9596 // FIXME: Can't store fb->def_value/RVA, is it needed for field_on_insts ?
9597
9598 return field;
9599 }
9600 #endif
9601
9602 MonoType*
9603 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types)
9604 {
9605 MonoClass *klass;
9606 MonoReflectionTypeBuilder *tb = NULL;
9607 gboolean is_dynamic = FALSE;
9608 MonoDomain *domain;
9609 MonoClass *geninst;
9610
9611 mono_loader_lock ();
9612
9613 domain = mono_object_domain (type);
9614
9615 if (!strcmp (((MonoObject *) type)->vtable->klass->name, "TypeBuilder")) {
9616 tb = (MonoReflectionTypeBuilder *) type;
9617
9618 is_dynamic = TRUE;
9619 } else if (!strcmp (((MonoObject *) type)->vtable->klass->name, "MonoGenericClass")) {
9620 MonoReflectionGenericClass *rgi = (MonoReflectionGenericClass *) type;
9621
9622 tb = rgi->generic_type;
9623 is_dynamic = TRUE;
9624 }
9625
9626 /* FIXME: fix the CreateGenericParameters protocol to avoid the two stage setup of TypeBuilders */
9627 if (tb && tb->generic_container)
9628 mono_reflection_create_generic_class (tb);
9629
9630 klass = mono_class_from_mono_type (type->type);
9631 if (!klass->generic_container) {
9632 mono_loader_unlock ();
9633 return NULL;
9634 }
9635
9636 if (klass->wastypebuilder) {
9637 tb = (MonoReflectionTypeBuilder *) klass->reflection_info;
9638
9639 is_dynamic = TRUE;
9640 }
9641
9642 mono_loader_unlock ();
9643
9644 geninst = mono_class_bind_generic_parameters (klass, type_argc, types, is_dynamic);
9645
9646 return &geninst->byval_arg;
9647 }
9648
9649 MonoClass*
9650 mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic)
9651 {
9652 MonoGenericClass *gclass;
9653 MonoGenericInst *inst;
9654
9655 g_assert (klass->generic_container);
9656
9657 inst = mono_metadata_get_generic_inst (type_argc, types);
9658 gclass = mono_metadata_lookup_generic_class (klass, inst, is_dynamic);
9659
9660 return mono_generic_class_get_class (gclass);
9661 }
9662
9663 MonoReflectionMethod*
9664 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types)
9665 {
9666 MonoClass *klass;
9667 MonoMethod *method, *inflated;
9668 MonoMethodInflated *imethod;
9669 MonoGenericContext tmp_context;
9670 MonoGenericInst *ginst;
9671 MonoType **type_argv;
9672 int count, i;
9673
9674 MONO_ARCH_SAVE_REGS;
9675
9676 if (!strcmp (rmethod->object.vtable->klass->name, "MethodBuilder")) {
9677 #ifndef DISABLE_REFLECTION_EMIT
9678 MonoReflectionMethodBuilder *mb = NULL;
9679 MonoReflectionTypeBuilder *tb;
9680 MonoClass *klass;
9681
9682 mb = (MonoReflectionMethodBuilder *) rmethod;
9683 tb = (MonoReflectionTypeBuilder *) mb->type;
9684 klass = mono_class_from_mono_type (tb->type.type);
9685
9686 method = methodbuilder_to_mono_method (klass, mb);
9687 #else
9688 g_assert_not_reached ();
9689 method = NULL;
9690 #endif
9691 } else {
9692 method = rmethod->method;
9693 }
9694
9695 klass = method->klass;
9696
9697 if (method->is_inflated)
9698 method = ((MonoMethodInflated *) method)->declaring;
9699
9700 count = mono_method_signature (method)->generic_param_count;
9701 if (count != mono_array_length (types))
9702 return NULL;
9703
9704 type_argv = g_new0 (MonoType *, count);
9705 for (i = 0; i < count; i++) {
9706 MonoReflectionType *garg = mono_array_get (types, gpointer, i);
9707 type_argv [i] = garg->type;
9708 }
9709 ginst = mono_metadata_get_generic_inst (count, type_argv);
9710 g_free (type_argv);
9711
9712 tmp_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL;
9713 tmp_context.method_inst = ginst;
9714
9715 inflated = mono_class_inflate_generic_method (method, &tmp_context);
9716 imethod = (MonoMethodInflated *) inflated;
9717
9718 if (method->klass->image->dynamic) {
9719 MonoDynamicImage *image = (MonoDynamicImage*)method->klass->image;
9720 /*
9721 * This table maps metadata structures representing inflated methods/fields
9722 * to the reflection objects representing their generic definitions.
9723 */
9724 mono_loader_lock ();
9725 mono_g_hash_table_insert (image->generic_def_objects, imethod, rmethod);
9726 mono_loader_unlock ();
9727 }
9728
9729 return mono_method_get_object (mono_object_domain (rmethod), inflated, NULL);
9730 }
9731
9732 #ifndef DISABLE_REFLECTION_EMIT
9733
9734 static MonoMethod *
9735 inflate_mono_method (MonoClass *klass, MonoMethod *method, MonoObject *obj)
9736 {
9737 MonoMethodInflated *imethod;
9738 MonoGenericContext *context;
9739 int i;
9740
9741 /*
9742 * With generic code sharing the klass might not be inflated.
9743 * This can happen because classes inflated with their own
9744 * type arguments are "normalized" to the uninflated class.
9745 */
9746 if (!klass->generic_class)
9747 return method;
9748
9749 context = mono_class_get_context (klass);
9750
9751 if (klass->method.count) {
9752 /* Find the already created inflated method */
9753 for (i = 0; i < klass->method.count; ++i) {
9754 g_assert (klass->methods [i]->is_inflated);
9755 if (((MonoMethodInflated*)klass->methods [i])->declaring == method)
9756 break;
9757 }
9758 g_assert (i < klass->method.count);
9759 imethod = (MonoMethodInflated*)klass->methods [i];
9760 } else {
9761 imethod = (MonoMethodInflated *) mono_class_inflate_generic_method_full (method, klass, context);
9762 }
9763
9764 if (method->is_generic && method->klass->image->dynamic) {
9765 MonoDynamicImage *image = (MonoDynamicImage*)method->klass->image;
9766
9767 mono_loader_lock ();
9768 mono_g_hash_table_insert (image->generic_def_objects, imethod, obj);
9769 mono_loader_unlock ();
9770 }
9771 return (MonoMethod *) imethod;
9772 }
9773
9774 static MonoMethod *
9775 inflate_method (MonoReflectionGenericClass *type, MonoObject *obj)
9776 {
9777 MonoMethod *method;
9778 MonoClass *gklass;
9779
9780 gklass = mono_class_from_mono_type (type->generic_type->type.type);
9781
9782 if (!strcmp (obj->vtable->klass->name, "MethodBuilder"))
9783 if (((MonoReflectionMethodBuilder*)obj)->mhandle)
9784 method = ((MonoReflectionMethodBuilder*)obj)->mhandle;
9785 else
9786 method = methodbuilder_to_mono_method (gklass, (MonoReflectionMethodBuilder *) obj);
9787 else if (!strcmp (obj->vtable->klass->name, "ConstructorBuilder"))
9788 method = ctorbuilder_to_mono_method (gklass, (MonoReflectionCtorBuilder *) obj);
9789 else if (!strcmp (obj->vtable->klass->name, "MonoMethod") || !strcmp (obj->vtable->klass->name, "MonoCMethod"))
9790 method = ((MonoReflectionMethod *) obj)->method;
9791 else {
9792 method = NULL; /* prevent compiler warning */
9793 g_assert_not_reached ();
9794 }
9795
9796 return inflate_mono_method (mono_class_from_mono_type (type->type.type), method, obj);
9797 }
9798
9799 /*TODO avoid saving custom attrs for generic classes as it's enough to have them on the generic type definition.*/
9800 void
9801 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods,
9802 MonoArray *ctors, MonoArray *fields, MonoArray *properties,
9803 MonoArray *events)
9804 {
9805 MonoGenericClass *gclass;
9806 MonoDynamicGenericClass *dgclass;
9807 MonoClass *klass, *gklass;
9808 int i;
9809
9810 MONO_ARCH_SAVE_REGS;
9811
9812 klass = mono_class_from_mono_type (type->type.type);
9813 g_assert (type->type.type->type == MONO_TYPE_GENERICINST);
9814 gclass = type->type.type->data.generic_class;
9815
9816 g_assert (gclass->is_dynamic);
9817 dgclass = (MonoDynamicGenericClass *) gclass;
9818
9819 if (dgclass->initialized)
9820 return;
9821
9822 gklass = gclass->container_class;
9823 mono_class_init (gklass);
9824
9825 dgclass->count_methods = methods ? mono_array_length (methods) : 0;
9826 dgclass->count_ctors = ctors ? mono_array_length (ctors) : 0;
9827 dgclass->count_fields = fields ? mono_array_length (fields) : 0;
9828 dgclass->count_properties = properties ? mono_array_length (properties) : 0;
9829 dgclass->count_events = events ? mono_array_length (events) : 0;
9830
9831 dgclass->methods = g_new0 (MonoMethod *, dgclass->count_methods);
9832 dgclass->ctors = g_new0 (MonoMethod *, dgclass->count_ctors);
9833 dgclass->fields = g_new0 (MonoClassField, dgclass->count_fields);
9834 dgclass->properties = g_new0 (MonoProperty, dgclass->count_properties);
9835 dgclass->events = g_new0 (MonoEvent, dgclass->count_events);
9836 dgclass->field_objects = g_new0 (MonoObject*, dgclass->count_fields);
9837 dgclass->field_generic_types = g_new0 (MonoType*, dgclass->count_fields);
9838
9839 for (i = 0; i < dgclass->count_methods; i++) {
9840 MonoObject *obj = mono_array_get (methods, gpointer, i);
9841
9842 dgclass->methods [i] = inflate_method (type, obj);
9843 }
9844
9845 for (i = 0; i < dgclass->count_ctors; i++) {
9846 MonoObject *obj = mono_array_get (ctors, gpointer, i);
9847
9848 dgclass->ctors [i] = inflate_method (type, obj);
9849 }
9850
9851 for (i = 0; i < dgclass->count_fields; i++) {
9852 MonoObject *obj = mono_array_get (fields, gpointer, i);
9853 MonoClassField *field, *inflated_field = NULL;
9854
9855 if (!strcmp (obj->vtable->klass->name, "FieldBuilder"))
9856 inflated_field = field = fieldbuilder_to_mono_class_field (klass, (MonoReflectionFieldBuilder *) obj);
9857 else if (!strcmp (obj->vtable->klass->name, "MonoField"))
9858 field = ((MonoReflectionField *) obj)->field;
9859 else {
9860 field = NULL; /* prevent compiler warning */
9861 g_assert_not_reached ();
9862 }
9863
9864 dgclass->fields [i] = *field;
9865 dgclass->fields [i].parent = klass;
9866 dgclass->fields [i].type = mono_class_inflate_generic_type (
9867 field->type, mono_generic_class_get_context ((MonoGenericClass *) dgclass));
9868 dgclass->field_generic_types [i] = field->type;
9869 MOVING_GC_REGISTER (&dgclass->field_objects [i]);
9870 dgclass->field_objects [i] = obj;
9871
9872 if (inflated_field) {
9873 g_free (inflated_field);
9874 } else {
9875 dgclass->fields [i].name = g_strdup (dgclass->fields [i].name);
9876 }
9877 }
9878
9879 for (i = 0; i < dgclass->count_properties; i++) {
9880 MonoObject *obj = mono_array_get (properties, gpointer, i);
9881 MonoProperty *property = &dgclass->properties [i];
9882
9883 if (!strcmp (obj->vtable->klass->name, "PropertyBuilder")) {
9884 MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *) obj;
9885
9886 property->parent = klass;
9887 property->attrs = pb->attrs;
9888 property->name = mono_string_to_utf8 (pb->name);
9889 if (pb->get_method)
9890 property->get = inflate_method (type, (MonoObject *) pb->get_method);
9891 if (pb->set_method)
9892 property->set = inflate_method (type, (MonoObject *) pb->set_method);
9893 } else if (!strcmp (obj->vtable->klass->name, "MonoProperty")) {
9894 *property = *((MonoReflectionProperty *) obj)->property;
9895 property->name = g_strdup (property->name);
9896
9897 if (property->get)
9898 property->get = inflate_mono_method (klass, property->get, NULL);
9899 if (property->set)
9900 property->set = inflate_mono_method (klass, property->set, NULL);
9901 } else
9902 g_assert_not_reached ();
9903 }
9904
9905 for (i = 0; i < dgclass->count_events; i++) {
9906 MonoObject *obj = mono_array_get (events, gpointer, i);
9907 MonoEvent *event = &dgclass->events [i];
9908
9909 if (!strcmp (obj->vtable->klass->name, "EventBuilder")) {
9910 MonoReflectionEventBuilder *eb = (MonoReflectionEventBuilder *) obj;
9911
9912 event->parent = klass;
9913 event->attrs = eb->attrs;
9914 event->name = mono_string_to_utf8 (eb->name);
9915 if (eb->add_method)
9916 event->add = inflate_method (type, (MonoObject *) eb->add_method);
9917 if (eb->remove_method)
9918 event->remove = inflate_method (type, (MonoObject *) eb->remove_method);
9919 } else if (!strcmp (obj->vtable->klass->name, "MonoEvent")) {
9920 *event = *((MonoReflectionMonoEvent *) obj)->event;
9921 event->name = g_strdup (event->name);
9922
9923 if (event->add)
9924 event->add = inflate_mono_method (klass, event->add, NULL);
9925 if (event->remove)
9926 event->remove = inflate_mono_method (klass, event->remove, NULL);
9927 } else
9928 g_assert_not_reached ();
9929 }
9930
9931 dgclass->initialized = TRUE;
9932 }
9933
9934 static void
9935 ensure_generic_class_runtime_vtable (MonoClass *klass)
9936 {
9937 MonoClass *gklass = klass->generic_class->container_class;
9938 int i;
9939
9940 if (klass->wastypebuilder)
9941 return;
9942
9943 ensure_runtime_vtable (gklass);
9944
9945 klass->method.count = gklass->method.count;
9946 klass->methods = mono_image_alloc (klass->image, sizeof (MonoMethod*) * (klass->method.count + 1));
9947
9948 for (i = 0; i < klass->method.count; i++) {
9949 klass->methods [i] = mono_class_inflate_generic_method_full (
9950 gklass->methods [i], klass, mono_class_get_context (klass));
9951 }
9952
9953 klass->interface_count = gklass->interface_count;
9954 klass->interfaces = mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
9955 for (i = 0; i < klass->interface_count; ++i) {
9956 MonoType *iface_type = mono_class_inflate_generic_type (&gklass->interfaces [i]->byval_arg, mono_class_get_context (klass));
9957 klass->interfaces [i] = mono_class_from_mono_type (iface_type);
9958 mono_metadata_free_type (iface_type);
9959
9960 ensure_runtime_vtable (klass->interfaces [i]);
9961 }
9962 klass->interfaces_inited = 1;
9963
9964 /*We can only finish with this klass once it's parent has as well*/
9965 if (gklass->wastypebuilder)
9966 klass->wastypebuilder = TRUE;
9967 return;
9968 }
9969
9970 static void
9971 ensure_runtime_vtable (MonoClass *klass)
9972 {
9973 MonoReflectionTypeBuilder *tb = klass->reflection_info;
9974 int i, num, j;
9975
9976 if (!klass->image->dynamic || (!tb && !klass->generic_class) || klass->wastypebuilder)
9977 return;
9978 if (klass->parent)
9979 ensure_runtime_vtable (klass->parent);
9980
9981 if (tb) {
9982 num = tb->ctors? mono_array_length (tb->ctors): 0;
9983 num += tb->num_methods;
9984 klass->method.count = num;
9985 klass->methods = mono_image_alloc (klass->image, sizeof (MonoMethod*) * num);
9986 num = tb->ctors? mono_array_length (tb->ctors): 0;
9987 for (i = 0; i < num; ++i)
9988 klass->methods [i] = ctorbuilder_to_mono_method (klass, mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i));
9989 num = tb->num_methods;
9990 j = i;
9991 for (i = 0; i < num; ++i)
9992 klass->methods [j++] = methodbuilder_to_mono_method (klass, mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i));
9993
9994 if (tb->interfaces) {
9995 klass->interface_count = mono_array_length (tb->interfaces);
9996 klass->interfaces = mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
9997 for (i = 0; i < klass->interface_count; ++i) {
9998 MonoReflectionType *iface = mono_type_array_get (tb->interfaces, i);
9999 klass->interfaces [i] = mono_class_from_mono_type (iface->type);
10000 ensure_runtime_vtable (klass->interfaces [i]);
10001 }
10002 klass->interfaces_inited = 1;
10003 }
10004 } else if (klass->generic_class){
10005 ensure_generic_class_runtime_vtable (klass);
10006 }
10007
10008 if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
10009 for (i = 0; i < klass->method.count; ++i)
10010 klass->methods [i]->slot = i;
10011
10012 mono_class_setup_interface_offsets (klass);
10013 mono_class_setup_interface_id (klass);
10014 }
10015
10016 /*
10017 * The generic vtable is needed even if image->run is not set since some
10018 * runtime code like ves_icall_Type_GetMethodsByName depends on
10019 * method->slot being defined.
10020 */
10021
10022 /*
10023 * tb->methods could not be freed since it is used for determining
10024 * overrides during dynamic vtable construction.
10025 */
10026 }
10027
10028 void
10029 mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides)
10030 {
10031 MonoReflectionTypeBuilder *tb;
10032 int i, onum;
10033
10034 *overrides = NULL;
10035 *num_overrides = 0;
10036
10037 g_assert (klass->image->dynamic);
10038
10039 if (!klass->reflection_info)
10040 return;
10041
10042 g_assert (strcmp (((MonoObject*)klass->reflection_info)->vtable->klass->name, "TypeBuilder") == 0);
10043
10044 tb = (MonoReflectionTypeBuilder*)klass->reflection_info;
10045
10046 onum = 0;
10047 if (tb->methods) {
10048 for (i = 0; i < tb->num_methods; ++i) {
10049 MonoReflectionMethodBuilder *mb =
10050 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
10051 if (mb->override_method)
10052 onum ++;
10053 }
10054 }
10055
10056 if (onum) {
10057 *overrides = g_new0 (MonoMethod*, onum * 2);
10058
10059 onum = 0;
10060 for (i = 0; i < tb->num_methods; ++i) {
10061 MonoReflectionMethodBuilder *mb =
10062 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
10063 if (mb->override_method) {
10064 (*overrides) [onum * 2] =
10065 mb->override_method->method;
10066 (*overrides) [onum * 2 + 1] =
10067 mb->mhandle;
10068
10069 /* FIXME: What if 'override_method' is a MethodBuilder ? */
10070 g_assert (mb->override_method->method);
10071 g_assert (mb->mhandle);
10072
10073 onum ++;
10074 }
10075 }
10076 }
10077
10078 *num_overrides = onum;
10079 }
10080
10081 static void
10082 typebuilder_setup_fields (MonoClass *klass)
10083 {
10084 MonoReflectionTypeBuilder *tb = klass->reflection_info;
10085 MonoReflectionFieldBuilder *fb;
10086 MonoClassField *field;
10087 MonoImage *image = klass->image;
10088 const char *p, *p2;
10089 int i;
10090 guint32 len, idx, real_size = 0;
10091
10092 klass->field.count = tb->num_fields;
10093 klass->field.first = 0;
10094
10095 if (tb->class_size) {
10096 g_assert ((tb->packing_size & 0xfffffff0) == 0);
10097 klass->packing_size = tb->packing_size;
10098 real_size = klass->instance_size + tb->class_size;
10099 }
10100
10101 if (!klass->field.count) {
10102 klass->instance_size = MAX (klass->instance_size, real_size);
10103 return;
10104 }
10105
10106 klass->fields = image_g_new0 (image, MonoClassField, klass->field.count);
10107 mono_class_alloc_ext (klass);
10108 klass->ext->field_def_values = image_g_new0 (image, MonoFieldDefaultValue, klass->field.count);
10109
10110 for (i = 0; i < klass->field.count; ++i) {
10111 fb = mono_array_get (tb->fields, gpointer, i);
10112 field = &klass->fields [i];
10113 field->name = mono_string_to_utf8_image (image, fb->name);
10114 if (fb->attrs) {
10115 field->type = mono_metadata_type_dup (klass->image, monotype_cast (fb->type)->type);
10116 field->type->attrs = fb->attrs;
10117 } else {
10118 field->type = monotype_cast (fb->type)->type;
10119 }
10120 if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && fb->rva_data)
10121 klass->ext->field_def_values [i].data = mono_array_addr (fb->rva_data, char, 0);
10122 if (fb->offset != -1)
10123 field->offset = fb->offset;
10124 field->parent = klass;
10125 fb->handle = field;
10126 mono_save_custom_attrs (klass->image, field, fb->cattrs);
10127
10128 if (fb->def_value) {
10129 MonoDynamicImage *assembly = (MonoDynamicImage*)klass->image;
10130 field->type->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
10131 idx = encode_constant (assembly, fb->def_value, &klass->ext->field_def_values [i].def_type);
10132 /* Copy the data from the blob since it might get realloc-ed */
10133 p = assembly->blob.data + idx;
10134 len = mono_metadata_decode_blob_size (p, &p2);
10135 len += p2 - p;
10136 klass->ext->field_def_values [i].data = mono_image_alloc (image, len);
10137 memcpy ((gpointer)klass->ext->field_def_values [i].data, p, len);
10138 }
10139 }
10140
10141 klass->instance_size = MAX (klass->instance_size, real_size);
10142 mono_class_layout_fields (klass);
10143 }
10144
10145 static void
10146 typebuilder_setup_properties (MonoClass *klass)
10147 {
10148 MonoReflectionTypeBuilder *tb = klass->reflection_info;
10149 MonoReflectionPropertyBuilder *pb;
10150 MonoImage *image = klass->image;
10151 MonoProperty *properties;
10152 int i;
10153
10154 if (!klass->ext)
10155 klass->ext = image_g_new0 (image, MonoClassExt, 1);
10156
10157 klass->ext->property.count = tb->properties ? mono_array_length (tb->properties) : 0;
10158 klass->ext->property.first = 0;
10159
10160 properties = image_g_new0 (image, MonoProperty, klass->ext->property.count);
10161 klass->ext->properties = properties;
10162 for (i = 0; i < klass->ext->property.count; ++i) {
10163 pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
10164 properties [i].parent = klass;
10165 properties [i].attrs = pb->attrs;
10166 properties [i].name = mono_string_to_utf8_image (image, pb->name);
10167 if (pb->get_method)
10168 properties [i].get = pb->get_method->mhandle;
10169 if (pb->set_method)
10170 properties [i].set = pb->set_method->mhandle;
10171
10172 mono_save_custom_attrs (klass->image, &properties [i], pb->cattrs);
10173 }
10174 }
10175
10176 MonoReflectionEvent *
10177 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb)
10178 {
10179 MonoEvent *event = g_new0 (MonoEvent, 1);
10180 MonoClass *klass;
10181 int j;
10182
10183 klass = mono_class_from_mono_type (tb->type.type);
10184
10185 event->parent = klass;
10186 event->attrs = eb->attrs;
10187 event->name = mono_string_to_utf8 (eb->name);
10188 if (eb->add_method)
10189 event->add = eb->add_method->mhandle;
10190 if (eb->remove_method)
10191 event->remove = eb->remove_method->mhandle;
10192 if (eb->raise_method)
10193 event->raise = eb->raise_method->mhandle;
10194
10195 if (eb->other_methods) {
10196 event->other = g_new0 (MonoMethod*, mono_array_length (eb->other_methods) + 1);
10197 for (j = 0; j < mono_array_length (eb->other_methods); ++j) {
10198 MonoReflectionMethodBuilder *mb =
10199 mono_array_get (eb->other_methods,
10200 MonoReflectionMethodBuilder*, j);
10201 event->other [j] = mb->mhandle;
10202 }
10203 }
10204
10205 return mono_event_get_object (mono_object_domain (tb), klass, event);
10206 }
10207
10208 static void
10209 typebuilder_setup_events (MonoClass *klass)
10210 {
10211 MonoReflectionTypeBuilder *tb = klass->reflection_info;
10212 MonoReflectionEventBuilder *eb;
10213 MonoImage *image = klass->image;
10214 MonoEvent *events;
10215 int i, j;
10216
10217 if (!klass->ext)
10218 klass->ext = image_g_new0 (image, MonoClassExt, 1);
10219
10220 klass->ext->event.count = tb->events ? mono_array_length (tb->events) : 0;
10221 klass->ext->event.first = 0;
10222
10223 events = image_g_new0 (image, MonoEvent, klass->ext->event.count);
10224 klass->ext->events = events;
10225 for (i = 0; i < klass->ext->event.count; ++i) {
10226 eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
10227 events [i].parent = klass;
10228 events [i].attrs = eb->attrs;
10229 events [i].name = mono_string_to_utf8_image (image, eb->name);
10230 if (eb->add_method)
10231 events [i].add = eb->add_method->mhandle;
10232 if (eb->remove_method)
10233 events [i].remove = eb->remove_method->mhandle;
10234 if (eb->raise_method)
10235 events [i].raise = eb->raise_method->mhandle;
10236
10237 if (eb->other_methods) {
10238 events [i].other = image_g_new0 (image, MonoMethod*, mono_array_length (eb->other_methods) + 1);
10239 for (j = 0; j < mono_array_length (eb->other_methods); ++j) {
10240 MonoReflectionMethodBuilder *mb =
10241 mono_array_get (eb->other_methods,
10242 MonoReflectionMethodBuilder*, j);
10243 events [i].other [j] = mb->mhandle;
10244 }
10245 }
10246 mono_save_custom_attrs (klass->image, &events [i], eb->cattrs);
10247 }
10248 }
10249
10250 static gboolean
10251 remove_instantiations_of (gpointer key,
10252 gpointer value,
10253 gpointer user_data)
10254 {
10255 MonoType *type = (MonoType*)key;
10256 MonoClass *klass = (MonoClass*)user_data;
10257
10258 if ((type->type == MONO_TYPE_GENERICINST) && (type->data.generic_class->container_class == klass))
10259 return TRUE;
10260 else
10261 return FALSE;
10262 }
10263
10264 static void
10265 check_array_for_usertypes (MonoArray *arr)
10266 {
10267 int i;
10268
10269 if (!arr)
10270 return;
10271
10272 for (i = 0; i < mono_array_length (arr); ++i)
10273 CHECK_MONOTYPE (mono_array_get (arr, gpointer, i));
10274 }
10275
10276 MonoReflectionType*
10277 mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
10278 {
10279 MonoClass *klass;
10280 MonoDomain* domain;
10281 MonoReflectionType* res;
10282 int i, j;
10283
10284 MONO_ARCH_SAVE_REGS;
10285
10286 domain = mono_object_domain (tb);
10287 klass = mono_class_from_mono_type (tb->type.type);
10288
10289 /*
10290 * Check for user defined Type subclasses.
10291 */
10292 CHECK_MONOTYPE (tb->parent);
10293 check_array_for_usertypes (tb->interfaces);
10294 if (tb->fields) {
10295 for (i = 0; i < mono_array_length (tb->fields); ++i) {
10296 MonoReflectionFieldBuilder *fb = mono_array_get (tb->fields, gpointer, i);
10297 if (fb) {
10298 CHECK_MONOTYPE (fb->type);
10299 check_array_for_usertypes (fb->modreq);
10300 check_array_for_usertypes (fb->modopt);
10301 if (fb->marshal_info && fb->marshal_info->marshaltyperef)
10302 CHECK_MONOTYPE (fb->marshal_info->marshaltyperef);
10303 }
10304 }
10305 }
10306 if (tb->methods) {
10307 for (i = 0; i < mono_array_length (tb->methods); ++i) {
10308 MonoReflectionMethodBuilder *mb = mono_array_get (tb->methods, gpointer, i);
10309 if (mb) {
10310 CHECK_MONOTYPE (mb->rtype);
10311 check_array_for_usertypes (mb->return_modreq);
10312 check_array_for_usertypes (mb->return_modopt);
10313 check_array_for_usertypes (mb->parameters);
10314 if (mb->param_modreq)
10315 for (j = 0; j < mono_array_length (mb->param_modreq); ++j)
10316 check_array_for_usertypes (mono_array_get (mb->param_modreq, MonoArray*, j));
10317 if (mb->param_modopt)
10318 for (j = 0; j < mono_array_length (mb->param_modopt); ++j)
10319 check_array_for_usertypes (mono_array_get (mb->param_modopt, MonoArray*, j));
10320 }
10321 }
10322 }
10323 if (tb->ctors) {
10324 for (i = 0; i < mono_array_length (tb->ctors); ++i) {
10325 MonoReflectionCtorBuilder *mb = mono_array_get (tb->ctors, gpointer, i);
10326 if (mb) {
10327 check_array_for_usertypes (mb->parameters);
10328 if (mb->param_modreq)
10329 for (j = 0; j < mono_array_length (mb->param_modreq); ++j)
10330 check_array_for_usertypes (mono_array_get (mb->param_modreq, MonoArray*, j));
10331 if (mb->param_modopt)
10332 for (j = 0; j < mono_array_length (mb->param_modopt); ++j)
10333 check_array_for_usertypes (mono_array_get (mb->param_modopt, MonoArray*, j));
10334 }
10335 }
10336 }
10337
10338 mono_save_custom_attrs (klass->image, klass, tb->cattrs);
10339
10340 /*
10341 * we need to lock the domain because the lock will be taken inside
10342 * So, we need to keep the locking order correct.
10343 */
10344 mono_loader_lock ();
10345 mono_domain_lock (domain);
10346 if (klass->wastypebuilder) {
10347 mono_domain_unlock (domain);
10348 mono_loader_unlock ();
10349 return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
10350 }
10351 /*
10352 * Fields to set in klass:
10353 * the various flags: delegate/unicode/contextbound etc.
10354 */
10355 klass->flags = tb->attrs;
10356 klass->has_cctor = 1;
10357 klass->has_finalize = 1;
10358
10359 #if 0
10360 if (!((MonoDynamicImage*)klass->image)->run) {
10361 if (klass->generic_container) {
10362 /* FIXME: The code below can't handle generic classes */
10363 klass->wastypebuilder = TRUE;
10364 mono_loader_unlock ();
10365 mono_domain_unlock (domain);
10366 return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
10367 }
10368 }
10369 #endif
10370
10371 /* enums are done right away */
10372 if (!klass->enumtype)
10373 ensure_runtime_vtable (klass);
10374
10375 if (tb->subtypes) {
10376 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
10377 MonoReflectionTypeBuilder *subtb = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
10378 mono_class_alloc_ext (klass);
10379 klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, mono_class_from_mono_type (subtb->type.type));
10380 }
10381 }
10382
10383 klass->nested_classes_inited = TRUE;
10384
10385 /* fields and object layout */
10386 if (klass->parent) {
10387 if (!klass->parent->size_inited)
10388 mono_class_init (klass->parent);
10389 klass->instance_size = klass->parent->instance_size;
10390 klass->sizes.class_size = 0;
10391 klass->min_align = klass->parent->min_align;
10392 /* if the type has no fields we won't call the field_setup
10393 * routine which sets up klass->has_references.
10394 */
10395 klass->has_references |= klass->parent->has_references;
10396 } else {
10397 klass->instance_size = sizeof (MonoObject);
10398 klass->min_align = 1;
10399 }
10400
10401 /* FIXME: handle packing_size and instance_size */
10402 typebuilder_setup_fields (klass);
10403
10404 typebuilder_setup_properties (klass);
10405
10406 typebuilder_setup_events (klass);
10407
10408 klass->wastypebuilder = TRUE;
10409
10410 /*
10411 * If we are a generic TypeBuilder, there might be instantiations in the type cache
10412 * which have type System.Reflection.MonoGenericClass, but after the type is created,
10413 * we want to return normal System.MonoType objects, so clear these out from the cache.
10414 */
10415 if (domain->type_hash && klass->generic_container)
10416 mono_g_hash_table_foreach_remove (domain->type_hash, remove_instantiations_of, klass);
10417
10418 mono_domain_unlock (domain);
10419 mono_loader_unlock ();
10420
10421 if (klass->enumtype && !mono_class_is_valid_enum (klass)) {
10422 mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
10423 mono_raise_exception (mono_get_exception_type_load (tb->name, NULL));
10424 }
10425
10426 res = mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
10427 g_assert (res != (MonoReflectionType*)tb);
10428
10429 return res;
10430 }
10431
10432 void
10433 mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam)
10434 {
10435 MonoGenericParamFull *param;
10436 MonoImage *image;
10437 MonoClass *pklass;
10438
10439 MONO_ARCH_SAVE_REGS;
10440
10441 param = g_new0 (MonoGenericParamFull, 1);
10442
10443 if (gparam->mbuilder) {
10444 if (!gparam->mbuilder->generic_container) {
10445 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)gparam->mbuilder->type;
10446 MonoClass *klass = mono_class_from_mono_type (tb->type.type);
10447 gparam->mbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
10448 gparam->mbuilder->generic_container->is_method = TRUE;
10449 }
10450 param->param.owner = gparam->mbuilder->generic_container;
10451 } else if (gparam->tbuilder) {
10452 if (!gparam->tbuilder->generic_container) {
10453 MonoClass *klass = mono_class_from_mono_type (gparam->tbuilder->type.type);
10454 gparam->tbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
10455 gparam->tbuilder->generic_container->owner.klass = klass;
10456 }
10457 param->param.owner = gparam->tbuilder->generic_container;
10458 }
10459
10460 param->info.name = mono_string_to_utf8 (gparam->name);
10461 param->param.num = gparam->index;
10462
10463 image = &gparam->tbuilder->module->dynamic_image->image;
10464 pklass = mono_class_from_generic_parameter ((MonoGenericParam *) param, image, gparam->mbuilder != NULL);
10465
10466 gparam->type.type = &pklass->byval_arg;
10467
10468 MOVING_GC_REGISTER (&pklass->reflection_info);
10469 pklass->reflection_info = gparam; /* FIXME: GC pin gparam */
10470 }
10471
10472 MonoArray *
10473 mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
10474 {
10475 MonoDynamicImage *assembly = sig->module->dynamic_image;
10476 guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
10477 guint32 buflen, i;
10478 MonoArray *result;
10479 SigBuffer buf;
10480
10481 check_array_for_usertypes (sig->arguments);
10482
10483 sigbuffer_init (&buf, 32);
10484
10485 sigbuffer_add_value (&buf, 0x07);
10486 sigbuffer_add_value (&buf, na);
10487 for (i = 0; i < na; ++i) {
10488 MonoReflectionType *type = mono_type_array_get (sig->arguments, i);
10489 encode_reflection_type (assembly, type, &buf);
10490 }
10491
10492 buflen = buf.p - buf.buf;
10493 result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
10494 memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
10495 sigbuffer_free (&buf);
10496
10497 return result;
10498 }
10499
10500 MonoArray *
10501 mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
10502 {
10503 MonoDynamicImage *assembly = sig->module->dynamic_image;
10504 guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
10505 guint32 buflen, i;
10506 MonoArray *result;
10507 SigBuffer buf;
10508
10509 check_array_for_usertypes (sig->arguments);
10510
10511 sigbuffer_init (&buf, 32);
10512
10513 sigbuffer_add_value (&buf, 0x06);
10514 for (i = 0; i < na; ++i) {
10515 MonoReflectionType *type = mono_type_array_get (sig->arguments, i);
10516 encode_reflection_type (assembly, type, &buf);
10517 }
10518
10519 buflen = buf.p - buf.buf;
10520 result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
10521 memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
10522 sigbuffer_free (&buf);
10523
10524 return result;
10525 }
10526
10527 void
10528 mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *mb)
10529 {
10530 ReflectionMethodBuilder rmb;
10531 MonoMethodSignature *sig;
10532 MonoClass *klass;
10533 GSList *l;
10534 int i;
10535
10536 sig = dynamic_method_to_signature (mb);
10537
10538 reflection_methodbuilder_from_dynamic_method (&rmb, mb);
10539
10540 /*
10541 * Resolve references.
10542 */
10543 /*
10544 * Every second entry in the refs array is reserved for storing handle_class,
10545 * which is needed by the ldtoken implementation in the JIT.
10546 */
10547 rmb.nrefs = mb->nrefs;
10548 rmb.refs = g_new0 (gpointer, mb->nrefs + 1);
10549 for (i = 0; i < mb->nrefs; i += 2) {
10550 MonoClass *handle_class;
10551 gpointer ref;
10552 MonoObject *obj = mono_array_get (mb->refs, MonoObject*, i);
10553
10554 if (strcmp (obj->vtable->klass->name, "DynamicMethod") == 0) {
10555 MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)obj;
10556 /*
10557 * The referenced DynamicMethod should already be created by the managed
10558 * code, except in the case of circular references. In that case, we store
10559 * method in the refs array, and fix it up later when the referenced
10560 * DynamicMethod is created.
10561 */
10562 if (method->mhandle) {
10563 ref = method->mhandle;
10564 } else {
10565 /* FIXME: GC object stored in unmanaged memory */
10566 ref = method;
10567
10568 /* FIXME: GC object stored in unmanaged memory */
10569 method->referenced_by = g_slist_append (method->referenced_by, mb);
10570 }
10571 handle_class = mono_defaults.methodhandle_class;
10572 } else {
10573 MonoException *ex = NULL;
10574 ref = resolve_object (mb->module->image, obj, &handle_class, NULL);
10575 if (!ref)
10576 ex = mono_get_exception_type_load (NULL, NULL);
10577 else if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR)
10578 ex = mono_security_core_clr_ensure_dynamic_method_resolved_object (ref, handle_class);
10579
10580 if (ex) {
10581 g_free (rmb.refs);
10582 mono_raise_exception (ex);
10583 return;
10584 }
10585 }
10586
10587 rmb.refs [i] = ref; /* FIXME: GC object stored in unmanaged memory (change also resolve_object() signature) */
10588 rmb.refs [i + 1] = handle_class;
10589 }
10590
10591 klass = mb->owner ? mono_class_from_mono_type (mb->owner->type) : mono_defaults.object_class;
10592
10593 mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
10594
10595 /* Fix up refs entries pointing at us */
10596 for (l = mb->referenced_by; l; l = l->next) {
10597 MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)l->data;
10598 MonoMethodWrapper *wrapper = (MonoMethodWrapper*)method->mhandle;
10599 gpointer *data;
10600
10601 g_assert (method->mhandle);
10602
10603 data = (gpointer*)wrapper->method_data;
10604 for (i = 0; i < GPOINTER_TO_UINT (data [0]); i += 2) {
10605 if ((data [i + 1] == mb) && (data [i + 1 + 1] == mono_defaults.methodhandle_class))
10606 data [i + 1] = mb->mhandle;
10607 }
10608 }
10609 g_slist_free (mb->referenced_by);
10610
10611 g_free (rmb.refs);
10612
10613 /* ilgen is no longer needed */
10614 mb->ilgen = NULL;
10615 }
10616
10617 #endif /* DISABLE_REFLECTION_EMIT */
10618
10619 void
10620 mono_reflection_destroy_dynamic_method (MonoReflectionDynamicMethod *mb)
10621 {
10622 g_assert (mb);
10623
10624 if (mb->mhandle)
10625 mono_runtime_free_method (
10626 mono_object_get_domain ((MonoObject*)mb), mb->mhandle);
10627 }
10628
10629 /**
10630 *
10631 * mono_reflection_is_valid_dynamic_token:
10632 *
10633 * Returns TRUE if token is valid.
10634 *
10635 */
10636 gboolean
10637 mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token)
10638 {
10639 return mono_g_hash_table_lookup (image->tokens, GUINT_TO_POINTER (token)) != NULL;
10640 }
10641
10642 #ifndef DISABLE_REFLECTION_EMIT
10643
10644 /**
10645 * mono_reflection_lookup_dynamic_token:
10646 *
10647 * Finish the Builder object pointed to by TOKEN and return the corresponding
10648 * runtime structure. If HANDLE_CLASS is not NULL, it is set to the class required by
10649 * mono_ldtoken. If valid_token is TRUE, assert if it is not found in the token->object
10650 * mapping table.
10651 *
10652 * LOCKING: Take the loader lock
10653 */
10654 gpointer
10655 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
10656 {
10657 MonoDynamicImage *assembly = (MonoDynamicImage*)image;
10658 MonoObject *obj;
10659 MonoClass *klass;
10660
10661 mono_loader_lock ();
10662 obj = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
10663 mono_loader_unlock ();
10664 if (!obj) {
10665 if (valid_token)
10666 g_assert_not_reached ();
10667 else
10668 return NULL;
10669 }
10670
10671 if (!handle_class)
10672 handle_class = &klass;
10673 return resolve_object (image, obj, handle_class, context);
10674 }
10675
10676 /*
10677 * ensure_complete_type:
10678 *
10679 * Ensure that KLASS is completed if it is a dynamic type, or references
10680 * dynamic types.
10681 */
10682 static void
10683 ensure_complete_type (MonoClass *klass)
10684 {
10685 if (klass->image->dynamic && !klass->wastypebuilder) {
10686 MonoReflectionTypeBuilder *tb = klass->reflection_info;
10687
10688 mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
10689
10690 // Asserting here could break a lot of code
10691 //g_assert (klass->wastypebuilder);
10692 }
10693
10694 if (klass->generic_class) {
10695 MonoGenericInst *inst = klass->generic_class->context.class_inst;
10696 int i;
10697
10698 for (i = 0; i < inst->type_argc; ++i) {
10699 ensure_complete_type (mono_class_from_mono_type (inst->type_argv [i]));
10700 }
10701 }
10702 }
10703
10704 static gpointer
10705 resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context)
10706 {
10707 gpointer result = NULL;
10708
10709 if (strcmp (obj->vtable->klass->name, "String") == 0) {
10710 result = mono_string_intern ((MonoString*)obj);
10711 *handle_class = NULL;
10712 g_assert (result);
10713 } else if (strcmp (obj->vtable->klass->name, "MonoType") == 0) {
10714 MonoReflectionType *tb = (MonoReflectionType*)obj;
10715 if (context) {
10716 MonoType *inflated = mono_class_inflate_generic_type (tb->type, context);
10717 result = mono_class_from_mono_type (inflated);
10718 mono_metadata_free_type (inflated);
10719 } else {
10720 result = mono_class_from_mono_type (tb->type);
10721 }
10722 *handle_class = mono_defaults.typehandle_class;
10723 g_assert (result);
10724 } else if (strcmp (obj->vtable->klass->name, "MonoMethod") == 0 ||
10725 strcmp (obj->vtable->klass->name, "MonoCMethod") == 0 ||
10726 strcmp (obj->vtable->klass->name, "MonoGenericCMethod") == 0 ||
10727 strcmp (obj->vtable->klass->name, "MonoGenericMethod") == 0) {
10728 result = ((MonoReflectionMethod*)obj)->method;
10729 if (context)
10730 result = mono_class_inflate_generic_method (result, context);
10731 *handle_class = mono_defaults.methodhandle_class;
10732 g_assert (result);
10733 } else if (strcmp (obj->vtable->klass->name, "MethodBuilder") == 0) {
10734 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)obj;
10735 result = mb->mhandle;
10736 if (!result) {
10737 /* Type is not yet created */
10738 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type;
10739
10740 mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
10741
10742 /*
10743 * Hopefully this has been filled in by calling CreateType() on the
10744 * TypeBuilder.
10745 */
10746 /*
10747 * TODO: This won't work if the application finishes another
10748 * TypeBuilder instance instead of this one.
10749 */
10750 result = mb->mhandle;
10751 }
10752 if (context)
10753 result = mono_class_inflate_generic_method (result, context);
10754 *handle_class = mono_defaults.methodhandle_class;
10755 } else if (strcmp (obj->vtable->klass->name, "ConstructorBuilder") == 0) {
10756 MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder*)obj;
10757
10758 result = cb->mhandle;
10759 if (!result) {
10760 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)cb->type;
10761
10762 mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
10763 result = cb->mhandle;
10764 }
10765 if (context)
10766 result = mono_class_inflate_generic_method (result, context);
10767 *handle_class = mono_defaults.methodhandle_class;
10768 } else if (strcmp (obj->vtable->klass->name, "MonoField") == 0) {
10769 MonoClassField *field = ((MonoReflectionField*)obj)->field;
10770
10771 ensure_complete_type (field->parent);
10772 if (context) {
10773 MonoType *inflated = mono_class_inflate_generic_type (&field->parent->byval_arg, context);
10774 MonoClass *class = mono_class_from_mono_type (inflated);
10775 MonoClassField *inflated_field;
10776 gpointer iter = NULL;
10777 mono_metadata_free_type (inflated);
10778 while ((inflated_field = mono_class_get_fields (class, &iter))) {
10779 if (!strcmp (field->name, inflated_field->name))
10780 break;
10781 }
10782 g_assert (inflated_field && !strcmp (field->name, inflated_field->name));
10783 result = inflated_field;
10784 } else {
10785 result = field;
10786 }
10787 *handle_class = mono_defaults.fieldhandle_class;
10788 g_assert (result);
10789 } else if (strcmp (obj->vtable->klass->name, "FieldBuilder") == 0) {
10790 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder*)obj;
10791 result = fb->handle;
10792
10793 if (!result) {
10794 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)fb->typeb;
10795
10796 mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
10797 result = fb->handle;
10798 }
10799
10800 if (fb->handle && fb->handle->parent->generic_container) {
10801 MonoClass *klass = fb->handle->parent;
10802 MonoType *type = mono_class_inflate_generic_type (&klass->byval_arg, context);
10803 MonoClass *inflated = mono_class_from_mono_type (type);
10804
10805 result = mono_class_get_field_from_name (inflated, mono_field_get_name (fb->handle));
10806 g_assert (result);
10807 mono_metadata_free_type (type);
10808 }
10809 *handle_class = mono_defaults.fieldhandle_class;
10810 } else if (strcmp (obj->vtable->klass->name, "TypeBuilder") == 0) {
10811 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)obj;
10812 MonoClass *klass;
10813
10814 klass = tb->type.type->data.klass;
10815 if (klass->wastypebuilder) {
10816 /* Already created */
10817 result = klass;
10818 }
10819 else {
10820 mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
10821 result = tb->type.type->data.klass;
10822 g_assert (result);
10823 }
10824 *handle_class = mono_defaults.typehandle_class;
10825 } else if (strcmp (obj->vtable->klass->name, "SignatureHelper") == 0) {
10826 MonoReflectionSigHelper *helper = (MonoReflectionSigHelper*)obj;
10827 MonoMethodSignature *sig;
10828 int nargs, i;
10829
10830 if (helper->arguments)
10831 nargs = mono_array_length (helper->arguments);
10832 else
10833 nargs = 0;
10834
10835 sig = mono_metadata_signature_alloc (image, nargs);
10836 sig->explicit_this = helper->call_conv & 64 ? 1 : 0;
10837 sig->hasthis = helper->call_conv & 32 ? 1 : 0;
10838
10839 if (helper->call_conv == 0) /* unmanaged */
10840 sig->call_convention = helper->unmanaged_call_conv - 1;
10841 else
10842 if (helper->call_conv & 0x02)
10843 sig->call_convention = MONO_CALL_VARARG;
10844 else
10845 sig->call_convention = MONO_CALL_DEFAULT;
10846
10847 sig->param_count = nargs;
10848 /* TODO: Copy type ? */
10849 sig->ret = helper->return_type->type;
10850 for (i = 0; i < nargs; ++i) {
10851 MonoReflectionType *rt = mono_type_array_get (helper->arguments, i);
10852 sig->params [i] = rt->type;
10853 }
10854
10855 result = sig;
10856 *handle_class = NULL;
10857 } else if (strcmp (obj->vtable->klass->name, "DynamicMethod") == 0) {
10858 MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)obj;
10859 /* Already created by the managed code */
10860 g_assert (method->mhandle);
10861 result = method->mhandle;
10862 *handle_class = mono_defaults.methodhandle_class;
10863 } else if (strcmp (obj->vtable->klass->name, "GenericTypeParameterBuilder") == 0) {
10864 MonoReflectionType *tb = (MonoReflectionType*)obj;
10865 MonoType *type = mono_class_inflate_generic_type (tb->type, context);
10866 result = mono_class_from_mono_type (type);
10867 *handle_class = mono_defaults.typehandle_class;
10868 g_assert (result);
10869 mono_metadata_free_type (type);
10870 } else if (strcmp (obj->vtable->klass->name, "MonoGenericClass") == 0) {
10871 MonoReflectionGenericClass *ref = (MonoReflectionGenericClass*)obj;
10872 MonoType *type = mono_class_inflate_generic_type (ref->type.type, context);
10873 result = mono_class_from_mono_type (type);
10874 *handle_class = mono_defaults.typehandle_class;
10875 g_assert (result);
10876 mono_metadata_free_type (type);
10877 } else if (strcmp (obj->vtable->klass->name, "FieldOnTypeBuilderInst") == 0) {
10878 MonoReflectionFieldOnTypeBuilderInst *f = (MonoReflectionFieldOnTypeBuilderInst*)obj;
10879 MonoClass *inflated;
10880 MonoType *type;
10881
10882 type = mono_class_inflate_generic_type (f->inst->type.type, context);
10883 inflated = mono_class_from_mono_type (type);
10884
10885 g_assert (f->fb->handle);
10886 result = mono_class_get_field_from_name (inflated, mono_field_get_name (f->fb->handle));
10887 g_assert (result);
10888 mono_metadata_free_type (type);
10889 *handle_class = mono_defaults.fieldhandle_class;
10890 } else if (strcmp (obj->vtable->klass->name, "ConstructorOnTypeBuilderInst") == 0) {
10891 MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)obj;
10892 MonoType *type = mono_class_inflate_generic_type (c->inst->type.type, context);
10893 MonoClass *inflated_klass = mono_class_from_mono_type (type);
10894 g_assert (c->cb->mhandle);
10895 result = inflate_mono_method (inflated_klass, c->cb->mhandle, (MonoObject*)c->cb);
10896 *handle_class = mono_defaults.methodhandle_class;
10897 mono_metadata_free_type (type);
10898 } else if (strcmp (obj->vtable->klass->name, "MethodOnTypeBuilderInst") == 0) {
10899 MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj;
10900 MonoType *type = mono_class_inflate_generic_type (m->inst->type.type, context);
10901 MonoClass *inflated_klass = mono_class_from_mono_type (type);
10902 g_assert (m->mb->mhandle);
10903 result = inflate_mono_method (inflated_klass, m->mb->mhandle, (MonoObject*)m->mb);
10904 *handle_class = mono_defaults.methodhandle_class;
10905 mono_metadata_free_type (type);
10906 } else {
10907 g_print (obj->vtable->klass->name);
10908 g_assert_not_reached ();
10909 }
10910 return result;
10911 }
10912
10913 #else /* DISABLE_REFLECTION_EMIT */
10914
10915 MonoArray*
10916 mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
10917 {
10918 g_assert_not_reached ();
10919 return NULL;
10920 }
10921
10922 void
10923 mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb)
10924 {
10925 g_assert_not_reached ();
10926 }
10927
10928 void
10929 mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb)
10930 {
10931 g_assert_not_reached ();
10932 }
10933
10934 void
10935 mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb)
10936 {
10937 g_assert_not_reached ();
10938 }
10939
10940 void
10941 mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb)
10942 {
10943 g_assert_not_reached ();
10944 }
10945
10946 void
10947 mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
10948 {
10949 g_error ("This mono runtime was configured with --enable-minimal=reflection_emit, so System.Reflection.Emit is not supported.");
10950 }
10951
10952 void
10953 mono_image_module_basic_init (MonoReflectionModuleBuilder *moduleb)
10954 {
10955 g_assert_not_reached ();
10956 }
10957
10958 MonoReflectionModule *
10959 mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *ab, MonoString *fileName)
10960 {
10961 g_assert_not_reached ();
10962 return NULL;
10963 }
10964
10965 guint32
10966 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str)
10967 {
10968 g_assert_not_reached ();
10969 return 0;
10970 }
10971
10972 guint32
10973 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types)
10974 {
10975 g_assert_not_reached ();
10976 return 0;
10977 }
10978
10979 guint32
10980 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj,
10981 gboolean create_methodspec, gboolean register_token)
10982 {
10983 g_assert_not_reached ();
10984 return 0;
10985 }
10986
10987 void
10988 mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj)
10989 {
10990 }
10991
10992 void
10993 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *methods,
10994 MonoArray *ctors, MonoArray *fields, MonoArray *properties,
10995 MonoArray *events)
10996 {
10997 g_assert_not_reached ();
10998 }
10999
11000 void
11001 mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides)
11002 {
11003 *overrides = NULL;
11004 *num_overrides = 0;
11005 }
11006
11007 MonoReflectionEvent *
11008 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb)
11009 {
11010 g_assert_not_reached ();
11011 return NULL;
11012 }
11013
11014 MonoReflectionType*
11015 mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
11016 {
11017 g_assert_not_reached ();
11018 return NULL;
11019 }
11020
11021 void
11022 mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam)
11023 {
11024 g_assert_not_reached ();
11025 }
11026
11027 MonoArray *
11028 mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
11029 {
11030 g_assert_not_reached ();
11031 return NULL;
11032 }
11033
11034 MonoArray *
11035 mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
11036 {
11037 g_assert_not_reached ();
11038 return NULL;
11039 }
11040
11041 void
11042 mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *mb)
11043 {
11044 }
11045
11046 gpointer
11047 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
11048 {
11049 return NULL;
11050 }
11051
11052 #endif /* DISABLE_REFLECTION_EMIT */
11053
11054 /* SECURITY_ACTION_* are defined in mono/metadata/tabledefs.h */
11055 const static guint32 declsec_flags_map[] = {
11056 0x00000000, /* empty */
11057 MONO_DECLSEC_FLAG_REQUEST, /* SECURITY_ACTION_REQUEST (x01) */
11058 MONO_DECLSEC_FLAG_DEMAND, /* SECURITY_ACTION_DEMAND (x02) */
11059 MONO_DECLSEC_FLAG_ASSERT, /* SECURITY_ACTION_ASSERT (x03) */
11060 MONO_DECLSEC_FLAG_DENY, /* SECURITY_ACTION_DENY (x04) */
11061 MONO_DECLSEC_FLAG_PERMITONLY, /* SECURITY_ACTION_PERMITONLY (x05) */
11062 MONO_DECLSEC_FLAG_LINKDEMAND, /* SECURITY_ACTION_LINKDEMAND (x06) */
11063 MONO_DECLSEC_FLAG_INHERITANCEDEMAND, /* SECURITY_ACTION_INHERITANCEDEMAND (x07) */
11064 MONO_DECLSEC_FLAG_REQUEST_MINIMUM, /* SECURITY_ACTION_REQUEST_MINIMUM (x08) */
11065 MONO_DECLSEC_FLAG_REQUEST_OPTIONAL, /* SECURITY_ACTION_REQUEST_OPTIONAL (x09) */
11066 MONO_DECLSEC_FLAG_REQUEST_REFUSE, /* SECURITY_ACTION_REQUEST_REFUSE (x0A) */
11067 MONO_DECLSEC_FLAG_PREJIT_GRANT, /* SECURITY_ACTION_PREJIT_GRANT (x0B) */
11068 MONO_DECLSEC_FLAG_PREJIT_DENY, /* SECURITY_ACTION_PREJIT_DENY (x0C) */
11069 MONO_DECLSEC_FLAG_NONCAS_DEMAND, /* SECURITY_ACTION_NONCAS_DEMAND (x0D) */
11070 MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND, /* SECURITY_ACTION_NONCAS_LINKDEMAND (x0E) */
11071 MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND, /* SECURITY_ACTION_NONCAS_INHERITANCEDEMAND (x0F) */
11072 MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE, /* SECURITY_ACTION_LINKDEMAND_CHOICE (x10) */
11073 MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE, /* SECURITY_ACTION_INHERITANCEDEMAND_CHOICE (x11) */
11074 MONO_DECLSEC_FLAG_DEMAND_CHOICE, /* SECURITY_ACTION_DEMAND_CHOICE (x12) */
11075 };
11076
11077 /*
11078 * Returns flags that includes all available security action associated to the handle.
11079 * @token: metadata token (either for a class or a method)
11080 * @image: image where resides the metadata.
11081 */
11082 static guint32
11083 mono_declsec_get_flags (MonoImage *image, guint32 token)
11084 {
11085 int index = mono_metadata_declsec_from_index (image, token);
11086 MonoTableInfo *t = &image->tables [MONO_TABLE_DECLSECURITY];
11087 guint32 result = 0;
11088 guint32 action;
11089 int i;
11090
11091 /* HasSecurity can be present for other, not specially encoded, attributes,
11092 e.g. SuppressUnmanagedCodeSecurityAttribute */
11093 if (index < 0)
11094 return 0;
11095
11096 for (i = index; i < t->rows; i++) {
11097 guint32 cols [MONO_DECL_SECURITY_SIZE];
11098
11099 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
11100 if (cols [MONO_DECL_SECURITY_PARENT] != token)
11101 break;
11102
11103 action = cols [MONO_DECL_SECURITY_ACTION];
11104 if ((action >= MONO_DECLSEC_ACTION_MIN) && (action <= MONO_DECLSEC_ACTION_MAX)) {
11105 result |= declsec_flags_map [action];
11106 } else {
11107 g_assert_not_reached ();
11108 }
11109 }
11110 return result;
11111 }
11112
11113 /*
11114 * Get the security actions (in the form of flags) associated with the specified method.
11115 *
11116 * @method: The method for which we want the declarative security flags.
11117 * Return the declarative security flags for the method (only).
11118 *
11119 * Note: To keep MonoMethod size down we do not cache the declarative security flags
11120 * (except for the stack modifiers which are kept in the MonoJitInfo structure)
11121 */
11122 guint32
11123 mono_declsec_flags_from_method (MonoMethod *method)
11124 {
11125 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
11126 /* FIXME: No cache (for the moment) */
11127 guint32 idx = mono_method_get_index (method);
11128 idx <<= MONO_HAS_DECL_SECURITY_BITS;
11129 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
11130 return mono_declsec_get_flags (method->klass->image, idx);
11131 }
11132 return 0;
11133 }
11134
11135 /*
11136 * Get the security actions (in the form of flags) associated with the specified class.
11137 *
11138 * @klass: The class for which we want the declarative security flags.
11139 * Return the declarative security flags for the class.
11140 *
11141 * Note: We cache the flags inside the MonoClass structure as this will get
11142 * called very often (at least for each method).
11143 */
11144 guint32
11145 mono_declsec_flags_from_class (MonoClass *klass)
11146 {
11147 if (klass->flags & TYPE_ATTRIBUTE_HAS_SECURITY) {
11148 if (!klass->ext || !klass->ext->declsec_flags) {
11149 guint32 idx;
11150
11151 idx = mono_metadata_token_index (klass->type_token);
11152 idx <<= MONO_HAS_DECL_SECURITY_BITS;
11153 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
11154 mono_loader_lock ();
11155 mono_class_alloc_ext (klass);
11156 mono_loader_unlock ();
11157 /* we cache the flags on classes */
11158 klass->ext->declsec_flags = mono_declsec_get_flags (klass->image, idx);
11159 }
11160 return klass->ext->declsec_flags;
11161 }
11162 return 0;
11163 }
11164
11165 /*
11166 * Get the security actions (in the form of flags) associated with the specified assembly.
11167 *
11168 * @assembly: The assembly for which we want the declarative security flags.
11169 * Return the declarative security flags for the assembly.
11170 */
11171 guint32
11172 mono_declsec_flags_from_assembly (MonoAssembly *assembly)
11173 {
11174 guint32 idx = 1; /* there is only one assembly */
11175 idx <<= MONO_HAS_DECL_SECURITY_BITS;
11176 idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
11177 return mono_declsec_get_flags (assembly->image, idx);
11178 }
11179
11180
11181 /*
11182 * Fill actions for the specific index (which may either be an encoded class token or
11183 * an encoded method token) from the metadata image.
11184 * Returns TRUE if some actions requiring code generation are present, FALSE otherwise.
11185 */
11186 static MonoBoolean
11187 fill_actions_from_index (MonoImage *image, guint32 token, MonoDeclSecurityActions* actions,
11188 guint32 id_std, guint32 id_noncas, guint32 id_choice)
11189 {
11190 MonoBoolean result = FALSE;
11191 MonoTableInfo *t;
11192 guint32 cols [MONO_DECL_SECURITY_SIZE];
11193 int index = mono_metadata_declsec_from_index (image, token);
11194 int i;
11195
11196 t = &image->tables [MONO_TABLE_DECLSECURITY];
11197 for (i = index; i < t->rows; i++) {
11198 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
11199
11200 if (cols [MONO_DECL_SECURITY_PARENT] != token)
11201 return result;
11202
11203 /* if present only replace (class) permissions with method permissions */
11204 /* if empty accept either class or method permissions */
11205 if (cols [MONO_DECL_SECURITY_ACTION] == id_std) {
11206 if (!actions->demand.blob) {
11207 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
11208 actions->demand.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
11209 actions->demand.blob = (char*) (blob + 2);
11210 actions->demand.size = mono_metadata_decode_blob_size (blob, &blob);
11211 result = TRUE;
11212 }
11213 } else if (cols [MONO_DECL_SECURITY_ACTION] == id_noncas) {
11214 if (!actions->noncasdemand.blob) {
11215 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
11216 actions->noncasdemand.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
11217 actions->noncasdemand.blob = (char*) (blob + 2);
11218 actions->noncasdemand.size = mono_metadata_decode_blob_size (blob, &blob);
11219 result = TRUE;
11220 }
11221 } else if (cols [MONO_DECL_SECURITY_ACTION] == id_choice) {
11222 if (!actions->demandchoice.blob) {
11223 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
11224 actions->demandchoice.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
11225 actions->demandchoice.blob = (char*) (blob + 2);
11226 actions->demandchoice.size = mono_metadata_decode_blob_size (blob, &blob);
11227 result = TRUE;
11228 }
11229 }
11230 }
11231
11232 return result;
11233 }
11234
11235 static MonoBoolean
11236 mono_declsec_get_class_demands_params (MonoClass *klass, MonoDeclSecurityActions* demands,
11237 guint32 id_std, guint32 id_noncas, guint32 id_choice)
11238 {
11239 guint32 idx = mono_metadata_token_index (klass->type_token);
11240 idx <<= MONO_HAS_DECL_SECURITY_BITS;
11241 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
11242 return fill_actions_from_index (klass->image, idx, demands, id_std, id_noncas, id_choice);
11243 }
11244
11245 static MonoBoolean
11246 mono_declsec_get_method_demands_params (MonoMethod *method, MonoDeclSecurityActions* demands,
11247 guint32 id_std, guint32 id_noncas, guint32 id_choice)
11248 {
11249 guint32 idx = mono_method_get_index (method);
11250 idx <<= MONO_HAS_DECL_SECURITY_BITS;
11251 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
11252 return fill_actions_from_index (method->klass->image, idx, demands, id_std, id_noncas, id_choice);
11253 }
11254
11255 /*
11256 * Collect all actions (that requires to generate code in mini) assigned for
11257 * the specified method.
11258 * Note: Don't use the content of actions if the function return FALSE.
11259 */
11260 MonoBoolean
11261 mono_declsec_get_demands (MonoMethod *method, MonoDeclSecurityActions* demands)
11262 {
11263 guint32 mask = MONO_DECLSEC_FLAG_DEMAND | MONO_DECLSEC_FLAG_NONCAS_DEMAND |
11264 MONO_DECLSEC_FLAG_DEMAND_CHOICE;
11265 MonoBoolean result = FALSE;
11266 guint32 flags;
11267
11268 /* quick exit if no declarative security is present in the metadata */
11269 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
11270 return FALSE;
11271
11272 /* we want the original as the wrapper is "free" of the security informations */
11273 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
11274 method = mono_marshal_method_from_wrapper (method);
11275 if (!method)
11276 return FALSE;
11277 }
11278
11279 /* First we look for method-level attributes */
11280 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
11281 mono_class_init (method->klass);
11282 memset (demands, 0, sizeof (MonoDeclSecurityActions));
11283
11284 result = mono_declsec_get_method_demands_params (method, demands,
11285 SECURITY_ACTION_DEMAND, SECURITY_ACTION_NONCASDEMAND, SECURITY_ACTION_DEMANDCHOICE);
11286 }
11287
11288 /* Here we use (or create) the class declarative cache to look for demands */
11289 flags = mono_declsec_flags_from_class (method->klass);
11290 if (flags & mask) {
11291 if (!result) {
11292 mono_class_init (method->klass);
11293 memset (demands, 0, sizeof (MonoDeclSecurityActions));
11294 }
11295 result |= mono_declsec_get_class_demands_params (method->klass, demands,
11296 SECURITY_ACTION_DEMAND, SECURITY_ACTION_NONCASDEMAND, SECURITY_ACTION_DEMANDCHOICE);
11297 }
11298
11299 /* The boolean return value is used as a shortcut in case nothing needs to
11300 be generated (e.g. LinkDemand[Choice] and InheritanceDemand[Choice]) */
11301 return result;
11302 }
11303
11304
11305 /*
11306 * Collect all Link actions: LinkDemand, NonCasLinkDemand and LinkDemandChoice (2.0).
11307 *
11308 * Note: Don't use the content of actions if the function return FALSE.
11309 */
11310 MonoBoolean
11311 mono_declsec_get_linkdemands (MonoMethod *method, MonoDeclSecurityActions* klass, MonoDeclSecurityActions *cmethod)
11312 {
11313 MonoBoolean result = FALSE;
11314 guint32 flags;
11315
11316 /* quick exit if no declarative security is present in the metadata */
11317 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
11318 return FALSE;
11319
11320 /* we want the original as the wrapper is "free" of the security informations */
11321 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
11322 method = mono_marshal_method_from_wrapper (method);
11323 if (!method)
11324 return FALSE;
11325 }
11326
11327 /* results are independant - zeroize both */
11328 memset (cmethod, 0, sizeof (MonoDeclSecurityActions));
11329 memset (klass, 0, sizeof (MonoDeclSecurityActions));
11330
11331 /* First we look for method-level attributes */
11332 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
11333 mono_class_init (method->klass);
11334
11335 result = mono_declsec_get_method_demands_params (method, cmethod,
11336 SECURITY_ACTION_LINKDEMAND, SECURITY_ACTION_NONCASLINKDEMAND, SECURITY_ACTION_LINKDEMANDCHOICE);
11337 }
11338
11339 /* Here we use (or create) the class declarative cache to look for demands */
11340 flags = mono_declsec_flags_from_class (method->klass);
11341 if (flags & (MONO_DECLSEC_FLAG_LINKDEMAND | MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND | MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE)) {
11342 mono_class_init (method->klass);
11343
11344 result |= mono_declsec_get_class_demands_params (method->klass, klass,
11345 SECURITY_ACTION_LINKDEMAND, SECURITY_ACTION_NONCASLINKDEMAND, SECURITY_ACTION_LINKDEMANDCHOICE);
11346 }
11347
11348 return result;
11349 }
11350
11351 /*
11352 * Collect all Inherit actions: InheritanceDemand, NonCasInheritanceDemand and InheritanceDemandChoice (2.0).
11353 *
11354 * @klass The inherited class - this is the class that provides the security check (attributes)
11355 * @demans
11356 * return TRUE if inheritance demands (any kind) are present, FALSE otherwise.
11357 *
11358 * Note: Don't use the content of actions if the function return FALSE.
11359 */
11360 MonoBoolean
11361 mono_declsec_get_inheritdemands_class (MonoClass *klass, MonoDeclSecurityActions* demands)
11362 {
11363 MonoBoolean result = FALSE;
11364 guint32 flags;
11365
11366 /* quick exit if no declarative security is present in the metadata */
11367 if (!klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
11368 return FALSE;
11369
11370 /* Here we use (or create) the class declarative cache to look for demands */
11371 flags = mono_declsec_flags_from_class (klass);
11372 if (flags & (MONO_DECLSEC_FLAG_INHERITANCEDEMAND | MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND | MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE)) {
11373 mono_class_init (klass);
11374 memset (demands, 0, sizeof (MonoDeclSecurityActions));
11375
11376 result |= mono_declsec_get_class_demands_params (klass, demands,
11377 SECURITY_ACTION_INHERITDEMAND, SECURITY_ACTION_NONCASINHERITANCE, SECURITY_ACTION_INHERITDEMANDCHOICE);
11378 }
11379
11380 return result;
11381 }
11382
11383 /*
11384 * Collect all Inherit actions: InheritanceDemand, NonCasInheritanceDemand and InheritanceDemandChoice (2.0).
11385 *
11386 * Note: Don't use the content of actions if the function return FALSE.
11387 */
11388 MonoBoolean
11389 mono_declsec_get_inheritdemands_method (MonoMethod *method, MonoDeclSecurityActions* demands)
11390 {
11391 /* quick exit if no declarative security is present in the metadata */
11392 if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
11393 return FALSE;
11394
11395 /* we want the original as the wrapper is "free" of the security informations */
11396 if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
11397 method = mono_marshal_method_from_wrapper (method);
11398 if (!method)
11399 return FALSE;
11400 }
11401
11402 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
11403 mono_class_init (method->klass);
11404 memset (demands, 0, sizeof (MonoDeclSecurityActions));
11405
11406 return mono_declsec_get_method_demands_params (method, demands,
11407 SECURITY_ACTION_INHERITDEMAND, SECURITY_ACTION_NONCASINHERITANCE, SECURITY_ACTION_INHERITDEMANDCHOICE);
11408 }
11409 return FALSE;
11410 }
11411
11412
11413 static MonoBoolean
11414 get_declsec_action (MonoImage *image, guint32 token, guint32 action, MonoDeclSecurityEntry *entry)
11415 {
11416 guint32 cols [MONO_DECL_SECURITY_SIZE];
11417 MonoTableInfo *t;
11418 int i;
11419
11420 int index = mono_metadata_declsec_from_index (image, token);
11421 if (index == -1)
11422 return FALSE;
11423
11424 t = &image->tables [MONO_TABLE_DECLSECURITY];
11425 for (i = index; i < t->rows; i++) {
11426 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
11427
11428 /* shortcut - index are ordered */
11429 if (token != cols [MONO_DECL_SECURITY_PARENT])
11430 return FALSE;
11431
11432 if (cols [MONO_DECL_SECURITY_ACTION] == action) {
11433 const char *metadata = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
11434 entry->blob = (char*) (metadata + 2);
11435 entry->size = mono_metadata_decode_blob_size (metadata, &metadata);
11436 return TRUE;
11437 }
11438 }
11439
11440 return FALSE;
11441 }
11442
11443 MonoBoolean
11444 mono_declsec_get_method_action (MonoMethod *method, guint32 action, MonoDeclSecurityEntry *entry)
11445 {
11446 if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
11447 guint32 idx = mono_method_get_index (method);
11448 idx <<= MONO_HAS_DECL_SECURITY_BITS;
11449 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
11450 return get_declsec_action (method->klass->image, idx, action, entry);
11451 }
11452 return FALSE;
11453 }
11454
11455 MonoBoolean
11456 mono_declsec_get_class_action (MonoClass *klass, guint32 action, MonoDeclSecurityEntry *entry)
11457 {
11458 /* use cache */
11459 guint32 flags = mono_declsec_flags_from_class (klass);
11460 if (declsec_flags_map [action] & flags) {
11461 guint32 idx = mono_metadata_token_index (klass->type_token);
11462 idx <<= MONO_HAS_DECL_SECURITY_BITS;
11463 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
11464 return get_declsec_action (klass->image, idx, action, entry);
11465 }
11466 return FALSE;
11467 }
11468
11469 MonoBoolean
11470 mono_declsec_get_assembly_action (MonoAssembly *assembly, guint32 action, MonoDeclSecurityEntry *entry)
11471 {
11472 guint32 idx = 1; /* there is only one assembly */
11473 idx <<= MONO_HAS_DECL_SECURITY_BITS;
11474 idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
11475
11476 return get_declsec_action (assembly->image, idx, action, entry);
11477 }
11478
11479 gboolean
11480 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass)
11481 {
11482 MonoObject *res, *exc;
11483 void *params [1];
11484 static MonoClass *System_Reflection_Emit_TypeBuilder = NULL;
11485 static MonoMethod *method = NULL;
11486
11487 if (!System_Reflection_Emit_TypeBuilder) {
11488 System_Reflection_Emit_TypeBuilder = mono_class_from_name (mono_defaults.corlib, "System.Reflection.Emit", "TypeBuilder");
11489 g_assert (System_Reflection_Emit_TypeBuilder);
11490 }
11491 if (method == NULL) {
11492 method = mono_class_get_method_from_name (System_Reflection_Emit_TypeBuilder, "IsAssignableTo", 1);
11493 g_assert (method);
11494 }
11495
11496 /*
11497 * The result of mono_type_get_object () might be a System.MonoType but we
11498 * need a TypeBuilder so use klass->reflection_info.
11499 */
11500 g_assert (klass->reflection_info);
11501 g_assert (!strcmp (((MonoObject*)(klass->reflection_info))->vtable->klass->name, "TypeBuilder"));
11502
11503 params [0] = mono_type_get_object (mono_domain_get (), &oklass->byval_arg);
11504
11505 res = mono_runtime_invoke (method, (MonoObject*)(klass->reflection_info), params, &exc);
11506 if (exc)
11507 return FALSE;
11508 else
11509 return *(MonoBoolean*)mono_object_unbox (res);
11510 }
git-svn mirror of mono