mono/metadata/reflection.c

   1 /*
   2  * reflection.c: Routines for creating an image at runtime.
   3  *
   4  * Author:
   5  *   Paolo Molaro (lupus@ximian.com)
   6  *
   7  * (C) 2001, 2002 Ximian, Inc.  http://www.ximian.com
   8  *
   9  */
  10 #include <config.h>
  11 #include "mono/utils/mono-digest.h"
  12 #include "mono/metadata/reflection.h"
  13 #include "mono/metadata/tabledefs.h"
  14 #include "mono/metadata/metadata-internals.h"
  15 #include "mono/metadata/class-internals.h"
  16 #include "mono/metadata/tokentype.h"
  17 #include "mono/metadata/domain-internals.h"
  18 #include "mono/metadata/opcodes.h"
  19 #include "mono/metadata/assembly.h"
  20 #include "mono/metadata/object-internals.h"
  21 #include <mono/metadata/exception.h>
  22 #include <stdio.h>
  23 #include <glib.h>
  24 #include <errno.h>
  25 #include <time.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28 #include "image.h"
  29 #include "cil-coff.h"
  30 #include "rawbuffer.h"
  31 #include "mono-endian.h"
  32 #include "private.h"
  33 #include <mono/os/gc_wrapper.h>
  34
  35 #define TEXT_OFFSET 512
  36 #define CLI_H_SIZE 136
  37 #define FILE_ALIGN 512
  38 #define VIRT_ALIGN 8192
  39 #define START_TEXT_RVA  0x00002000
  40
  41 typedef struct {
  42         MonoReflectionILGen *ilgen;
  43         MonoReflectionType *rtype;
  44         MonoArray *parameters;
  45         MonoArray *generic_params;
  46         MonoArray *pinfo;
  47         MonoArray *opt_types;
  48         guint32 attrs;
  49         guint32 iattrs;
  50         guint32 call_conv;
  51         guint32 *table_idx; /* note: it's a pointer */
  52         MonoArray *code;
  53         MonoObject *type;
  54         MonoString *name;
  55         MonoBoolean init_locals;
  56         MonoArray *return_modreq;
  57         MonoArray *return_modopt;
  58         MonoArray *param_modreq;
  59         MonoArray *param_modopt;
  60         MonoArray *permissions;
  61         MonoMethod *mhandle;
  62         guint32 nrefs;
  63         gpointer *refs;
  64         /* for PInvoke */
  65         int charset, lasterr, native_cc;
  66         MonoString *dll, *dllentry;
  67 } ReflectionMethodBuilder;
  68
  69 typedef struct {
  70         guint32 owner;
  71         MonoReflectionGenericParam *gparam;
  72 } GenericParamTableEntry;
  73
  74 const unsigned char table_sizes [64] = {
  75         MONO_MODULE_SIZE,
  76         MONO_TYPEREF_SIZE,
  77         MONO_TYPEDEF_SIZE,
  78         0,
  79         MONO_FIELD_SIZE,
  80         0,
  81         MONO_METHOD_SIZE,
  82         0,
  83         MONO_PARAM_SIZE,
  84         MONO_INTERFACEIMPL_SIZE,
  85         MONO_MEMBERREF_SIZE,    /* 0x0A */
  86         MONO_CONSTANT_SIZE,
  87         MONO_CUSTOM_ATTR_SIZE,
  88         MONO_FIELD_MARSHAL_SIZE,
  89         MONO_DECL_SECURITY_SIZE,
  90         MONO_CLASS_LAYOUT_SIZE,
  91         MONO_FIELD_LAYOUT_SIZE, /* 0x10 */
  92         MONO_STAND_ALONE_SIGNATURE_SIZE,
  93         MONO_EVENT_MAP_SIZE,
  94         0,
  95         MONO_EVENT_SIZE,
  96         MONO_PROPERTY_MAP_SIZE,
  97         0,
  98         MONO_PROPERTY_SIZE,
  99         MONO_METHOD_SEMA_SIZE,
 100         MONO_METHODIMPL_SIZE,
 101         MONO_MODULEREF_SIZE,    /* 0x1A */
 102         MONO_TYPESPEC_SIZE,
 103         MONO_IMPLMAP_SIZE,
 104         MONO_FIELD_RVA_SIZE,
 105         0,
 106         0,
 107         MONO_ASSEMBLY_SIZE,     /* 0x20 */
 108         MONO_ASSEMBLY_PROCESSOR_SIZE,
 109         MONO_ASSEMBLYOS_SIZE,
 110         MONO_ASSEMBLYREF_SIZE,
 111         MONO_ASSEMBLYREFPROC_SIZE,
 112         MONO_ASSEMBLYREFOS_SIZE,
 113         MONO_FILE_SIZE,
 114         MONO_EXP_TYPE_SIZE,
 115         MONO_MANIFEST_SIZE,
 116         MONO_NESTED_CLASS_SIZE,
 117
 118         MONO_GENERICPARAM_SIZE, /* 0x2A */
 119         MONO_METHODSPEC_SIZE,
 120         MONO_GENPARCONSTRAINT_SIZE,
 121
 122         0       /* 0x2D */
 123 };
 124
 125 /**
 126  * These macros can be used to allocate long living atomic data so it won't be
 127  * tracked by the garbage collector. We use libgc because it's apparently faster
 128  * than g_malloc.
 129  */
 130 #ifdef HAVE_BOEHM_GC
 131 #define ALLOC_ATOMIC(size) GC_MALLOC_ATOMIC (size)
 132 #define FREE_ATOMIC(ptr)
 133 #define REALLOC_ATOMIC(ptr, size) GC_REALLOC ((ptr), (size))
 134 #else
 135 #define ALLOC_ATOMIC(size) g_malloc (size)
 136 #define FREE_ATOMIC(ptr) g_free (ptr)
 137 #define REALLOC_ATOMIC(ptr, size) g_realloc ((ptr), (size))
 138 #endif
 139
 140 static void reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb);
 141 static void reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb);
 142 static guint32 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type);
 143 static guint32 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method);
 144 static guint32 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb);
 145 static guint32 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *cb);
 146 static guint32 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper);
 147 static void    mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly);
 148 static guint32 encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo);
 149 static guint32 encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type);
 150 static char*   type_get_qualified_name (MonoType *type, MonoAssembly *ass);
 151 static void    ensure_runtime_vtable (MonoClass *klass);
 152 static gpointer resolve_object (MonoImage *image, MonoObject *obj);
 153 static void    encode_type (MonoDynamicImage *assembly, MonoType *type, char *p, char **endbuf);
 154 static guint32 type_get_signature_size (MonoType *type);
 155 static void get_default_param_value_blobs (MonoMethod *method, char **blobs);
 156 static MonoObject *mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob);
 157
 158
 159 static void
 160 alloc_table (MonoDynamicTable *table, guint nrows)
 161 {
 162         table->rows = nrows;
 163         g_assert (table->columns);
 164         if (nrows + 1 >= table->alloc_rows) {
 165                 while (nrows + 1 >= table->alloc_rows) {
 166                         if (table->alloc_rows == 0)
 167                                 table->alloc_rows = 16;
 168                         else
 169                                 table->alloc_rows *= 2;
 170                 }
 171
 172                 if (table->values)
 173                         table->values = REALLOC_ATOMIC (table->values, (table->alloc_rows) * table->columns * sizeof (guint32));
 174                 else
 175                         table->values = ALLOC_ATOMIC ((table->alloc_rows) * table->columns * sizeof (guint32));
 176         }
 177 }
 178
 179 static void
 180 make_room_in_stream (MonoDynamicStream *stream, int size)
 181 {
 182         while (stream->alloc_size <= size) {
 183                 if (stream->alloc_size < 4096)
 184                         stream->alloc_size = 4096;
 185                 else
 186                         stream->alloc_size *= 2;
 187         }
 188         if (stream->data)
 189                 stream->data = REALLOC_ATOMIC (stream->data, stream->alloc_size);
 190         else
 191                 stream->data = ALLOC_ATOMIC (stream->alloc_size);
 192 }
 193
 194 static guint32
 195 string_heap_insert (MonoDynamicStream *sh, const char *str)
 196 {
 197         guint32 idx;
 198         guint32 len;
 199         gpointer oldkey, oldval;
 200
 201         if (g_hash_table_lookup_extended (sh->hash, str, &oldkey, &oldval))
 202                 return GPOINTER_TO_UINT (oldval);
 203
 204         len = strlen (str) + 1;
 205         idx = sh->index;
 206         if (idx + len > sh->alloc_size)
 207                 make_room_in_stream (sh, idx + len);
 208
 209         /*
 210          * We strdup the string even if we already copy them in sh->data
 211          * so that the string pointers in the hash remain valid even if
 212          * we need to realloc sh->data. We may want to avoid that later.
 213          */
 214         g_hash_table_insert (sh->hash, g_strdup (str), GUINT_TO_POINTER (idx));
 215         memcpy (sh->data + idx, str, len);
 216         sh->index += len;
 217         return idx;
 218 }
 219
 220 static void
 221 string_heap_init (MonoDynamicStream *sh)
 222 {
 223         sh->index = 0;
 224         sh->alloc_size = 4096;
 225         sh->data = ALLOC_ATOMIC (4096);
 226         sh->hash = g_hash_table_new (g_str_hash, g_str_equal);
 227         string_heap_insert (sh, "");
 228 }
 229
 230 #if 0 /* never used */
 231 static void
 232 string_heap_free (MonoDynamicStream *sh)
 233 {
 234         FREE_ATOMIC (sh->data);
 235         g_hash_table_foreach (sh->hash, (GHFunc)g_free, NULL);
 236         g_hash_table_destroy (sh->hash);
 237 }
 238 #endif
 239
 240 static guint32
 241 mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
 242 {
 243         guint32 idx;
 244         if (stream->alloc_size < stream->index + len)
 245                 make_room_in_stream (stream, stream->index + len);
 246         memcpy (stream->data + stream->index, data, len);
 247         idx = stream->index;
 248         stream->index += len;
 249         /*
 250          * align index? Not without adding an additional param that controls it since
 251          * we may store a blob value in pieces.
 252          */
 253         return idx;
 254 }
 255
 256 static guint32
 257 mono_image_add_stream_zero (MonoDynamicStream *stream, guint32 len)
 258 {
 259         guint32 idx;
 260         if (stream->alloc_size < stream->index + len)
 261                 make_room_in_stream (stream, stream->index + len);
 262         memset (stream->data + stream->index, 0, len);
 263         idx = stream->index;
 264         stream->index += len;
 265         return idx;
 266 }
 267
 268 static void
 269 stream_data_align (MonoDynamicStream *stream)
 270 {
 271         char buf [4] = {0};
 272         guint32 count = stream->index % 4;
 273
 274         /* we assume the stream data will be aligned */
 275         if (count)
 276                 mono_image_add_stream_data (stream, buf, 4 - count);
 277 }
 278
 279 static int
 280 mono_blob_entry_hash (const char* str)
 281 {
 282         guint len, h;
 283         const char *end;
 284         len = mono_metadata_decode_blob_size (str, &str);
 285         if (len > 0) {
 286                 end = str + len;
 287                 h = *str;
 288                 for (str += 1; str < end; str++)
 289                         h = (h << 5) - h + *str;
 290                 return h;
 291         } else {
 292                 return 0;
 293         }
 294 }
 295
 296 static gboolean
 297 mono_blob_entry_equal (const char *str1, const char *str2) {
 298         int len, len2;
 299         const char *end1;
 300         const char *end2;
 301         len = mono_metadata_decode_blob_size (str1, &end1);
 302         len2 = mono_metadata_decode_blob_size (str2, &end2);
 303         if (len != len2)
 304                 return 0;
 305         return memcmp (end1, end2, len) == 0;
 306 }
 307
 308 static guint32
 309 add_to_blob_cached (MonoDynamicImage *assembly, char *b1, int s1, char *b2, int s2)
 310 {
 311         guint32 idx;
 312         char *copy;
 313         gpointer oldkey, oldval;
 314
 315         copy = ALLOC_ATOMIC (s1+s2);
 316         memcpy (copy, b1, s1);
 317         memcpy (copy + s1, b2, s2);
 318         if (mono_g_hash_table_lookup_extended (assembly->blob_cache, copy, &oldkey, &oldval)) {
 319                 FREE_ATOMIC (copy);
 320                 idx = GPOINTER_TO_UINT (oldval);
 321         } else {
 322                 idx = mono_image_add_stream_data (&assembly->blob, b1, s1);
 323                 mono_image_add_stream_data (&assembly->blob, b2, s2);
 324                 mono_g_hash_table_insert (assembly->blob_cache, copy, GUINT_TO_POINTER (idx));
 325         }
 326         return idx;
 327 }
 328
 329 /*
 330  * Copy len * nelem bytes from val to dest, swapping bytes to LE if necessary.
 331  * dest may be misaligned.
 332  */
 333 static void
 334 swap_with_size (char *dest, const char* val, int len, int nelem) {
 335 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 336         int elem;
 337
 338         for (elem = 0; elem < nelem; ++elem) {
 339                 switch (len) {
 340                 case 1:
 341                         *dest = *val;
 342                         break;
 343                 case 2:
 344                         dest [0] = val [1];
 345                         dest [1] = val [0];
 346                         break;
 347                 case 4:
 348                         dest [0] = val [3];
 349                         dest [1] = val [2];
 350                         dest [2] = val [1];
 351                         dest [3] = val [0];
 352                         break;
 353                 case 8:
 354                         dest [0] = val [7];
 355                         dest [1] = val [6];
 356                         dest [2] = val [5];
 357                         dest [3] = val [4];
 358                         dest [4] = val [3];
 359                         dest [5] = val [2];
 360                         dest [6] = val [1];
 361                         dest [7] = val [0];
 362                         break;
 363                 default:
 364                         g_assert_not_reached ();
 365                 }
 366                 dest += len;
 367                 val += len;
 368         }
 369 #else
 370         memcpy (dest, val, len * nelem);
 371 #endif
 372 }
 373
 374 static guint32
 375 add_mono_string_to_blob_cached (MonoDynamicImage *assembly, MonoString *str)
 376 {
 377         char blob_size [64];
 378         char *b = blob_size;
 379         guint32 idx = 0, len;
 380
 381         len = str->length * 2;
 382         mono_metadata_encode_value (len, b, &b);
 383 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 384         {
 385                 char *swapped = g_malloc (2 * mono_string_length (str));
 386                 const char *p = (const char*)mono_string_chars (str);
 387
 388                 swap_with_size (swapped, p, 2, mono_string_length (str));
 389                 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, swapped, len);
 390                 g_free (swapped);
 391         }
 392 #else
 393         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, (char*)mono_string_chars (str), len);
 394 #endif
 395         return idx;
 396 }
 397
 398 /* modified version needed to handle building corlib */
 399 static MonoClass*
 400 my_mono_class_from_mono_type (MonoType *type) {
 401         switch (type->type) {
 402         case MONO_TYPE_ARRAY:
 403         case MONO_TYPE_PTR:
 404         case MONO_TYPE_SZARRAY:
 405         case MONO_TYPE_GENERICINST:
 406                 return mono_class_from_mono_type (type);
 407         case MONO_TYPE_VAR:
 408         case MONO_TYPE_MVAR:
 409                 g_assert (type->data.generic_param->pklass);
 410                 return type->data.generic_param->pklass;
 411         default:
 412                 /* should be always valid when we reach this case... */
 413                 return type->data.klass;
 414         }
 415 }
 416
 417 static MonoClass *
 418 default_class_from_mono_type (MonoType *type)
 419 {
 420         switch (type->type) {
 421         case MONO_TYPE_OBJECT:
 422                 return mono_defaults.object_class;
 423         case MONO_TYPE_VOID:
 424                 return mono_defaults.void_class;
 425         case MONO_TYPE_BOOLEAN:
 426                 return mono_defaults.boolean_class;
 427         case MONO_TYPE_CHAR:
 428                 return mono_defaults.char_class;
 429         case MONO_TYPE_I1:
 430                 return mono_defaults.sbyte_class;
 431         case MONO_TYPE_U1:
 432                 return mono_defaults.byte_class;
 433         case MONO_TYPE_I2:
 434                 return mono_defaults.int16_class;
 435         case MONO_TYPE_U2:
 436                 return mono_defaults.uint16_class;
 437         case MONO_TYPE_I4:
 438                 return mono_defaults.int32_class;
 439         case MONO_TYPE_U4:
 440                 return mono_defaults.uint32_class;
 441         case MONO_TYPE_I:
 442                 return mono_defaults.int_class;
 443         case MONO_TYPE_U:
 444                 return mono_defaults.uint_class;
 445         case MONO_TYPE_I8:
 446                 return mono_defaults.int64_class;
 447         case MONO_TYPE_U8:
 448                 return mono_defaults.uint64_class;
 449         case MONO_TYPE_R4:
 450                 return mono_defaults.single_class;
 451         case MONO_TYPE_R8:
 452                 return mono_defaults.double_class;
 453         case MONO_TYPE_STRING:
 454                 return mono_defaults.string_class;
 455         default:
 456                 g_warning ("implement me 0x%02x\n", type->type);
 457                 g_assert_not_reached ();
 458         }
 459
 460         return NULL;
 461 }
 462
 463 static void
 464 encode_generic_inst (MonoDynamicImage *assembly, MonoGenericInst *ginst, char *p, char **endbuf)
 465 {
 466         int i;
 467
 468         if (!ginst) {
 469                 g_assert_not_reached ();
 470                 return;
 471         }
 472
 473         mono_metadata_encode_value (MONO_TYPE_GENERICINST, p, &p);
 474         encode_type (assembly, ginst->generic_type, p, &p);
 475         mono_metadata_encode_value (ginst->type_argc, p, &p);
 476         for (i = 0; i < ginst->type_argc; ++i)
 477                 encode_type (assembly, ginst->type_argv [i], p, &p);
 478
 479         *endbuf = p;
 480 }
 481
 482 static void
 483 encode_type (MonoDynamicImage *assembly, MonoType *type, char *p, char **endbuf)
 484 {
 485         if (!type) {
 486                 g_assert_not_reached ();
 487                 return;
 488         }
 489
 490         if (type->byref)
 491                 mono_metadata_encode_value (MONO_TYPE_BYREF, p, &p);
 492
 493         switch (type->type){
 494         case MONO_TYPE_VOID:
 495         case MONO_TYPE_BOOLEAN:
 496         case MONO_TYPE_CHAR:
 497         case MONO_TYPE_I1:
 498         case MONO_TYPE_U1:
 499         case MONO_TYPE_I2:
 500         case MONO_TYPE_U2:
 501         case MONO_TYPE_I4:
 502         case MONO_TYPE_U4:
 503         case MONO_TYPE_I8:
 504         case MONO_TYPE_U8:
 505         case MONO_TYPE_R4:
 506         case MONO_TYPE_R8:
 507         case MONO_TYPE_I:
 508         case MONO_TYPE_U:
 509         case MONO_TYPE_STRING:
 510         case MONO_TYPE_OBJECT:
 511         case MONO_TYPE_TYPEDBYREF:
 512                 mono_metadata_encode_value (type->type, p, &p);
 513                 break;
 514         case MONO_TYPE_PTR:
 515                 mono_metadata_encode_value (type->type, p, &p);
 516                 encode_type (assembly, type->data.type, p, &p);
 517                 break;
 518         case MONO_TYPE_SZARRAY:
 519                 mono_metadata_encode_value (type->type, p, &p);
 520                 encode_type (assembly, &type->data.klass->byval_arg, p, &p);
 521                 break;
 522         case MONO_TYPE_VALUETYPE:
 523         case MONO_TYPE_CLASS: {
 524                 MonoClass *k = mono_class_from_mono_type (type);
 525                 mono_metadata_encode_value (type->type, p, &p);
 526                 /*
 527                  * ensure only non-byref gets passed to mono_image_typedef_or_ref(),
 528                  * otherwise two typerefs could point to the same type, leading to
 529                  * verification errors.
 530                  */
 531                 mono_metadata_encode_value (mono_image_typedef_or_ref (assembly, &k->byval_arg), p, &p);
 532                 break;
 533         }
 534         case MONO_TYPE_ARRAY:
 535                 mono_metadata_encode_value (type->type, p, &p);
 536                 encode_type (assembly, &type->data.array->eklass->byval_arg, p, &p);
 537                 mono_metadata_encode_value (type->data.array->rank, p, &p);
 538                 mono_metadata_encode_value (0, p, &p); /* FIXME: set to 0 for now */
 539                 mono_metadata_encode_value (0, p, &p);
 540                 break;
 541         case MONO_TYPE_GENERICINST:
 542                 encode_generic_inst (assembly, type->data.generic_inst, p, &p);
 543                 break;
 544         case MONO_TYPE_VAR:
 545         case MONO_TYPE_MVAR:
 546                 mono_metadata_encode_value (type->type, p, &p);
 547                 mono_metadata_encode_value (type->data.generic_param->num, p, &p);
 548                 break;
 549         default:
 550                 g_error ("need to encode type %x", type->type);
 551         }
 552         *endbuf = p;
 553 }
 554
 555 static void
 556 encode_reflection_type (MonoDynamicImage *assembly, MonoReflectionType *type, char *p, char **endbuf)
 557 {
 558         if (!type) {
 559                 mono_metadata_encode_value (MONO_TYPE_VOID, p, endbuf);
 560                 return;
 561         }
 562         if (type->type) {
 563                 encode_type (assembly, type->type, p, endbuf);
 564                 return;
 565         }
 566
 567         g_assert_not_reached ();
 568
 569 }
 570
 571 static void
 572 encode_custom_modifiers (MonoDynamicImage *assembly, MonoArray *modreq, MonoArray *modopt, char *p, char **endbuf)
 573 {
 574         int i;
 575
 576         if (modreq) {
 577                 for (i = 0; i < mono_array_length (modreq); ++i) {
 578                         MonoReflectionType *mod = mono_array_get (modreq, MonoReflectionType*, i);
 579                         *p = MONO_TYPE_CMOD_REQD;
 580                         p++;
 581                         mono_metadata_encode_value (mono_image_typedef_or_ref (assembly, mod->type), p, &p);
 582                 }
 583         }
 584         if (modopt) {
 585                 for (i = 0; i < mono_array_length (modopt); ++i) {
 586                         MonoReflectionType *mod = mono_array_get (modopt, MonoReflectionType*, i);
 587                         *p = MONO_TYPE_CMOD_OPT;
 588                         p++;
 589                         mono_metadata_encode_value (mono_image_typedef_or_ref (assembly, mod->type), p, &p);
 590                 }
 591         }
 592         *endbuf = p;
 593 }
 594
 595 static guint32
 596 generic_inst_get_signature_size (MonoGenericInst *ginst)
 597 {
 598         guint32 size = 0;
 599         int i;
 600
 601         if (!ginst) {
 602                 g_assert_not_reached ();
 603         }
 604
 605         size += 1 + type_get_signature_size (ginst->generic_type);
 606         size += 4;
 607         for (i = 0; i < ginst->type_argc; ++i)
 608                 size += type_get_signature_size (ginst->type_argv [i]);
 609
 610         return size;
 611 }
 612
 613 static guint32
 614 type_get_signature_size (MonoType *type)
 615 {
 616         guint32 size = 0;
 617
 618         if (!type) {
 619                 g_assert_not_reached ();
 620         }
 621
 622         if (type->byref)
 623                 size++;
 624
 625         switch (type->type){
 626         case MONO_TYPE_VOID:
 627         case MONO_TYPE_BOOLEAN:
 628         case MONO_TYPE_CHAR:
 629         case MONO_TYPE_I1:
 630         case MONO_TYPE_U1:
 631         case MONO_TYPE_I2:
 632         case MONO_TYPE_U2:
 633         case MONO_TYPE_I4:
 634         case MONO_TYPE_U4:
 635         case MONO_TYPE_I8:
 636         case MONO_TYPE_U8:
 637         case MONO_TYPE_R4:
 638         case MONO_TYPE_R8:
 639         case MONO_TYPE_I:
 640         case MONO_TYPE_U:
 641         case MONO_TYPE_STRING:
 642         case MONO_TYPE_OBJECT:
 643         case MONO_TYPE_TYPEDBYREF:
 644                 return size + 1;
 645         case MONO_TYPE_PTR:
 646                 return size + 1 + type_get_signature_size (type->data.type);
 647         case MONO_TYPE_SZARRAY:
 648                 return size + 1 + type_get_signature_size (&type->data.klass->byval_arg);
 649         case MONO_TYPE_VALUETYPE:
 650         case MONO_TYPE_CLASS:
 651                 return size + 5;
 652         case MONO_TYPE_ARRAY:
 653                 return size + 7 + type_get_signature_size (&type->data.array->eklass->byval_arg);
 654         case MONO_TYPE_GENERICINST:
 655                 return size + generic_inst_get_signature_size (type->data.generic_inst);
 656         case MONO_TYPE_VAR:
 657         case MONO_TYPE_MVAR:
 658                 return size + 5;
 659         default:
 660                 g_error ("need to encode type %x", type->type);
 661                 return size;
 662         }
 663 }
 664
 665 static guint32
 666 method_get_signature_size (MonoMethodSignature *sig)
 667 {
 668         guint32 size;
 669         int i;
 670
 671         size = type_get_signature_size (sig->ret);
 672         for (i = 0; i < sig->param_count; i++)
 673                 size += type_get_signature_size (sig->params [i]);
 674
 675         if (sig->generic_param_count)
 676                 size += 4;
 677         if (sig->sentinelpos >= 0)
 678                 size++;
 679
 680         return size;
 681 }
 682
 683 static guint32
 684 method_encode_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig)
 685 {
 686         char *buf;
 687         char *p;
 688         int i;
 689         guint32 nparams =  sig->param_count;
 690         guint32 size = 11 + method_get_signature_size (sig);
 691         guint32 idx;
 692         char blob_size [6];
 693         char *b = blob_size;
 694
 695         if (!assembly->save)
 696                 return 0;
 697
 698         p = buf = g_malloc (size);
 699         /*
 700          * FIXME: vararg, explicit_this, differenc call_conv values...
 701          */
 702         *p = sig->call_convention;
 703         if (sig->hasthis)
 704                 *p |= 0x20; /* hasthis */
 705         if (sig->generic_param_count)
 706                 *p |= 0x10; /* generic */
 707         p++;
 708         if (sig->generic_param_count)
 709                 mono_metadata_encode_value (sig->generic_param_count, p, &p);
 710         mono_metadata_encode_value (nparams, p, &p);
 711         encode_type (assembly, sig->ret, p, &p);
 712         for (i = 0; i < nparams; ++i) {
 713                 if (i == sig->sentinelpos)
 714                         *p++ = MONO_TYPE_SENTINEL;
 715                 encode_type (assembly, sig->params [i], p, &p);
 716         }
 717         /* store length */
 718         g_assert (p - buf < size);
 719         mono_metadata_encode_value (p-buf, b, &b);
 720         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, p-buf);
 721         g_free (buf);
 722         return idx;
 723 }
 724
 725 static guint32
 726 method_builder_encode_signature (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
 727 {
 728         /*
 729          * FIXME: reuse code from method_encode_signature().
 730          */
 731         char *buf;
 732         char *p;
 733         int i;
 734         guint32 nparams =  mb->parameters ? mono_array_length (mb->parameters): 0;
 735         guint32 ngparams = mb->generic_params ? mono_array_length (mb->generic_params): 0;
 736         guint32 notypes = mb->opt_types ? mono_array_length (mb->opt_types): 0;
 737         guint32 size = 21 + nparams * 20 + notypes * 20;
 738         guint32 idx;
 739         char blob_size [6];
 740         char *b = blob_size;
 741
 742         p = buf = g_malloc (size);
 743         /* LAMESPEC: all the call conv spec is foobared */
 744         *p = mb->call_conv & 0x60; /* has-this, explicit-this */
 745         if (mb->call_conv & 2)
 746                 *p |= 0x5; /* vararg */
 747         if (!(mb->attrs & METHOD_ATTRIBUTE_STATIC))
 748                 *p |= 0x20; /* hasthis */
 749         if (ngparams)
 750                 *p |= 0x10; /* generic */
 751         p++;
 752         if (ngparams)
 753                 mono_metadata_encode_value (ngparams, p, &p);
 754         mono_metadata_encode_value (nparams + notypes, p, &p);
 755         encode_custom_modifiers (assembly, mb->return_modreq, mb->return_modopt, p, &p);
 756         encode_reflection_type (assembly, mb->rtype, p, &p);
 757         for (i = 0; i < nparams; ++i) {
 758                 MonoArray *modreq = NULL;
 759                 MonoArray *modopt = NULL;
 760                 MonoReflectionType *pt;
 761
 762                 if (mb->param_modreq && (i < mono_array_length (mb->param_modreq)))
 763                         modreq = mono_array_get (mb->param_modreq, MonoArray*, i);
 764                 if (mb->param_modopt && (i < mono_array_length (mb->param_modopt)))
 765                         modopt = mono_array_get (mb->param_modopt, MonoArray*, i);
 766                 encode_custom_modifiers (assembly, modreq, modopt, p, &p);
 767                 pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
 768                 encode_reflection_type (assembly, pt, p, &p);
 769         }
 770         if (notypes)
 771                 *p++ = MONO_TYPE_SENTINEL;
 772         for (i = 0; i < notypes; ++i) {
 773                 MonoReflectionType *pt;
 774
 775                 pt = mono_array_get (mb->opt_types, MonoReflectionType*, i);
 776                 encode_reflection_type (assembly, pt, p, &p);
 777         }
 778
 779         /* store length */
 780         g_assert (p - buf < size);
 781         mono_metadata_encode_value (p-buf, b, &b);
 782         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, p-buf);
 783         g_free (buf);
 784         return idx;
 785 }
 786
 787 static guint32
 788 encode_locals (MonoDynamicImage *assembly, MonoReflectionILGen *ilgen)
 789 {
 790         MonoDynamicTable *table;
 791         guint32 *values;
 792         char *p;
 793         guint32 idx, sig_idx, size;
 794         guint nl = mono_array_length (ilgen->locals);
 795         char *buf;
 796         char blob_size [6];
 797         char *b = blob_size;
 798         int i;
 799
 800         size = 10 + nl * 10;
 801         p = buf = g_malloc (size);
 802         table = &assembly->tables [MONO_TABLE_STANDALONESIG];
 803         idx = table->next_idx ++;
 804         table->rows ++;
 805         alloc_table (table, table->rows);
 806         values = table->values + idx * MONO_STAND_ALONE_SIGNATURE_SIZE;
 807
 808         mono_metadata_encode_value (0x07, p, &p);
 809         mono_metadata_encode_value (nl, p, &p);
 810         for (i = 0; i < nl; ++i) {
 811                 MonoReflectionLocalBuilder *lb = mono_array_get (ilgen->locals, MonoReflectionLocalBuilder*, i);
 812
 813                 if (lb->is_pinned)
 814                         mono_metadata_encode_value (MONO_TYPE_PINNED, p, &p);
 815
 816                 encode_reflection_type (assembly, lb->type, p, &p);
 817         }
 818         g_assert (p - buf < size);
 819         mono_metadata_encode_value (p-buf, b, &b);
 820         sig_idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, p-buf);
 821         g_free (buf);
 822
 823         values [MONO_STAND_ALONE_SIGNATURE] = sig_idx;
 824
 825         return idx;
 826 }
 827
 828 static guint32
 829 method_count_clauses (MonoReflectionILGen *ilgen)
 830 {
 831         guint32 num_clauses = 0;
 832         int i;
 833
 834         MonoILExceptionInfo *ex_info;
 835         for (i = 0; i < mono_array_length (ilgen->ex_handlers); ++i) {
 836                 ex_info = (MonoILExceptionInfo*)mono_array_addr (ilgen->ex_handlers, MonoILExceptionInfo, i);
 837                 if (ex_info->handlers)
 838                         num_clauses += mono_array_length (ex_info->handlers);
 839                 else
 840                         num_clauses++;
 841         }
 842
 843         return num_clauses;
 844 }
 845
 846 static MonoExceptionClause*
 847 method_encode_clauses (MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, guint32 num_clauses)
 848 {
 849         MonoExceptionClause *clauses;
 850         MonoExceptionClause *clause;
 851         MonoILExceptionInfo *ex_info;
 852         MonoILExceptionBlock *ex_block;
 853         guint32 finally_start;
 854         int i, j, clause_index;;
 855
 856         clauses = g_new0 (MonoExceptionClause, num_clauses);
 857
 858         clause_index = 0;
 859         for (i = mono_array_length (ilgen->ex_handlers) - 1; i >= 0; --i) {
 860                 ex_info = (MonoILExceptionInfo*)mono_array_addr (ilgen->ex_handlers, MonoILExceptionInfo, i);
 861                 finally_start = ex_info->start + ex_info->len;
 862                 g_assert (ex_info->handlers);
 863                 for (j = 0; j < mono_array_length (ex_info->handlers); ++j) {
 864                         ex_block = (MonoILExceptionBlock*)mono_array_addr (ex_info->handlers, MonoILExceptionBlock, j);
 865                         clause = &(clauses [clause_index]);
 866
 867                         clause->flags = ex_block->type;
 868                         clause->try_offset = ex_info->start;
 869
 870                         if (ex_block->type == MONO_EXCEPTION_CLAUSE_FINALLY)
 871                                 clause->try_len = finally_start - ex_info->start;
 872                         else
 873                                 clause->try_len = ex_info->len;
 874                         clause->handler_offset = ex_block->start;
 875                         clause->handler_len = ex_block->len;
 876                         clause->token_or_filter = ex_block->extype ? mono_metadata_token_from_dor (
 877                                 mono_image_typedef_or_ref (assembly, ex_block->extype->type)): 0;
 878                         if (ex_block->extype) {
 879                                 mono_g_hash_table_insert (assembly->tokens,
 880                                           GUINT_TO_POINTER (clause->token_or_filter), ex_block->extype);
 881                         }
 882                         finally_start = ex_block->start + ex_block->len;
 883
 884                         clause_index ++;
 885                 }
 886         }
 887
 888         return clauses;
 889 }
 890
 891 static guint32
 892 method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb)
 893 {
 894         char flags = 0;
 895         guint32 idx;
 896         guint32 code_size;
 897         gint32 max_stack, i;
 898         gint32 num_locals = 0;
 899         gint32 num_exception = 0;
 900         gint maybe_small;
 901         guint32 fat_flags;
 902         char fat_header [12];
 903         guint32 *intp;
 904         guint16 *shortp;
 905         guint32 local_sig = 0;
 906         guint32 header_size = 12;
 907         MonoArray *code;
 908
 909         if ((mb->attrs & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT)) ||
 910                         (mb->iattrs & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)))
 911                 return 0;
 912
 913         /*if (mb->name)
 914                 g_print ("Encode method %s\n", mono_string_to_utf8 (mb->name));*/
 915         if (mb->ilgen) {
 916                 code = mb->ilgen->code;
 917                 code_size = mb->ilgen->code_len;
 918                 max_stack = mb->ilgen->max_stack;
 919                 num_locals = mb->ilgen->locals ? mono_array_length (mb->ilgen->locals) : 0;
 920                 if (mb->ilgen->ex_handlers)
 921                         num_exception = method_count_clauses (mb->ilgen);
 922         } else {
 923                 code = mb->code;
 924                 if (code == NULL){
 925                         char *name = mono_string_to_utf8 (mb->name);
 926                         char *str = g_strdup_printf ("Method %s does not have any IL associated", name);
 927                         MonoException *exception = mono_get_exception_argument (NULL, "a method does not have any IL associated");
 928                         g_free (str);
 929                         g_free (name);
 930                         mono_raise_exception (exception);
 931                 }
 932
 933                 code_size = mono_array_length (code);
 934                 max_stack = 8; /* we probably need to run a verifier on the code... */
 935         }
 936
 937         stream_data_align (&assembly->code);
 938
 939         /* check for exceptions, maxstack, locals */
 940         maybe_small = (max_stack <= 8) && (!num_locals) && (!num_exception);
 941         if (maybe_small) {
 942                 if (code_size < 64 && !(code_size & 1)) {
 943                         flags = (code_size << 2) | 0x2;
 944                 } else if (code_size < 32 && (code_size & 1)) {
 945                         flags = (code_size << 2) | 0x6; /* LAMESPEC: see metadata.c */
 946                 } else {
 947                         goto fat_header;
 948                 }
 949                 idx = mono_image_add_stream_data (&assembly->code, &flags, 1);
 950                 /* add to the fixup todo list */
 951                 if (mb->ilgen && mb->ilgen->num_token_fixups)
 952                         mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 1));
 953                 mono_image_add_stream_data (&assembly->code, mono_array_addr (code, char, 0), code_size);
 954                 return assembly->text_rva + idx;
 955         }
 956 fat_header:
 957         if (num_locals)
 958                 local_sig = MONO_TOKEN_SIGNATURE | encode_locals (assembly, mb->ilgen);
 959         /*
 960          * FIXME: need to set also the header size in fat_flags.
 961          * (and more sects and init locals flags)
 962          */
 963         fat_flags =  0x03;
 964         if (num_exception)
 965                 fat_flags |= METHOD_HEADER_MORE_SECTS;
 966         if (mb->init_locals)
 967                 fat_flags |= METHOD_HEADER_INIT_LOCALS;
 968         fat_header [0] = fat_flags;
 969         fat_header [1] = (header_size / 4 ) << 4;
 970         shortp = (guint16*)(fat_header + 2);
 971         *shortp = GUINT16_TO_LE (max_stack);
 972         intp = (guint32*)(fat_header + 4);
 973         *intp = GUINT32_TO_LE (code_size);
 974         intp = (guint32*)(fat_header + 8);
 975         *intp = GUINT32_TO_LE (local_sig);
 976         idx = mono_image_add_stream_data (&assembly->code, fat_header, 12);
 977         /* add to the fixup todo list */
 978         if (mb->ilgen && mb->ilgen->num_token_fixups)
 979                 mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 12));
 980
 981         mono_image_add_stream_data (&assembly->code, mono_array_addr (code, char, 0), code_size);
 982         if (num_exception) {
 983                 unsigned char sheader [4];
 984                 MonoExceptionClause clause;
 985                 MonoILExceptionInfo * ex_info;
 986                 MonoILExceptionBlock * ex_block;
 987                 int j;
 988
 989                 stream_data_align (&assembly->code);
 990                 /* always use fat format for now */
 991                 sheader [0] = METHOD_HEADER_SECTION_FAT_FORMAT | METHOD_HEADER_SECTION_EHTABLE;
 992                 num_exception *= sizeof (MonoExceptionClause);
 993                 num_exception += 4; /* include the size of the header */
 994                 sheader [1] = num_exception & 0xff;
 995                 sheader [2] = (num_exception >> 8) & 0xff;
 996                 sheader [3] = (num_exception >> 16) & 0xff;
 997                 mono_image_add_stream_data (&assembly->code, sheader, 4);
 998                 /* fat header, so we are already aligned */
 999                 /* reverse order */
1000                 for (i = mono_array_length (mb->ilgen->ex_handlers) - 1; i >= 0; --i) {
1001                         ex_info = (MonoILExceptionInfo *)mono_array_addr (mb->ilgen->ex_handlers, MonoILExceptionInfo, i);
1002                         if (ex_info->handlers) {
1003                                 int finally_start = ex_info->start + ex_info->len;
1004                                 for (j = 0; j < mono_array_length (ex_info->handlers); ++j) {
1005                                         ex_block = (MonoILExceptionBlock*)mono_array_addr (ex_info->handlers, MonoILExceptionBlock, j);
1006                                         clause.flags = GUINT32_TO_LE (ex_block->type);
1007                                         clause.try_offset = GUINT32_TO_LE (ex_info->start);
1008                                         /* need fault, too, probably */
1009                                         if (ex_block->type == MONO_EXCEPTION_CLAUSE_FINALLY)
1010                                                 clause.try_len = GUINT32_TO_LE (finally_start - ex_info->start);
1011                                         else
1012                                                 clause.try_len = GUINT32_TO_LE (ex_info->len);
1013                                         clause.handler_offset = GUINT32_TO_LE (ex_block->start);
1014                                         clause.handler_len = GUINT32_TO_LE (ex_block->len);
1015                                         finally_start = ex_block->start + ex_block->len;
1016                                         clause.token_or_filter = ex_block->extype ? mono_metadata_token_from_dor (
1017                                                         mono_image_typedef_or_ref (assembly, ex_block->extype->type)): 0;
1018                                         clause.token_or_filter = GUINT32_TO_LE (clause.token_or_filter);
1019                                         /*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",
1020                                                         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);*/
1021                                         mono_image_add_stream_data (&assembly->code, (char*)&clause, sizeof (clause));
1022                                 }
1023                         } else {
1024                                 g_error ("No clauses for ex info block %d", i);
1025                         }
1026                 }
1027         }
1028         return assembly->text_rva + idx;
1029 }
1030
1031 static guint32
1032 find_index_in_table (MonoDynamicImage *assembly, int table_idx, int col, guint32 token)
1033 {
1034         int i;
1035         MonoDynamicTable *table;
1036         guint32 *values;
1037
1038         table = &assembly->tables [table_idx];
1039
1040         g_assert (col < table->columns);
1041
1042         values = table->values + table->columns;
1043         for (i = 1; i <= table->rows; ++i) {
1044                 if (values [col] == token)
1045                         return i;
1046                 values += table->columns;
1047         }
1048         return 0;
1049 }
1050
1051 static GHashTable *dynamic_custom_attrs = NULL;
1052
1053 static MonoCustomAttrInfo*
1054 mono_custom_attrs_from_builders (MonoImage *image, MonoArray *cattrs)
1055 {
1056         int i, count;
1057         MonoCustomAttrInfo *ainfo;
1058         MonoReflectionCustomAttr *cattr;
1059
1060         if (!cattrs)
1061                 return NULL;
1062         /* FIXME: check in assembly the Run flag is set */
1063
1064         count = mono_array_length (cattrs);
1065
1066         ainfo = g_malloc0 (sizeof (MonoCustomAttrInfo) + sizeof (MonoCustomAttrEntry) * (count - MONO_ZERO_LEN_ARRAY));
1067
1068         ainfo->image = image;
1069         ainfo->num_attrs = count;
1070         for (i = 0; i < count; ++i) {
1071                 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
1072                 ainfo->attrs [i].ctor = cattr->ctor->method;
1073                 /* FIXME: might want to memdup the data here */
1074                 ainfo->attrs [i].data = mono_array_addr (cattr->data, char, 0);
1075                 ainfo->attrs [i].data_size = mono_array_length (cattr->data);
1076         }
1077
1078         return ainfo;
1079 }
1080
1081 static void
1082 mono_save_custom_attrs (MonoImage *image, void *obj, MonoArray *cattrs)
1083 {
1084         MonoCustomAttrInfo *ainfo = mono_custom_attrs_from_builders (image, cattrs);
1085
1086         if (!ainfo)
1087                 return;
1088
1089         if (!dynamic_custom_attrs)
1090                 dynamic_custom_attrs = g_hash_table_new (NULL, NULL);
1091
1092         g_hash_table_insert (dynamic_custom_attrs, obj, ainfo);
1093         ainfo->cached = TRUE;
1094 }
1095
1096 void
1097 mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
1098 {
1099         /* they are cached, so we don't free them */
1100         if (dynamic_custom_attrs && g_hash_table_lookup (dynamic_custom_attrs, ainfo))
1101                 return;
1102         g_free (ainfo);
1103 }
1104
1105 /*
1106  * idx is the table index of the object
1107  * type is one of MONO_CUSTOM_ATTR_*
1108  */
1109 static void
1110 mono_image_add_cattrs (MonoDynamicImage *assembly, guint32 idx, guint32 type, MonoArray *cattrs)
1111 {
1112         MonoDynamicTable *table;
1113         MonoReflectionCustomAttr *cattr;
1114         guint32 *values;
1115         guint32 count, i, token;
1116         char blob_size [6];
1117         char *p = blob_size;
1118
1119         /* it is legal to pass a NULL cattrs: we avoid to use the if in a lot of places */
1120         if (!cattrs)
1121                 return;
1122         count = mono_array_length (cattrs);
1123         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1124         table->rows += count;
1125         alloc_table (table, table->rows);
1126         values = table->values + table->next_idx * MONO_CUSTOM_ATTR_SIZE;
1127         idx <<= MONO_CUSTOM_ATTR_BITS;
1128         idx |= type;
1129         for (i = 0; i < count; ++i) {
1130                 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
1131                 values [MONO_CUSTOM_ATTR_PARENT] = idx;
1132                 token = mono_image_create_token (assembly, (MonoObject*)cattr->ctor, FALSE);
1133                 type = mono_metadata_token_index (token);
1134                 type <<= MONO_CUSTOM_ATTR_TYPE_BITS;
1135                 switch (mono_metadata_token_table (token)) {
1136                 case MONO_TABLE_METHOD:
1137                         type |= MONO_CUSTOM_ATTR_TYPE_METHODDEF;
1138                         break;
1139                 case MONO_TABLE_MEMBERREF:
1140                         type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
1141                         break;
1142                 default:
1143                         g_warning ("got wrong token in custom attr");
1144                         continue;
1145                 }
1146                 values [MONO_CUSTOM_ATTR_TYPE] = type;
1147                 p = blob_size;
1148                 mono_metadata_encode_value (mono_array_length (cattr->data), p, &p);
1149                 values [MONO_CUSTOM_ATTR_VALUE] = add_to_blob_cached (assembly, blob_size, p - blob_size,
1150                         mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
1151                 values += MONO_CUSTOM_ATTR_SIZE;
1152                 ++table->next_idx;
1153         }
1154 }
1155
1156 static void
1157 mono_image_add_decl_security (MonoDynamicImage *assembly, guint32 parent_token, MonoArray *permissions)
1158 {
1159         MonoDynamicTable *table;
1160         guint32 *values;
1161         guint32 count, i, idx;
1162         MonoReflectionPermissionSet *perm;
1163
1164         if (!permissions)
1165                 return;
1166
1167         count = mono_array_length (permissions);
1168         table = &assembly->tables [MONO_TABLE_DECLSECURITY];
1169         table->rows += count;
1170         alloc_table (table, table->rows);
1171
1172         for (i = 0; i < mono_array_length (permissions); ++i) {
1173                 perm = (MonoReflectionPermissionSet*)mono_array_addr (permissions, MonoReflectionPermissionSet, i);
1174
1175                 values = table->values + table->next_idx * MONO_DECL_SECURITY_SIZE;
1176
1177                 idx = mono_metadata_token_index (parent_token);
1178                 idx <<= MONO_HAS_DECL_SECURITY_BITS;
1179                 switch (mono_metadata_token_table (parent_token)) {
1180                 case MONO_TABLE_TYPEDEF:
1181                         idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
1182                         break;
1183                 case MONO_TABLE_METHOD:
1184                         idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
1185                         break;
1186                 case MONO_TABLE_ASSEMBLY:
1187                         idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
1188                         break;
1189                 default:
1190                         g_assert_not_reached ();
1191                 }
1192
1193                 values [MONO_DECL_SECURITY_ACTION] = perm->action;
1194                 values [MONO_DECL_SECURITY_PARENT] = idx;
1195                 values [MONO_DECL_SECURITY_PERMISSIONSET] = add_mono_string_to_blob_cached (assembly, perm->pset);
1196
1197                 ++table->next_idx;
1198         }
1199 }
1200
1201 /*
1202  * Fill in the MethodDef and ParamDef tables for a method.
1203  * This is used for both normal methods and constructors.
1204  */
1205 static void
1206 mono_image_basic_method (ReflectionMethodBuilder *mb, MonoDynamicImage *assembly)
1207 {
1208         MonoDynamicTable *table;
1209         guint32 *values;
1210         char *name;
1211         guint i, count;
1212
1213         /* room in this table is already allocated */
1214         table = &assembly->tables [MONO_TABLE_METHOD];
1215         *mb->table_idx = table->next_idx ++;
1216         mono_g_hash_table_insert (assembly->method_to_table_idx, mb->mhandle, GUINT_TO_POINTER ((*mb->table_idx)));
1217         values = table->values + *mb->table_idx * MONO_METHOD_SIZE;
1218         name = mono_string_to_utf8 (mb->name);
1219         values [MONO_METHOD_NAME] = string_heap_insert (&assembly->sheap, name);
1220         g_free (name);
1221         values [MONO_METHOD_FLAGS] = mb->attrs;
1222         values [MONO_METHOD_IMPLFLAGS] = mb->iattrs;
1223         values [MONO_METHOD_SIGNATURE] = method_builder_encode_signature (assembly, mb);
1224         values [MONO_METHOD_RVA] = method_encode_code (assembly, mb);
1225
1226         table = &assembly->tables [MONO_TABLE_PARAM];
1227         values [MONO_METHOD_PARAMLIST] = table->next_idx;
1228
1229         mono_image_add_decl_security (assembly,
1230                 mono_metadata_make_token (MONO_TABLE_METHOD, *mb->table_idx), mb->permissions);
1231
1232         if (mb->pinfo) {
1233                 MonoDynamicTable *mtable;
1234                 guint32 *mvalues;
1235
1236                 mtable = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
1237                 mvalues = mtable->values + mtable->next_idx * MONO_FIELD_MARSHAL_SIZE;
1238
1239                 count = 0;
1240                 for (i = 0; i < mono_array_length (mb->pinfo); ++i) {
1241                         if (mono_array_get (mb->pinfo, gpointer, i))
1242                                 count++;
1243                 }
1244                 table->rows += count;
1245                 alloc_table (table, table->rows);
1246                 values = table->values + table->next_idx * MONO_PARAM_SIZE;
1247                 for (i = 0; i < mono_array_length (mb->pinfo); ++i) {
1248                         MonoReflectionParamBuilder *pb;
1249                         if ((pb = mono_array_get (mb->pinfo, MonoReflectionParamBuilder*, i))) {
1250                                 values [MONO_PARAM_FLAGS] = pb->attrs;
1251                                 values [MONO_PARAM_SEQUENCE] = i;
1252                                 if (pb->name != NULL) {
1253                                         name = mono_string_to_utf8 (pb->name);
1254                                         values [MONO_PARAM_NAME] = string_heap_insert (&assembly->sheap, name);
1255                                         g_free (name);
1256                                 } else {
1257                                         values [MONO_PARAM_NAME] = 0;
1258                                 }
1259                                 values += MONO_PARAM_SIZE;
1260                                 if (pb->marshal_info) {
1261                                         mtable->rows++;
1262                                         alloc_table (mtable, mtable->rows);
1263                                         mvalues = mtable->values + mtable->rows * MONO_FIELD_MARSHAL_SIZE;
1264                                         mvalues [MONO_FIELD_MARSHAL_PARENT] = (table->next_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_PARAMDEF;
1265                                         mvalues [MONO_FIELD_MARSHAL_NATIVE_TYPE] = encode_marshal_blob (assembly, pb->marshal_info);
1266                                 }
1267                                 pb->table_idx = table->next_idx++;
1268                                 if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
1269                                         guint32 field_type = 0;
1270                                         mtable = &assembly->tables [MONO_TABLE_CONSTANT];
1271                                         mtable->rows ++;
1272                                         alloc_table (mtable, mtable->rows);
1273                                         mvalues = mtable->values + mtable->rows * MONO_CONSTANT_SIZE;
1274                                         mvalues [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_PARAM | (pb->table_idx << MONO_HASCONSTANT_BITS);
1275                                         mvalues [MONO_CONSTANT_VALUE] = encode_constant (assembly, pb->def_value, &field_type);
1276                                         mvalues [MONO_CONSTANT_TYPE] = field_type;
1277                                         mvalues [MONO_CONSTANT_PADDING] = 0;
1278                                 }
1279                         }
1280                 }
1281         }
1282 }
1283
1284 static void
1285 reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb)
1286 {
1287         rmb->ilgen = mb->ilgen;
1288         rmb->rtype = mb->rtype;
1289         rmb->parameters = mb->parameters;
1290         rmb->generic_params = mb->generic_params;
1291         rmb->opt_types = NULL;
1292         rmb->pinfo = mb->pinfo;
1293         rmb->attrs = mb->attrs;
1294         rmb->iattrs = mb->iattrs;
1295         rmb->call_conv = mb->call_conv;
1296         rmb->code = mb->code;
1297         rmb->type = mb->type;
1298         rmb->name = mb->name;
1299         rmb->table_idx = &mb->table_idx;
1300         rmb->init_locals = mb->init_locals;
1301         rmb->return_modreq = mb->return_modreq;
1302         rmb->return_modopt = mb->return_modopt;
1303         rmb->param_modreq = mb->param_modreq;
1304         rmb->param_modopt = mb->param_modopt;
1305         rmb->permissions = mb->permissions;
1306         rmb->mhandle = mb->mhandle;
1307         rmb->nrefs = 0;
1308         rmb->refs = NULL;
1309
1310         if (mb->dll) {
1311                 rmb->charset = rmb->charset & 0xf;
1312                 rmb->lasterr = rmb->charset & 0x40;
1313                 rmb->native_cc = rmb->native_cc;
1314                 rmb->dllentry = mb->dllentry;
1315                 rmb->dll = mb->dll;
1316         }
1317 }
1318
1319 static void
1320 reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb)
1321 {
1322         const char *name = mb->attrs & METHOD_ATTRIBUTE_STATIC ? ".cctor": ".ctor";
1323
1324         rmb->ilgen = mb->ilgen;
1325         rmb->rtype = mono_type_get_object (mono_domain_get (), &mono_defaults.void_class->byval_arg);
1326         rmb->parameters = mb->parameters;
1327         rmb->generic_params = NULL;
1328         rmb->opt_types = NULL;
1329         rmb->pinfo = mb->pinfo;
1330         rmb->attrs = mb->attrs;
1331         rmb->iattrs = mb->iattrs;
1332         rmb->call_conv = mb->call_conv;
1333         rmb->code = NULL;
1334         rmb->type = mb->type;
1335         rmb->name = mono_string_new (mono_domain_get (), name);
1336         rmb->table_idx = &mb->table_idx;
1337         rmb->init_locals = mb->init_locals;
1338         rmb->return_modreq = NULL;
1339         rmb->return_modopt = NULL;
1340         rmb->param_modreq = mb->param_modreq;
1341         rmb->param_modopt = mb->param_modopt;
1342         rmb->permissions = mb->permissions;
1343         rmb->mhandle = mb->mhandle;
1344         rmb->nrefs = 0;
1345         rmb->refs = NULL;
1346 }
1347
1348 static void
1349 reflection_methodbuilder_from_dynamic_method (ReflectionMethodBuilder *rmb, MonoReflectionDynamicMethod *mb)
1350 {
1351         rmb->ilgen = mb->ilgen;
1352         rmb->rtype = mb->rtype;
1353         rmb->parameters = mb->parameters;
1354         rmb->generic_params = NULL;
1355         rmb->opt_types = NULL;
1356         rmb->pinfo = NULL;
1357         rmb->attrs = mb->attrs;
1358         rmb->iattrs = 0;
1359         rmb->call_conv = mb->call_conv;
1360         rmb->code = NULL;
1361         rmb->type = NULL;
1362         rmb->name = mb->name;
1363         rmb->table_idx = NULL;
1364         rmb->init_locals = mb->init_locals;
1365         rmb->return_modreq = NULL;
1366         rmb->return_modopt = NULL;
1367         rmb->param_modreq = NULL;
1368         rmb->param_modopt = NULL;
1369         rmb->permissions = NULL;
1370         rmb->mhandle = mb->mhandle;
1371         rmb->nrefs = 0;
1372         rmb->refs = NULL;
1373 }
1374
1375 static void
1376 mono_image_get_method_info (MonoReflectionMethodBuilder *mb, MonoDynamicImage *assembly)
1377 {
1378         MonoDynamicTable *table;
1379         guint32 *values;
1380         char *name;
1381         ReflectionMethodBuilder rmb;
1382         int i;
1383
1384         reflection_methodbuilder_from_method_builder (&rmb, mb);
1385
1386         mono_image_basic_method (&rmb, assembly);
1387
1388         if (mb->dll) { /* It's a P/Invoke method */
1389                 guint32 moduleref;
1390                 int charset = mb->charset & 0xf;
1391                 int lasterr = mb->charset & 0x40;
1392                 table = &assembly->tables [MONO_TABLE_IMPLMAP];
1393                 table->rows ++;
1394                 alloc_table (table, table->rows);
1395                 values = table->values + table->rows * MONO_IMPLMAP_SIZE;
1396                 /* map CharSet values to on-disk values */
1397
1398                 values [MONO_IMPLMAP_FLAGS] = (mb->native_cc << 8) | (charset ? (charset - 1) * 2: 1) | lasterr;
1399                 values [MONO_IMPLMAP_MEMBER] = (mb->table_idx << 1) | 1; /* memberforwarded: method */
1400                 name = mono_string_to_utf8 (mb->dllentry);
1401                 values [MONO_IMPLMAP_NAME] = string_heap_insert (&assembly->sheap, name);
1402                 g_free (name);
1403                 name = mono_string_to_utf8 (mb->dll);
1404                 moduleref = string_heap_insert (&assembly->sheap, name);
1405                 g_free (name);
1406                 if (!(values [MONO_IMPLMAP_SCOPE] = find_index_in_table (assembly, MONO_TABLE_MODULEREF, MONO_MODULEREF_NAME, moduleref))) {
1407                         table = &assembly->tables [MONO_TABLE_MODULEREF];
1408                         table->rows ++;
1409                         alloc_table (table, table->rows);
1410                         table->values [table->rows * MONO_MODULEREF_SIZE + MONO_MODULEREF_NAME] = moduleref;
1411                         values [MONO_IMPLMAP_SCOPE] = table->rows;
1412                 }
1413         }
1414
1415         if (mb->override_method) {
1416                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mb->type;
1417                 guint32 tok;
1418                 table = &assembly->tables [MONO_TABLE_METHODIMPL];
1419                 table->rows ++;
1420                 alloc_table (table, table->rows);
1421                 values = table->values + table->rows * MONO_METHODIMPL_SIZE;
1422                 values [MONO_METHODIMPL_CLASS] = tb->table_idx;
1423                 values [MONO_METHODIMPL_BODY] = MONO_METHODDEFORREF_METHODDEF | (mb->table_idx << MONO_METHODDEFORREF_BITS);
1424
1425                 tok = mono_image_create_token (assembly, (MonoObject*)mb->override_method, FALSE);
1426                 switch (mono_metadata_token_table (tok)) {
1427                 case MONO_TABLE_MEMBERREF:
1428                         tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODREF;
1429                         break;
1430                 case MONO_TABLE_METHOD:
1431                         tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODDEF;
1432                         break;
1433                 default:
1434                         g_assert_not_reached ();
1435                 }
1436                 values [MONO_METHODIMPL_DECLARATION] = tok;
1437         }
1438
1439         if (mb->generic_params) {
1440                 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
1441                 table->rows += mono_array_length (mb->generic_params);
1442                 alloc_table (table, table->rows);
1443                 for (i = 0; i < mono_array_length (mb->generic_params); ++i) {
1444                         guint32 owner = MONO_TYPEORMETHOD_METHOD | (mb->table_idx << MONO_TYPEORMETHOD_BITS);
1445
1446                         mono_image_get_generic_param_info (
1447                                 mono_array_get (mb->generic_params, gpointer, i), owner, assembly);
1448                 }
1449         }
1450
1451 }
1452
1453 static void
1454 mono_image_get_ctor_info (MonoDomain *domain, MonoReflectionCtorBuilder *mb, MonoDynamicImage *assembly)
1455 {
1456         ReflectionMethodBuilder rmb;
1457
1458         reflection_methodbuilder_from_ctor_builder (&rmb, mb);
1459
1460         mono_image_basic_method (&rmb, assembly);
1461 }
1462
1463 static char*
1464 type_get_fully_qualified_name (MonoType *type) {
1465         char *name, *result;
1466         MonoClass *klass;
1467         MonoAssembly *ta;
1468
1469         name = mono_type_get_name (type);
1470         klass = my_mono_class_from_mono_type (type);
1471         ta = klass->image->assembly;
1472
1473         result = g_strdup_printf ("%s, %s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s",
1474                 name, ta->aname.name,
1475                 ta->aname.major, ta->aname.minor, ta->aname.build, ta->aname.revision,
1476                 ta->aname.culture && *ta->aname.culture? ta->aname.culture: "neutral",
1477                 ta->aname.public_key_token [0] ? (char *)ta->aname.public_key_token : "null");
1478         g_free (name);
1479         return result;
1480 }
1481
1482 static char*
1483 type_get_qualified_name (MonoType *type, MonoAssembly *ass) {
1484         MonoClass *klass;
1485         MonoAssembly *ta;
1486
1487         klass = my_mono_class_from_mono_type (type);
1488         if (!klass)
1489                 return mono_type_get_name (type);
1490         ta = klass->image->assembly;
1491         if (ta == ass || klass->image == mono_defaults.corlib)
1492                 return mono_type_get_name (type);
1493
1494         return type_get_fully_qualified_name (type);
1495 }
1496
1497 static guint32
1498 fieldref_encode_signature (MonoDynamicImage *assembly, MonoType *type)
1499 {
1500         char blob_size [64];
1501         char *b = blob_size;
1502         char *p;
1503         char* buf;
1504         guint32 idx;
1505
1506         if (!assembly->save)
1507                 return 0;
1508
1509         p = buf = g_malloc (64);
1510
1511         mono_metadata_encode_value (0x06, p, &p);
1512         /* encode custom attributes before the type */
1513         encode_type (assembly, type, p, &p);
1514         g_assert (p-buf < 64);
1515         mono_metadata_encode_value (p-buf, b, &b);
1516         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, p-buf);
1517         g_free (buf);
1518         return idx;
1519 }
1520
1521 static guint32
1522 field_encode_signature (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
1523 {
1524         char blob_size [64];
1525         char *b = blob_size;
1526         char *p;
1527         char* buf;
1528         guint32 idx;
1529
1530         p = buf = g_malloc (64);
1531
1532         mono_metadata_encode_value (0x06, p, &p);
1533         encode_custom_modifiers (assembly, fb->modreq, fb->modopt, p, &p);
1534         /* encode custom attributes before the type */
1535         encode_reflection_type (assembly, fb->type, p, &p);
1536         g_assert (p-buf < 64);
1537         mono_metadata_encode_value (p-buf, b, &b);
1538         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, p-buf);
1539         g_free (buf);
1540         return idx;
1541 }
1542
1543 static guint32
1544 encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type) {
1545         char blob_size [64];
1546         char *b = blob_size;
1547         char *p, *box_val;
1548         char* buf;
1549         guint32 idx = 0, len = 0, dummy = 0;
1550
1551         p = buf = g_malloc (64);
1552         if (!val) {
1553                 *ret_type = MONO_TYPE_CLASS;
1554                 len = 4;
1555                 box_val = (char*)&dummy;
1556         } else {
1557                 box_val = ((char*)val) + sizeof (MonoObject);
1558                 *ret_type = val->vtable->klass->byval_arg.type;
1559         }
1560 handle_enum:
1561         switch (*ret_type) {
1562         case MONO_TYPE_BOOLEAN:
1563         case MONO_TYPE_U1:
1564         case MONO_TYPE_I1:
1565                 len = 1;
1566                 break;
1567         case MONO_TYPE_CHAR:
1568         case MONO_TYPE_U2:
1569         case MONO_TYPE_I2:
1570                 len = 2;
1571                 break;
1572         case MONO_TYPE_U4:
1573         case MONO_TYPE_I4:
1574         case MONO_TYPE_R4:
1575                 len = 4;
1576                 break;
1577         case MONO_TYPE_U8:
1578         case MONO_TYPE_I8:
1579         case MONO_TYPE_R8:
1580                 len = 8;
1581                 break;
1582         case MONO_TYPE_VALUETYPE:
1583                 if (val->vtable->klass->enumtype) {
1584                         *ret_type = val->vtable->klass->enum_basetype->type;
1585                         goto handle_enum;
1586                 } else
1587                         g_error ("we can't encode valuetypes");
1588         case MONO_TYPE_CLASS:
1589                 break;
1590         case MONO_TYPE_STRING: {
1591                 MonoString *str = (MonoString*)val;
1592                 /* there is no signature */
1593                 len = str->length * 2;
1594                 mono_metadata_encode_value (len, b, &b);
1595 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
1596                 {
1597                         char *swapped = g_malloc (2 * mono_string_length (str));
1598                         const char *p = (const char*)mono_string_chars (str);
1599
1600                         swap_with_size (swapped, p, 2, mono_string_length (str));
1601                         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, swapped, len);
1602                         g_free (swapped);
1603                 }
1604 #else
1605                 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, (char*)mono_string_chars (str), len);
1606 #endif
1607
1608                 g_free (buf);
1609                 return idx;
1610         }
1611         default:
1612                 g_error ("we don't encode constant type 0x%02x yet", *ret_type);
1613         }
1614
1615         /* there is no signature */
1616         mono_metadata_encode_value (len, b, &b);
1617 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
1618         idx = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
1619         swap_with_size (blob_size, box_val, len, 1);
1620         mono_image_add_stream_data (&assembly->blob, blob_size, len);
1621 #else
1622         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, box_val, len);
1623 #endif
1624
1625         g_free (buf);
1626         return idx;
1627 }
1628
1629 static guint32
1630 encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo) {
1631         char blob_size [64];
1632         char *b = blob_size;
1633         char *p, *buf, *str;
1634         guint32 idx, len, bufsize = 256;
1635
1636         p = buf = g_malloc (bufsize);
1637
1638         switch (minfo->type) {
1639         case MONO_NATIVE_BYVALTSTR:
1640         case MONO_NATIVE_BYVALARRAY:
1641                 mono_metadata_encode_value (minfo->type, p, &p);
1642                 mono_metadata_encode_value (minfo->count, p, &p);
1643                 break;
1644         case MONO_NATIVE_LPARRAY:
1645                 mono_metadata_encode_value (minfo->type, p, &p);
1646                 if (minfo->eltype || (minfo->count > 0)) {
1647                         mono_metadata_encode_value (minfo->eltype, p, &p);
1648                         if (minfo->count > 0) {
1649                                 mono_metadata_encode_value (0, p, &p);
1650                                 mono_metadata_encode_value (minfo->count, p, &p);
1651                         }
1652                 }
1653                 break;
1654         case MONO_NATIVE_CUSTOM:
1655                 mono_metadata_encode_value (minfo->type, p, &p);
1656                 if (minfo->guid) {
1657                         str = mono_string_to_utf8 (minfo->guid);
1658                         len = strlen (str);
1659                         mono_metadata_encode_value (len, p, &p);
1660                         memcpy (p, str, len);
1661                         p += len;
1662                         g_free (str);
1663                 } else {
1664                         mono_metadata_encode_value (0, p, &p);
1665                 }
1666                 if (minfo->marshaltype) {
1667                         str = mono_string_to_utf8 (minfo->marshaltype);
1668                         len = strlen (str);
1669                         mono_metadata_encode_value (len, p, &p);
1670                         if (p + len >= buf + bufsize) {
1671                                 idx = p - buf;
1672                                 bufsize *= 2;
1673                                 buf = g_realloc (buf, bufsize);
1674                                 p = buf + idx;
1675                         }
1676                         memcpy (p, str, len);
1677                         p += len;
1678                         g_free (str);
1679                 } else {
1680                         mono_metadata_encode_value (0, p, &p);
1681                 }
1682                 if (minfo->marshaltyperef) {
1683                         str = type_get_fully_qualified_name (minfo->marshaltyperef->type);
1684                         len = strlen (str);
1685                         mono_metadata_encode_value (len, p, &p);
1686                         if (p + len >= buf + bufsize) {
1687                                 idx = p - buf;
1688                                 bufsize *= 2;
1689                                 buf = g_realloc (buf, bufsize);
1690                                 p = buf + idx;
1691                         }
1692                         memcpy (p, str, len);
1693                         p += len;
1694                         g_free (str);
1695                 } else {
1696                         mono_metadata_encode_value (0, p, &p);
1697                 }
1698                 if (minfo->mcookie) {
1699                         str = mono_string_to_utf8 (minfo->mcookie);
1700                         len = strlen (str);
1701                         mono_metadata_encode_value (len, p, &p);
1702                         if (p + len >= buf + bufsize) {
1703                                 idx = p - buf;
1704                                 bufsize *= 2;
1705                                 buf = g_realloc (buf, bufsize);
1706                                 p = buf + idx;
1707                         }
1708                         memcpy (p, str, len);
1709                         p += len;
1710                         g_free (str);
1711                 } else {
1712                         mono_metadata_encode_value (0, p, &p);
1713                 }
1714                 break;
1715         default:
1716                 mono_metadata_encode_value (minfo->type, p, &p);
1717                 break;
1718         }
1719         len = p-buf;
1720         mono_metadata_encode_value (len, b, &b);
1721         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, len);
1722         g_free (buf);
1723         return idx;
1724 }
1725
1726 static void
1727 mono_image_get_field_info (MonoReflectionFieldBuilder *fb, MonoDynamicImage *assembly)
1728 {
1729         MonoDynamicTable *table;
1730         guint32 *values;
1731         char *name;
1732
1733         /* maybe this fixup should be done in the C# code */
1734         if (fb->attrs & FIELD_ATTRIBUTE_LITERAL)
1735                 fb->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
1736         table = &assembly->tables [MONO_TABLE_FIELD];
1737         fb->table_idx = table->next_idx ++;
1738         mono_g_hash_table_insert (assembly->field_to_table_idx, fb->handle, GUINT_TO_POINTER (fb->table_idx));
1739         values = table->values + fb->table_idx * MONO_FIELD_SIZE;
1740         name = mono_string_to_utf8 (fb->name);
1741         values [MONO_FIELD_NAME] = string_heap_insert (&assembly->sheap, name);
1742         g_free (name);
1743         values [MONO_FIELD_FLAGS] = fb->attrs;
1744         values [MONO_FIELD_SIGNATURE] = field_encode_signature (assembly, fb);
1745
1746         if (fb->offset != -1) {
1747                 table = &assembly->tables [MONO_TABLE_FIELDLAYOUT];
1748                 table->rows ++;
1749                 alloc_table (table, table->rows);
1750                 values = table->values + table->rows * MONO_FIELD_LAYOUT_SIZE;
1751                 values [MONO_FIELD_LAYOUT_FIELD] = fb->table_idx;
1752                 values [MONO_FIELD_LAYOUT_OFFSET] = fb->offset;
1753         }
1754         if (fb->attrs & FIELD_ATTRIBUTE_LITERAL) {
1755                 guint32 field_type = 0;
1756                 table = &assembly->tables [MONO_TABLE_CONSTANT];
1757                 table->rows ++;
1758                 alloc_table (table, table->rows);
1759                 values = table->values + table->rows * MONO_CONSTANT_SIZE;
1760                 values [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_FIEDDEF | (fb->table_idx << MONO_HASCONSTANT_BITS);
1761                 values [MONO_CONSTANT_VALUE] = encode_constant (assembly, fb->def_value, &field_type);
1762                 values [MONO_CONSTANT_TYPE] = field_type;
1763                 values [MONO_CONSTANT_PADDING] = 0;
1764         }
1765         if (fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) {
1766                 guint32 rva_idx;
1767                 table = &assembly->tables [MONO_TABLE_FIELDRVA];
1768                 table->rows ++;
1769                 alloc_table (table, table->rows);
1770                 values = table->values + table->rows * MONO_FIELD_RVA_SIZE;
1771                 values [MONO_FIELD_RVA_FIELD] = fb->table_idx;
1772                 /*
1773                  * We store it in the code section because it's simpler for now.
1774                  */
1775                 if (fb->rva_data)
1776                         rva_idx = mono_image_add_stream_data (&assembly->code, mono_array_addr (fb->rva_data, char, 0), mono_array_length (fb->rva_data));
1777                 else
1778                         rva_idx = mono_image_add_stream_zero (&assembly->code, mono_class_value_size (fb->handle->parent, NULL));
1779                 values [MONO_FIELD_RVA_RVA] = rva_idx + assembly->text_rva;
1780         }
1781         if (fb->marshal_info) {
1782                 table = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
1783                 table->rows ++;
1784                 alloc_table (table, table->rows);
1785                 values = table->values + table->rows * MONO_FIELD_MARSHAL_SIZE;
1786                 values [MONO_FIELD_MARSHAL_PARENT] = (fb->table_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_FIELDSREF;
1787                 values [MONO_FIELD_MARSHAL_NATIVE_TYPE] = encode_marshal_blob (assembly, fb->marshal_info);
1788         }
1789 }
1790
1791 static guint32
1792 property_encode_signature (MonoDynamicImage *assembly, MonoReflectionPropertyBuilder *fb)
1793 {
1794         char *buf, *p;
1795         char blob_size [6];
1796         char *b = blob_size;
1797         guint32 nparams = 0;
1798         MonoReflectionMethodBuilder *mb = fb->get_method;
1799         MonoReflectionMethodBuilder *smb = fb->set_method;
1800         guint32 idx, i, size;
1801
1802         if (mb && mb->parameters)
1803                 nparams = mono_array_length (mb->parameters);
1804         if (!mb && smb && smb->parameters)
1805                 nparams = mono_array_length (smb->parameters) - 1;
1806         size = 24 + nparams * 10;
1807         buf = p = g_malloc (size);
1808         *p = 0x08;
1809         p++;
1810         mono_metadata_encode_value (nparams, p, &p);
1811         if (mb) {
1812                 encode_reflection_type (assembly, mb->rtype, p, &p);
1813                 for (i = 0; i < nparams; ++i) {
1814                         MonoReflectionType *pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
1815                         encode_reflection_type (assembly, pt, p, &p);
1816                 }
1817         } else {
1818                 /* the property type is the last param */
1819                 encode_reflection_type (assembly, mono_array_get (smb->parameters, MonoReflectionType*, nparams), p, &p);
1820                 for (i = 0; i < nparams; ++i) {
1821                         MonoReflectionType *pt = mono_array_get (smb->parameters, MonoReflectionType*, i);
1822                         encode_reflection_type (assembly, pt, p, &p);
1823                 }
1824         }
1825         /* store length */
1826         g_assert (p - buf < size);
1827         mono_metadata_encode_value (p-buf, b, &b);
1828         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, p-buf);
1829         g_free (buf);
1830         return idx;
1831 }
1832
1833 static void
1834 mono_image_get_property_info (MonoReflectionPropertyBuilder *pb, MonoDynamicImage *assembly)
1835 {
1836         MonoDynamicTable *table;
1837         guint32 *values;
1838         char *name;
1839         guint num_methods = 0;
1840         guint32 semaidx;
1841
1842         /*
1843          * we need to set things in the following tables:
1844          * PROPERTYMAP (info already filled in _get_type_info ())
1845          * PROPERTY    (rows already preallocated in _get_type_info ())
1846          * METHOD      (method info already done with the generic method code)
1847          * METHODSEMANTICS
1848          */
1849         table = &assembly->tables [MONO_TABLE_PROPERTY];
1850         pb->table_idx = table->next_idx ++;
1851         values = table->values + pb->table_idx * MONO_PROPERTY_SIZE;
1852         name = mono_string_to_utf8 (pb->name);
1853         values [MONO_PROPERTY_NAME] = string_heap_insert (&assembly->sheap, name);
1854         g_free (name);
1855         values [MONO_PROPERTY_FLAGS] = pb->attrs;
1856         values [MONO_PROPERTY_TYPE] = property_encode_signature (assembly, pb);
1857
1858         /* FIXME: we still don't handle 'other' methods */
1859         if (pb->get_method) num_methods ++;
1860         if (pb->set_method) num_methods ++;
1861
1862         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
1863         table->rows += num_methods;
1864         alloc_table (table, table->rows);
1865
1866         if (pb->get_method) {
1867                 semaidx = table->next_idx ++;
1868                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
1869                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_GETTER;
1870                 values [MONO_METHOD_SEMA_METHOD] = pb->get_method->table_idx;
1871                 values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
1872         }
1873         if (pb->set_method) {
1874                 semaidx = table->next_idx ++;
1875                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
1876                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_SETTER;
1877                 values [MONO_METHOD_SEMA_METHOD] = pb->set_method->table_idx;
1878                 values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
1879         }
1880 }
1881
1882 static void
1883 mono_image_get_event_info (MonoReflectionEventBuilder *eb, MonoDynamicImage *assembly)
1884 {
1885         MonoDynamicTable *table;
1886         guint32 *values;
1887         char *name;
1888         guint num_methods = 0;
1889         guint32 semaidx;
1890
1891         /*
1892          * we need to set things in the following tables:
1893          * EVENTMAP (info already filled in _get_type_info ())
1894          * EVENT    (rows already preallocated in _get_type_info ())
1895          * METHOD      (method info already done with the generic method code)
1896          * METHODSEMANTICS
1897          */
1898         table = &assembly->tables [MONO_TABLE_EVENT];
1899         eb->table_idx = table->next_idx ++;
1900         values = table->values + eb->table_idx * MONO_EVENT_SIZE;
1901         name = mono_string_to_utf8 (eb->name);
1902         values [MONO_EVENT_NAME] = string_heap_insert (&assembly->sheap, name);
1903         g_free (name);
1904         values [MONO_EVENT_FLAGS] = eb->attrs;
1905         values [MONO_EVENT_TYPE] = mono_image_typedef_or_ref (assembly, eb->type->type);
1906
1907         /*
1908          * FIXME: we still don't handle 'other' methods
1909          */
1910         if (eb->add_method) num_methods ++;
1911         if (eb->remove_method) num_methods ++;
1912         if (eb->raise_method) num_methods ++;
1913
1914         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
1915         table->rows += num_methods;
1916         alloc_table (table, table->rows);
1917
1918         if (eb->add_method) {
1919                 semaidx = table->next_idx ++;
1920                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
1921                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_ADD_ON;
1922                 values [MONO_METHOD_SEMA_METHOD] = eb->add_method->table_idx;
1923                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
1924         }
1925         if (eb->remove_method) {
1926                 semaidx = table->next_idx ++;
1927                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
1928                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_REMOVE_ON;
1929                 values [MONO_METHOD_SEMA_METHOD] = eb->remove_method->table_idx;
1930                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
1931         }
1932         if (eb->raise_method) {
1933                 semaidx = table->next_idx ++;
1934                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
1935                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_FIRE;
1936                 values [MONO_METHOD_SEMA_METHOD] = eb->raise_method->table_idx;
1937                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
1938         }
1939 }
1940
1941 static void
1942 encode_new_constraint (MonoDynamicImage *assembly, guint32 owner)
1943 {
1944         static MonoClass *NewConstraintAttr;
1945         static MonoMethod *NewConstraintAttr_ctor;
1946         MonoDynamicTable *table;
1947         guint32 *values;
1948         guint32 token, type;
1949         char blob_size [4] = { 0x01, 0x00, 0x00, 0x00 };
1950         char *buf, *p;
1951
1952         if (!NewConstraintAttr)
1953                 NewConstraintAttr = mono_class_from_name ( mono_defaults.corlib,
1954                         "System.Runtime.CompilerServices", "NewConstraintAttribute");
1955         g_assert (NewConstraintAttr);
1956
1957         if (!NewConstraintAttr_ctor) {
1958                 int i;
1959
1960                 for (i = 0; i < NewConstraintAttr->method.count; i++) {
1961                         MonoMethod *m = NewConstraintAttr->methods [i];
1962
1963                         if (strcmp (m->name, ".ctor"))
1964                                 continue;
1965
1966                         NewConstraintAttr_ctor = m;
1967                         break;
1968                 }
1969
1970                 g_assert (NewConstraintAttr_ctor);
1971         }
1972
1973         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1974         table->rows += 1;
1975         alloc_table (table, table->rows);
1976
1977         values = table->values + table->next_idx * MONO_CUSTOM_ATTR_SIZE;
1978         owner <<= MONO_CUSTOM_ATTR_BITS;
1979         owner |= MONO_CUSTOM_ATTR_GENERICPAR;
1980         values [MONO_CUSTOM_ATTR_PARENT] = owner;
1981
1982         token = mono_image_get_methodref_token (assembly, NewConstraintAttr_ctor);
1983
1984         type = mono_metadata_token_index (token);
1985         type <<= MONO_CUSTOM_ATTR_TYPE_BITS;
1986         switch (mono_metadata_token_table (token)) {
1987         case MONO_TABLE_METHOD:
1988                 type |= MONO_CUSTOM_ATTR_TYPE_METHODDEF;
1989                 break;
1990         case MONO_TABLE_MEMBERREF:
1991                 type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
1992                 break;
1993         default:
1994                 g_warning ("got wrong token in custom attr");
1995                 return;
1996         }
1997         values [MONO_CUSTOM_ATTR_TYPE] = type;
1998
1999         buf = p = g_malloc (1);
2000         mono_metadata_encode_value (4, p, &p);
2001         g_assert (p-buf == 1);
2002
2003         values [MONO_CUSTOM_ATTR_VALUE] = add_to_blob_cached (assembly, buf, 1, blob_size, 4);
2004
2005         values += MONO_CUSTOM_ATTR_SIZE;
2006         ++table->next_idx;
2007 }
2008
2009 static void
2010 encode_constraints (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly)
2011 {
2012         MonoDynamicTable *table;
2013         guint32 num_constraints, i;
2014         guint32 *values;
2015         guint32 table_idx;
2016
2017         table = &assembly->tables [MONO_TABLE_GENERICPARAMCONSTRAINT];
2018         num_constraints = gparam->iface_constraints ?
2019                 mono_array_length (gparam->iface_constraints) : 0;
2020         table->rows += num_constraints;
2021         if (gparam->base_type)
2022                 table->rows++;
2023         alloc_table (table, table->rows);
2024
2025         if (gparam->base_type) {
2026                 table_idx = table->next_idx ++;
2027                 values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE;
2028
2029                 values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner;
2030                 values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (
2031                         assembly, gparam->base_type->type);
2032         }
2033
2034         for (i = 0; i < num_constraints; i++) {
2035                 MonoReflectionType *constraint = mono_array_get (
2036                         gparam->iface_constraints, gpointer, i);
2037
2038                 table_idx = table->next_idx ++;
2039                 values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE;
2040
2041                 values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner;
2042                 values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (
2043                         assembly, constraint->type);
2044         }
2045
2046         if (gparam->attrs &  GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT)
2047                 encode_new_constraint (assembly, owner);
2048 }
2049
2050 static void
2051 mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly)
2052 {
2053         GenericParamTableEntry *entry;
2054
2055         /*
2056          * The GenericParam table must be sorted according to the `owner' field.
2057          * We need to do this sorting prior to writing the GenericParamConstraint
2058          * table, since we have to use the final GenericParam table indices there
2059          * and they must also be sorted.
2060          */
2061
2062         entry = g_new0 (GenericParamTableEntry, 1);
2063         entry->owner = owner;
2064         entry->gparam = gparam;
2065
2066         g_ptr_array_add (assembly->gen_params, entry);
2067 }
2068
2069 static void
2070 write_generic_param_entry (MonoDynamicImage *assembly, GenericParamTableEntry *entry)
2071 {
2072         MonoDynamicTable *table;
2073         MonoGenericParam *param;
2074         guint32 *values;
2075         guint32 table_idx;
2076
2077         table = &assembly->tables [MONO_TABLE_GENERICPARAM];
2078         table_idx = table->next_idx ++;
2079         values = table->values + table_idx * MONO_GENERICPARAM_SIZE;
2080
2081         param = entry->gparam->type.type->data.generic_param;
2082
2083         values [MONO_GENERICPARAM_OWNER] = entry->owner;
2084         values [MONO_GENERICPARAM_FLAGS] = entry->gparam->attrs;
2085         values [MONO_GENERICPARAM_NUMBER] = param->num;
2086         values [MONO_GENERICPARAM_NAME] = string_heap_insert (&assembly->sheap, param->name);
2087         values [MONO_GENERICPARAM_KIND] = 0;
2088
2089         encode_constraints (entry->gparam, table_idx, assembly);
2090 }
2091
2092 static guint32
2093 resolution_scope_from_image (MonoDynamicImage *assembly, MonoImage *image)
2094 {
2095         MonoDynamicTable *table;
2096         guint32 token;
2097         guint32 *values;
2098         guint32 cols [MONO_ASSEMBLY_SIZE];
2099         const char *pubkey;
2100         guint32 publen;
2101
2102         if ((token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, image))))
2103                 return token;
2104
2105         if (image->assembly->dynamic && (image->assembly == assembly->image.assembly)) {
2106                 table = &assembly->tables [MONO_TABLE_MODULEREF];
2107                 token = table->next_idx ++;
2108                 table->rows ++;
2109                 alloc_table (table, table->rows);
2110                 values = table->values + token * MONO_MODULEREF_SIZE;
2111                 values [MONO_MODULEREF_NAME] = string_heap_insert (&assembly->sheap, image->module_name);
2112
2113                 token <<= MONO_RESOLTION_SCOPE_BITS;
2114                 token |= MONO_RESOLTION_SCOPE_MODULEREF;
2115                 g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
2116
2117                 return token;
2118         }
2119
2120         if (image->assembly->dynamic)
2121                 /* FIXME: */
2122                 memset (cols, 0, sizeof (cols));
2123         else {
2124                 /* image->assembly->image is the manifest module */
2125                 image = image->assembly->image;
2126                 mono_metadata_decode_row (&image->tables [MONO_TABLE_ASSEMBLY], 0, cols, MONO_ASSEMBLY_SIZE);
2127         }
2128
2129         table = &assembly->tables [MONO_TABLE_ASSEMBLYREF];
2130         token = table->next_idx ++;
2131         table->rows ++;
2132         alloc_table (table, table->rows);
2133         values = table->values + token * MONO_ASSEMBLYREF_SIZE;
2134         values [MONO_ASSEMBLYREF_NAME] = string_heap_insert (&assembly->sheap, image->assembly_name);
2135         values [MONO_ASSEMBLYREF_MAJOR_VERSION] = cols [MONO_ASSEMBLY_MAJOR_VERSION];
2136         values [MONO_ASSEMBLYREF_MINOR_VERSION] = cols [MONO_ASSEMBLY_MINOR_VERSION];
2137         values [MONO_ASSEMBLYREF_BUILD_NUMBER] = cols [MONO_ASSEMBLY_BUILD_NUMBER];
2138         values [MONO_ASSEMBLYREF_REV_NUMBER] = cols [MONO_ASSEMBLY_REV_NUMBER];
2139         values [MONO_ASSEMBLYREF_FLAGS] = 0;
2140         values [MONO_ASSEMBLYREF_CULTURE] = 0;
2141         values [MONO_ASSEMBLYREF_HASH_VALUE] = 0;
2142
2143         if (strcmp ("", image->assembly->aname.culture)) {
2144                 values [MONO_ASSEMBLYREF_CULTURE] = string_heap_insert (&assembly->sheap,
2145                                 image->assembly->aname.culture);
2146         }
2147
2148         if ((pubkey = mono_image_get_public_key (image, &publen))) {
2149                 guchar pubtoken [9];
2150                 pubtoken [0] = 8;
2151                 mono_digest_get_public_token (pubtoken + 1, pubkey, publen);
2152                 values [MONO_ASSEMBLYREF_PUBLIC_KEY] = mono_image_add_stream_data (&assembly->blob, pubtoken, 9);
2153         } else {
2154                 values [MONO_ASSEMBLYREF_PUBLIC_KEY] = 0;
2155         }
2156         token <<= MONO_RESOLTION_SCOPE_BITS;
2157         token |= MONO_RESOLTION_SCOPE_ASSEMBLYREF;
2158         g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
2159         return token;
2160 }
2161
2162 static guint32
2163 create_typespec (MonoDynamicImage *assembly, MonoType *type)
2164 {
2165         MonoDynamicTable *table;
2166         guint32 *values;
2167         guint32 token;
2168         char sig [128];
2169         char *p = sig;
2170         char blob_size [6];
2171         char *b = blob_size;
2172
2173         switch (type->type) {
2174         case MONO_TYPE_FNPTR:
2175         case MONO_TYPE_PTR:
2176         case MONO_TYPE_SZARRAY:
2177         case MONO_TYPE_ARRAY:
2178         case MONO_TYPE_VAR:
2179         case MONO_TYPE_MVAR:
2180         case MONO_TYPE_GENERICINST:
2181                 encode_type (assembly, type, p, &p);
2182                 break;
2183         case MONO_TYPE_CLASS:
2184         case MONO_TYPE_VALUETYPE: {
2185                 MonoClass *k = mono_class_from_mono_type (type);
2186                 if (!k || !k->generic_inst)
2187                         return 0;
2188                 encode_generic_inst (assembly, k->generic_inst, p, &p);
2189                 break;
2190         }
2191         default:
2192                 return 0;
2193         }
2194
2195         table = &assembly->tables [MONO_TABLE_TYPESPEC];
2196         if (assembly->save) {
2197                 g_assert (p-sig < 128);
2198                 mono_metadata_encode_value (p-sig, b, &b);
2199                 token = add_to_blob_cached (assembly, blob_size, b-blob_size, sig, p-sig);
2200                 alloc_table (table, table->rows + 1);
2201                 values = table->values + table->next_idx * MONO_TYPESPEC_SIZE;
2202                 values [MONO_TYPESPEC_SIGNATURE] = token;
2203         }
2204
2205         token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
2206         g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
2207         table->next_idx ++;
2208         return token;
2209 }
2210
2211 /*
2212  * Despite the name, we handle also TypeSpec (with the above helper).
2213  */
2214 static guint32
2215 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type)
2216 {
2217         MonoDynamicTable *table;
2218         guint32 *values;
2219         guint32 token, scope, enclosing;
2220         MonoClass *klass;
2221
2222         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typeref, type));
2223         if (token)
2224                 return token;
2225         token = create_typespec (assembly, type);
2226         if (token)
2227                 return token;
2228         klass = my_mono_class_from_mono_type (type);
2229         if (!klass)
2230                 klass = mono_class_from_mono_type (type);
2231
2232         /*
2233          * If it's in the same module and not a generic type parameter:
2234          */
2235         if ((klass->image == &assembly->image) && (type->type != MONO_TYPE_VAR) &&
2236                         (type->type != MONO_TYPE_MVAR)) {
2237                 MonoReflectionTypeBuilder *tb = klass->reflection_info;
2238                 token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
2239                 mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), klass->reflection_info);
2240                 return token;
2241         }
2242
2243         if (klass->nested_in) {
2244                 enclosing = mono_image_typedef_or_ref (assembly, &klass->nested_in->byval_arg);
2245                 /* get the typeref idx of the enclosing type */
2246                 enclosing >>= MONO_TYPEDEFORREF_BITS;
2247                 scope = (enclosing << MONO_RESOLTION_SCOPE_BITS) | MONO_RESOLTION_SCOPE_TYPEREF;
2248         } else {
2249                 scope = resolution_scope_from_image (assembly, klass->image);
2250         }
2251         table = &assembly->tables [MONO_TABLE_TYPEREF];
2252         if (assembly->save) {
2253                 alloc_table (table, table->rows + 1);
2254                 values = table->values + table->next_idx * MONO_TYPEREF_SIZE;
2255                 values [MONO_TYPEREF_SCOPE] = scope;
2256                 values [MONO_TYPEREF_NAME] = string_heap_insert (&assembly->sheap, klass->name);
2257                 values [MONO_TYPEREF_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
2258         }
2259         token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
2260         g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
2261         table->next_idx ++;
2262         mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), klass->reflection_info);
2263         return token;
2264 }
2265
2266 /*
2267  * Insert a memberef row into the metadata: the token that point to the memberref
2268  * is returned. Caching is done in the caller (mono_image_get_methodref_token() or
2269  * mono_image_get_fieldref_token()).
2270  * The sig param is an index to an already built signature.
2271  */
2272 static guint32
2273 mono_image_get_memberref_token (MonoDynamicImage *assembly, MonoType *type, const char *name, guint32 sig)
2274 {
2275         MonoDynamicTable *table;
2276         guint32 *values;
2277         guint32 token, pclass;
2278         guint32 parent;
2279
2280         parent = mono_image_typedef_or_ref (assembly, type);
2281         switch (parent & MONO_TYPEDEFORREF_MASK) {
2282         case MONO_TYPEDEFORREF_TYPEREF:
2283                 pclass = MONO_MEMBERREF_PARENT_TYPEREF;
2284                 break;
2285         case MONO_TYPEDEFORREF_TYPESPEC:
2286                 pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
2287                 break;
2288         case MONO_TYPEDEFORREF_TYPEDEF:
2289                 pclass = MONO_MEMBERREF_PARENT_TYPEDEF;
2290                 break;
2291         default:
2292                 g_warning ("unknown typeref or def token 0x%08x for %s", parent, name);
2293                 return 0;
2294         }
2295         /* extract the index */
2296         parent >>= MONO_TYPEDEFORREF_BITS;
2297
2298         table = &assembly->tables [MONO_TABLE_MEMBERREF];
2299
2300         if (assembly->save) {
2301                 alloc_table (table, table->rows + 1);
2302                 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
2303                 values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
2304                 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
2305                 values [MONO_MEMBERREF_SIGNATURE] = sig;
2306         }
2307
2308         token = MONO_TOKEN_MEMBER_REF | table->next_idx;
2309         table->next_idx ++;
2310
2311         return token;
2312 }
2313
2314 static guint32
2315 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method)
2316 {
2317         guint32 token;
2318         MonoMethodSignature *sig;
2319
2320         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
2321         if (token)
2322                 return token;
2323
2324         /*
2325          * A methodref signature can't contain an unmanaged calling convention.
2326          */
2327         sig = mono_metadata_signature_dup (method->signature);
2328         if ((sig->call_convention != MONO_CALL_DEFAULT) && (sig->call_convention != MONO_CALL_VARARG))
2329                 sig->call_convention = MONO_CALL_DEFAULT;
2330         token = mono_image_get_memberref_token (assembly, &method->klass->byval_arg,
2331                 method->name,  method_encode_signature (assembly, sig));
2332         g_free (sig);
2333         g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
2334         return token;
2335 }
2336
2337 static guint32
2338 mono_image_get_varargs_method_token (MonoDynamicImage *assembly, guint32 original,
2339                                      const gchar *name, guint32 sig)
2340 {
2341         MonoDynamicTable *table;
2342         guint32 token;
2343         guint32 *values;
2344
2345         table = &assembly->tables [MONO_TABLE_MEMBERREF];
2346
2347         if (assembly->save) {
2348                 alloc_table (table, table->rows + 1);
2349                 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
2350                 values [MONO_MEMBERREF_CLASS] = original;
2351                 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
2352                 values [MONO_MEMBERREF_SIGNATURE] = sig;
2353         }
2354
2355         token = MONO_TOKEN_MEMBER_REF | table->next_idx;
2356         table->next_idx ++;
2357
2358         return token;
2359 }
2360
2361 static guint32
2362 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb)
2363 {
2364         guint32 token;
2365         ReflectionMethodBuilder rmb;
2366
2367         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, mb));
2368         if (token)
2369                 return token;
2370
2371         reflection_methodbuilder_from_method_builder (&rmb, mb);
2372
2373         token = mono_image_get_memberref_token (assembly, ((MonoReflectionTypeBuilder*)rmb.type)->type.type,
2374                 mono_string_to_utf8 (rmb.name), method_builder_encode_signature (assembly, &rmb));
2375         g_hash_table_insert (assembly->handleref, mb, GUINT_TO_POINTER(token));
2376         return token;
2377 }
2378
2379 static guint32
2380 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *mb)
2381 {
2382         guint32 token;
2383         ReflectionMethodBuilder rmb;
2384
2385         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, mb));
2386         if (token)
2387                 return token;
2388
2389         reflection_methodbuilder_from_ctor_builder (&rmb, mb);
2390
2391         token = mono_image_get_memberref_token (assembly, ((MonoReflectionTypeBuilder*)rmb.type)->type.type,
2392                 mono_string_to_utf8 (rmb.name), method_builder_encode_signature (assembly, &rmb));
2393         g_hash_table_insert (assembly->handleref, mb, GUINT_TO_POINTER(token));
2394         return token;
2395 }
2396
2397 static guint32
2398 mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoReflectionField *f)
2399 {
2400         MonoType *type;
2401         guint32 token;
2402
2403         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, f));
2404         if (token)
2405                 return token;
2406         g_assert (f->field->parent);
2407         type = f->field->generic_info ? f->field->generic_info->generic_type : f->field->type;
2408         token = mono_image_get_memberref_token (assembly, &f->klass->byval_arg,
2409                 f->field->name,  fieldref_encode_signature (assembly, type));
2410         g_hash_table_insert (assembly->handleref, f, GUINT_TO_POINTER(token));
2411         return token;
2412 }
2413
2414 static guint32
2415 encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericMethod *gmethod)
2416 {
2417         char *buf;
2418         char *p;
2419         int i;
2420         guint32 nparams =  gmethod->mtype_argc;
2421         guint32 size = 10 + nparams * 10;
2422         guint32 idx;
2423         char blob_size [6];
2424         char *b = blob_size;
2425
2426         if (!assembly->save)
2427                 return 0;
2428
2429         p = buf = g_malloc (size);
2430         /*
2431          * FIXME: vararg, explicit_this, differenc call_conv values...
2432          */
2433         mono_metadata_encode_value (0xa, p, &p); /* FIXME FIXME FIXME */
2434         mono_metadata_encode_value (nparams, p, &p);
2435
2436         for (i = 0; i < nparams; i++)
2437                 encode_type (assembly, gmethod->mtype_argv [i], p, &p);
2438
2439         /* store length */
2440         g_assert (p - buf < size);
2441         mono_metadata_encode_value (p-buf, b, &b);
2442         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, p-buf);
2443         g_free (buf);
2444         return idx;
2445 }
2446
2447 static guint32
2448 method_encode_methodspec (MonoDynamicImage *assembly, MonoMethod *method)
2449 {
2450         MonoDynamicTable *table;
2451         guint32 *values;
2452         guint32 token, mtoken = 0, sig;
2453         MonoMethodInflated *imethod;
2454         MonoMethod *declaring;
2455
2456         table = &assembly->tables [MONO_TABLE_METHODSPEC];
2457
2458         g_assert (method->signature->is_inflated);
2459         imethod = (MonoMethodInflated *) method;
2460         declaring = imethod->declaring;
2461
2462         sig = method_encode_signature (assembly, declaring->signature);
2463         mtoken = mono_image_get_memberref_token (assembly, &method->klass->byval_arg, declaring->name, sig);
2464
2465         if (!declaring->signature->generic_param_count)
2466                 return mtoken;
2467
2468         switch (mono_metadata_token_table (mtoken)) {
2469         case MONO_TABLE_MEMBERREF:
2470                 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
2471                 break;
2472         case MONO_TABLE_METHOD:
2473                 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODDEF;
2474                 break;
2475         default:
2476                 g_assert_not_reached ();
2477         }
2478
2479         sig = encode_generic_method_sig (assembly, imethod->context->gmethod);
2480
2481         if (assembly->save) {
2482                 alloc_table (table, table->rows + 1);
2483                 values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
2484                 values [MONO_METHODSPEC_METHOD] = mtoken;
2485                 values [MONO_METHODSPEC_SIGNATURE] = sig;
2486         }
2487
2488         token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
2489         table->next_idx ++;
2490
2491         return token;
2492 }
2493
2494 static guint32
2495 mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *m)
2496 {
2497         MonoMethodInflated *imethod;
2498         guint32 token;
2499
2500         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, m));
2501         if (token)
2502                 return token;
2503
2504         g_assert (m->signature->is_inflated);
2505         imethod = (MonoMethodInflated *) m;
2506
2507         if (imethod->declaring->signature->generic_param_count) {
2508                 token = method_encode_methodspec (assembly, m);
2509         } else {
2510                 guint32 sig = method_encode_signature (
2511                         assembly, imethod->declaring->signature);
2512                 token = mono_image_get_memberref_token (
2513                         assembly, &m->klass->byval_arg, m->name, sig);
2514         }
2515
2516         g_hash_table_insert (assembly->handleref, m, GUINT_TO_POINTER(token));
2517         return token;
2518 }
2519
2520 static guint32
2521 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m)
2522 {
2523         MonoMethodInflated *imethod = (MonoMethodInflated *) m;
2524         guint32 sig, token;
2525
2526         sig = method_encode_signature (assembly, imethod->declaring->signature);
2527         token = mono_image_get_memberref_token (
2528                 assembly, &m->klass->byval_arg, m->name, sig);
2529
2530         return token;
2531 }
2532
2533 static guint32
2534 create_generic_typespec (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb)
2535 {
2536         MonoDynamicTable *table;
2537         MonoClass *klass;
2538         guint32 *values;
2539         guint32 token;
2540         char sig [128];
2541         char *p = sig;
2542         char blob_size [6];
2543         char *b = blob_size;
2544         int count, i;
2545
2546         /*
2547          * We're creating a TypeSpec for the TypeBuilder of a generic type declaration,
2548          * ie. what we'd normally use as the generic type in a TypeSpec signature.
2549          * Because of this, we must not insert it into the `typeref' hash table.
2550          */
2551
2552         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typespec, tb->type.type));
2553         if (token)
2554                 return token;
2555
2556         g_assert (tb->generic_params);
2557         klass = mono_class_from_mono_type (tb->type.type);
2558
2559         mono_metadata_encode_value (MONO_TYPE_GENERICINST, p, &p);
2560         encode_type (assembly, &klass->byval_arg, p, &p);
2561
2562         count = mono_array_length (tb->generic_params);
2563         mono_metadata_encode_value (count, p, &p);
2564         for (i = 0; i < count; i++) {
2565                 MonoReflectionGenericParam *gparam;
2566
2567                 gparam = mono_array_get (tb->generic_params, MonoReflectionGenericParam *, i);
2568
2569                 encode_type (assembly, gparam->type.type, p, &p);
2570         }
2571
2572         table = &assembly->tables [MONO_TABLE_TYPESPEC];
2573         if (assembly->save) {
2574                 g_assert (p-sig < 128);
2575                 mono_metadata_encode_value (p-sig, b, &b);
2576                 token = add_to_blob_cached (assembly, blob_size, b-blob_size, sig, p-sig);
2577                 alloc_table (table, table->rows + 1);
2578                 values = table->values + table->next_idx * MONO_TYPESPEC_SIZE;
2579                 values [MONO_TYPESPEC_SIGNATURE] = token;
2580         }
2581
2582         token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
2583         g_hash_table_insert (assembly->typespec, tb->type.type, GUINT_TO_POINTER(token));
2584         table->next_idx ++;
2585         return token;
2586 }
2587
2588 static guint32
2589 mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb)
2590 {
2591         MonoDynamicTable *table;
2592         MonoClass *klass;
2593         guint32 *values;
2594         guint32 token, pclass, parent, sig;
2595         gchar *name;
2596
2597         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, fb));
2598         if (token)
2599                 return token;
2600
2601         klass = mono_class_from_mono_type (fb->typeb->type);
2602         name = mono_string_to_utf8 (fb->name);
2603
2604         sig = fieldref_encode_signature (assembly, fb->type->type);
2605
2606         parent = create_generic_typespec (assembly, (MonoReflectionTypeBuilder *) fb->typeb);
2607         g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC);
2608
2609         pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
2610         parent >>= MONO_TYPEDEFORREF_BITS;
2611
2612         table = &assembly->tables [MONO_TABLE_MEMBERREF];
2613
2614         if (assembly->save) {
2615                 alloc_table (table, table->rows + 1);
2616                 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
2617                 values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
2618                 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
2619                 values [MONO_MEMBERREF_SIGNATURE] = sig;
2620         }
2621
2622         token = MONO_TOKEN_MEMBER_REF | table->next_idx;
2623         table->next_idx ++;
2624         g_hash_table_insert (assembly->handleref, fb, GUINT_TO_POINTER(token));
2625         return token;
2626 }
2627
2628 static guint32
2629 mono_reflection_encode_sighelper (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper)
2630 {
2631         char *buf;
2632         char *p;
2633         guint32 nargs;
2634         guint32 size;
2635         guint32 i, idx;
2636         char blob_size [6];
2637         char *b = blob_size;
2638
2639         if (!assembly->save)
2640                 return 0;
2641
2642         /* FIXME: */
2643         g_assert (helper->type == 2);
2644
2645         if (helper->arguments)
2646                 nargs = mono_array_length (helper->arguments);
2647         else
2648                 nargs = 0;
2649
2650         size = 10 + (nargs * 10);
2651
2652         p = buf = g_malloc (size);
2653
2654         /* Encode calling convention */
2655         /* Change Any to Standard */
2656         if ((helper->call_conv & 0x03) == 0x03)
2657                 helper->call_conv = 0x01;
2658         /* explicit_this implies has_this */
2659         if (helper->call_conv & 0x40)
2660                 helper->call_conv &= 0x20;
2661
2662         if (helper->call_conv == 0) { /* Unmanaged */
2663                 *p = helper->unmanaged_call_conv - 1;
2664         } else {
2665                 /* Managed */
2666                 *p = helper->call_conv & 0x60; /* has_this + explicit_this */
2667                 if (helper->call_conv & 0x02) /* varargs */
2668                         *p += 0x05;
2669         }
2670
2671         p++;
2672         mono_metadata_encode_value (nargs, p, &p);
2673         encode_reflection_type (assembly, helper->return_type, p, &p);
2674         for (i = 0; i < nargs; ++i) {
2675                 MonoReflectionType *pt = mono_array_get (helper->arguments, MonoReflectionType*, i);
2676                 encode_reflection_type (assembly, pt, p, &p);
2677         }
2678         /* store length */
2679         g_assert (p - buf < size);
2680         mono_metadata_encode_value (p-buf, b, &b);
2681         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, buf, p-buf);
2682         g_free (buf);
2683
2684         return idx;
2685 }
2686
2687 static guint32
2688 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper)
2689 {
2690         guint32 idx;
2691         MonoDynamicTable *table;
2692         guint32 *values;
2693
2694         table = &assembly->tables [MONO_TABLE_STANDALONESIG];
2695         idx = table->next_idx ++;
2696         table->rows ++;
2697         alloc_table (table, table->rows);
2698         values = table->values + idx * MONO_STAND_ALONE_SIGNATURE_SIZE;
2699
2700         values [MONO_STAND_ALONE_SIGNATURE] =
2701                 mono_reflection_encode_sighelper (assembly, helper);
2702
2703         return idx;
2704 }
2705
2706 static int
2707 reflection_cc_to_file (int call_conv) {
2708         switch (call_conv & 0x3) {
2709         case 0:
2710         case 1: return MONO_CALL_DEFAULT;
2711         case 2: return MONO_CALL_VARARG;
2712         default:
2713                 g_assert_not_reached ();
2714         }
2715         return 0;
2716 }
2717
2718 typedef struct {
2719         MonoType *parent;
2720         MonoMethodSignature *sig;
2721         char *name;
2722         guint32 token;
2723 } ArrayMethod;
2724
2725 static guint32
2726 mono_image_get_array_token (MonoDynamicImage *assembly, MonoReflectionArrayMethod *m)
2727 {
2728         guint32 nparams, i;
2729         GList *tmp;
2730         char *name;
2731         MonoMethodSignature *sig;
2732         ArrayMethod *am;
2733
2734         name = mono_string_to_utf8 (m->name);
2735         nparams = mono_array_length (m->parameters);
2736         sig = g_malloc0 (sizeof (MonoMethodSignature) + sizeof (MonoType*) * nparams);
2737         sig->hasthis = 1;
2738         sig->sentinelpos = -1;
2739         sig->call_convention = reflection_cc_to_file (m->call_conv);
2740         sig->param_count = nparams;
2741         sig->ret = m->ret? m->ret->type: &mono_defaults.void_class->byval_arg;
2742         for (i = 0; i < nparams; ++i) {
2743                 MonoReflectionType *t = mono_array_get (m->parameters, gpointer, i);
2744                 sig->params [i] = t->type;
2745         }
2746
2747         for (tmp = assembly->array_methods; tmp; tmp = tmp->next) {
2748                 am = tmp->data;
2749                 if (strcmp (name, am->name) == 0 &&
2750                                 mono_metadata_type_equal (am->parent, m->parent->type) &&
2751                                 mono_metadata_signature_equal (am->sig, sig)) {
2752                         g_free (name);
2753                         g_free (sig);
2754                         m->table_idx = am->token & 0xffffff;
2755                         return am->token;
2756                 }
2757         }
2758         am = g_new0 (ArrayMethod, 1);
2759         am->name = name;
2760         am->sig = sig;
2761         am->parent = m->parent->type;
2762         am->token = mono_image_get_memberref_token (assembly, am->parent, name,
2763                 method_encode_signature (assembly, sig));
2764         assembly->array_methods = g_list_prepend (assembly->array_methods, am);
2765         m->table_idx = am->token & 0xffffff;
2766         return am->token;
2767 }
2768
2769 /*
2770  * Insert into the metadata tables all the info about the TypeBuilder tb.
2771  * Data in the tables is inserted in a predefined order, since some tables need to be sorted.
2772  */
2773 static void
2774 mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, MonoDynamicImage *assembly)
2775 {
2776         MonoDynamicTable *table;
2777         guint *values;
2778         int i, is_object = 0, is_system = 0;
2779         char *n;
2780
2781         table = &assembly->tables [MONO_TABLE_TYPEDEF];
2782         values = table->values + tb->table_idx * MONO_TYPEDEF_SIZE;
2783         values [MONO_TYPEDEF_FLAGS] = tb->attrs;
2784         n = mono_string_to_utf8 (tb->name);
2785         if (strcmp (n, "Object") == 0)
2786                 is_object++;
2787         values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, n);
2788         g_free (n);
2789         n = mono_string_to_utf8 (tb->nspace);
2790         if (strcmp (n, "System") == 0)
2791                 is_system++;
2792         values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, n);
2793         g_free (n);
2794         if (tb->parent && !(is_system && is_object) &&
2795                         !(tb->attrs & TYPE_ATTRIBUTE_INTERFACE)) { /* interfaces don't have a parent */
2796                 values [MONO_TYPEDEF_EXTENDS] = mono_image_typedef_or_ref (assembly, tb->parent->type);
2797         } else {
2798                 values [MONO_TYPEDEF_EXTENDS] = 0;
2799         }
2800         values [MONO_TYPEDEF_FIELD_LIST] = assembly->tables [MONO_TABLE_FIELD].next_idx;
2801         values [MONO_TYPEDEF_METHOD_LIST] = assembly->tables [MONO_TABLE_METHOD].next_idx;
2802
2803         /*
2804          * if we have explicitlayout or sequentiallayouts, output data in the
2805          * ClassLayout table.
2806          */
2807         if (((tb->attrs & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT) &&
2808                         ((tb->class_size > 0) || (tb->packing_size > 0))) {
2809                 table = &assembly->tables [MONO_TABLE_CLASSLAYOUT];
2810                 table->rows++;
2811                 alloc_table (table, table->rows);
2812                 values = table->values + table->rows * MONO_CLASS_LAYOUT_SIZE;
2813                 values [MONO_CLASS_LAYOUT_PARENT] = tb->table_idx;
2814                 values [MONO_CLASS_LAYOUT_CLASS_SIZE] = tb->class_size;
2815                 values [MONO_CLASS_LAYOUT_PACKING_SIZE] = tb->packing_size;
2816         }
2817
2818         /* handle interfaces */
2819         if (tb->interfaces) {
2820                 table = &assembly->tables [MONO_TABLE_INTERFACEIMPL];
2821                 i = table->rows;
2822                 table->rows += mono_array_length (tb->interfaces);
2823                 alloc_table (table, table->rows);
2824                 values = table->values + (i + 1) * MONO_INTERFACEIMPL_SIZE;
2825                 for (i = 0; i < mono_array_length (tb->interfaces); ++i) {
2826                         MonoReflectionType* iface = (MonoReflectionType*) mono_array_get (tb->interfaces, gpointer, i);
2827                         values [MONO_INTERFACEIMPL_CLASS] = tb->table_idx;
2828                         values [MONO_INTERFACEIMPL_INTERFACE] = mono_image_typedef_or_ref (assembly, iface->type);
2829                         values += MONO_INTERFACEIMPL_SIZE;
2830                 }
2831         }
2832
2833         /* handle fields */
2834         if (tb->fields) {
2835                 table = &assembly->tables [MONO_TABLE_FIELD];
2836                 table->rows += tb->num_fields;
2837                 alloc_table (table, table->rows);
2838                 for (i = 0; i < tb->num_fields; ++i)
2839                         mono_image_get_field_info (
2840                                 mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i), assembly);
2841         }
2842
2843         /* handle constructors */
2844         if (tb->ctors) {
2845                 table = &assembly->tables [MONO_TABLE_METHOD];
2846                 table->rows += mono_array_length (tb->ctors);
2847                 alloc_table (table, table->rows);
2848                 for (i = 0; i < mono_array_length (tb->ctors); ++i)
2849                         mono_image_get_ctor_info (domain,
2850                                 mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i), assembly);
2851         }
2852
2853         /* handle methods */
2854         if (tb->methods) {
2855                 table = &assembly->tables [MONO_TABLE_METHOD];
2856                 table->rows += tb->num_methods;
2857                 alloc_table (table, table->rows);
2858                 for (i = 0; i < tb->num_methods; ++i)
2859                         mono_image_get_method_info (
2860                                 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i), assembly);
2861         }
2862
2863         /* Do the same with properties etc.. */
2864         if (tb->events && mono_array_length (tb->events)) {
2865                 table = &assembly->tables [MONO_TABLE_EVENT];
2866                 table->rows += mono_array_length (tb->events);
2867                 alloc_table (table, table->rows);
2868                 table = &assembly->tables [MONO_TABLE_EVENTMAP];
2869                 table->rows ++;
2870                 alloc_table (table, table->rows);
2871                 values = table->values + table->rows * MONO_EVENT_MAP_SIZE;
2872                 values [MONO_EVENT_MAP_PARENT] = tb->table_idx;
2873                 values [MONO_EVENT_MAP_EVENTLIST] = assembly->tables [MONO_TABLE_EVENT].next_idx;
2874                 for (i = 0; i < mono_array_length (tb->events); ++i)
2875                         mono_image_get_event_info (
2876                                 mono_array_get (tb->events, MonoReflectionEventBuilder*, i), assembly);
2877         }
2878         if (tb->properties && mono_array_length (tb->properties)) {
2879                 table = &assembly->tables [MONO_TABLE_PROPERTY];
2880                 table->rows += mono_array_length (tb->properties);
2881                 alloc_table (table, table->rows);
2882                 table = &assembly->tables [MONO_TABLE_PROPERTYMAP];
2883                 table->rows ++;
2884                 alloc_table (table, table->rows);
2885                 values = table->values + table->rows * MONO_PROPERTY_MAP_SIZE;
2886                 values [MONO_PROPERTY_MAP_PARENT] = tb->table_idx;
2887                 values [MONO_PROPERTY_MAP_PROPERTY_LIST] = assembly->tables [MONO_TABLE_PROPERTY].next_idx;
2888                 for (i = 0; i < mono_array_length (tb->properties); ++i)
2889                         mono_image_get_property_info (
2890                                 mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i), assembly);
2891         }
2892
2893         /* handle generic parameters */
2894         if (tb->generic_params) {
2895                 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
2896                 table->rows += mono_array_length (tb->generic_params);
2897                 alloc_table (table, table->rows);
2898                 for (i = 0; i < mono_array_length (tb->generic_params); ++i) {
2899                         guint32 owner = MONO_TYPEORMETHOD_TYPE | (tb->table_idx << MONO_TYPEORMETHOD_BITS);
2900
2901                         mono_image_get_generic_param_info (
2902                                 mono_array_get (tb->generic_params, MonoReflectionGenericParam*, i), owner, assembly);
2903                 }
2904         }
2905
2906         mono_image_add_decl_security (assembly,
2907                 mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx), tb->permissions);
2908
2909         if (tb->subtypes) {
2910                 MonoDynamicTable *ntable;
2911
2912                 ntable = &assembly->tables [MONO_TABLE_NESTEDCLASS];
2913                 ntable->rows += mono_array_length (tb->subtypes);
2914                 alloc_table (ntable, ntable->rows);
2915                 values = ntable->values + ntable->next_idx * MONO_NESTED_CLASS_SIZE;
2916
2917                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
2918                         MonoReflectionTypeBuilder *subtype = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
2919
2920                         values [MONO_NESTED_CLASS_NESTED] = subtype->table_idx;
2921                         values [MONO_NESTED_CLASS_ENCLOSING] = tb->table_idx;
2922                         /*g_print ("nesting %s (%d) in %s (%d) (rows %d/%d)\n",
2923                                 mono_string_to_utf8 (subtype->name), subtype->table_idx,
2924                                 mono_string_to_utf8 (tb->name), tb->table_idx,
2925                                 ntable->next_idx, ntable->rows);*/
2926                         values += MONO_NESTED_CLASS_SIZE;
2927                         ntable->next_idx++;
2928                 }
2929         }
2930 }
2931
2932 static void
2933 collect_types (GPtrArray *types, MonoReflectionTypeBuilder *type)
2934 {
2935         int i;
2936
2937         g_ptr_array_add (types, type);
2938
2939         if (!type->subtypes)
2940                 return;
2941
2942         for (i = 0; i < mono_array_length (type->subtypes); ++i) {
2943                 MonoReflectionTypeBuilder *subtype = mono_array_get (type->subtypes, MonoReflectionTypeBuilder*, i);
2944                 collect_types (types, subtype);
2945         }
2946 }
2947
2948 static gint
2949 compare_types_by_table_idx (MonoReflectionTypeBuilder **type1, MonoReflectionTypeBuilder **type2)
2950 {
2951         if ((*type1)->table_idx < (*type2)->table_idx)
2952                 return -1;
2953         else
2954                 if ((*type1)->table_idx > (*type2)->table_idx)
2955                         return 1;
2956         else
2957                 return 0;
2958 }
2959
2960 static void
2961 params_add_cattrs (MonoDynamicImage *assembly, MonoArray *pinfo) {
2962         int i;
2963
2964         if (!pinfo)
2965                 return;
2966         for (i = 0; i < mono_array_length (pinfo); ++i) {
2967                 MonoReflectionParamBuilder *pb;
2968                 pb = mono_array_get (pinfo, MonoReflectionParamBuilder *, i);
2969                 if (!pb)
2970                         continue;
2971                 mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PARAMDEF, pb->cattrs);
2972         }
2973 }
2974
2975 static void
2976 type_add_cattrs (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb) {
2977         int i;
2978
2979         mono_image_add_cattrs (assembly, tb->table_idx, MONO_CUSTOM_ATTR_TYPEDEF, tb->cattrs);
2980         if (tb->fields) {
2981                 for (i = 0; i < tb->num_fields; ++i) {
2982                         MonoReflectionFieldBuilder* fb;
2983                         fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i);
2984                         mono_image_add_cattrs (assembly, fb->table_idx, MONO_CUSTOM_ATTR_FIELDDEF, fb->cattrs);
2985                 }
2986         }
2987         if (tb->events) {
2988                 for (i = 0; i < mono_array_length (tb->events); ++i) {
2989                         MonoReflectionEventBuilder* eb;
2990                         eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
2991                         mono_image_add_cattrs (assembly, eb->table_idx, MONO_CUSTOM_ATTR_EVENT, eb->cattrs);
2992                 }
2993         }
2994         if (tb->properties) {
2995                 for (i = 0; i < mono_array_length (tb->properties); ++i) {
2996                         MonoReflectionPropertyBuilder* pb;
2997                         pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
2998                         mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PROPERTY, pb->cattrs);
2999                 }
3000         }
3001         if (tb->ctors) {
3002                 for (i = 0; i < mono_array_length (tb->ctors); ++i) {
3003                         MonoReflectionCtorBuilder* cb;
3004                         cb = mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i);
3005                         mono_image_add_cattrs (assembly, cb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, cb->cattrs);
3006                         params_add_cattrs (assembly, cb->pinfo);
3007                 }
3008         }
3009
3010         if (tb->methods) {
3011                 for (i = 0; i < tb->num_methods; ++i) {
3012                         MonoReflectionMethodBuilder* mb;
3013                         mb = mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
3014                         mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, mb->cattrs);
3015                         params_add_cattrs (assembly, mb->pinfo);
3016                 }
3017         }
3018
3019         if (tb->subtypes) {
3020                 for (i = 0; i < mono_array_length (tb->subtypes); ++i)
3021                         type_add_cattrs (assembly, mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i));
3022         }
3023 }
3024
3025 static void
3026 module_add_cattrs (MonoDynamicImage *assembly, MonoReflectionModuleBuilder *mb) {
3027         int i;
3028
3029         mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_MODULE, mb->cattrs);
3030
3031         /* no types in the module */
3032         if (!mb->types)
3033                 return;
3034
3035         for (i = 0; i < mb->num_types; ++i)
3036                 type_add_cattrs (assembly, mono_array_get (mb->types, MonoReflectionTypeBuilder*, i));
3037 }
3038
3039 static void
3040 mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, MonoDynamicImage *assembly)
3041 {
3042         MonoDynamicTable *table;
3043         guint32 *values;
3044         char blob_size [6];
3045         guchar hash [20];
3046         char *b = blob_size;
3047         char *dir, *path;
3048
3049         table = &assembly->tables [MONO_TABLE_FILE];
3050         table->rows++;
3051         alloc_table (table, table->rows);
3052         values = table->values + table->next_idx * MONO_FILE_SIZE;
3053         values [MONO_FILE_FLAGS] = FILE_CONTAINS_METADATA;
3054         values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, module->image->module_name);
3055         if (module->image->dynamic) {
3056                 /* This depends on the fact that the main module is emitted last */
3057                 dir = mono_string_to_utf8 (((MonoReflectionModuleBuilder*)module)->assemblyb->dir);
3058                 path = g_strdup_printf ("%s%c%s", dir, G_DIR_SEPARATOR, module->image->module_name);
3059         } else {
3060                 dir = NULL;
3061                 path = g_strdup (module->image->name);
3062         }
3063         mono_sha1_get_digest_from_file (path, hash);
3064         g_free (dir);
3065         g_free (path);
3066         mono_metadata_encode_value (20, b, &b);
3067         values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
3068         mono_image_add_stream_data (&assembly->blob, hash, 20);
3069         table->next_idx ++;
3070 }
3071
3072 static void
3073 mono_image_fill_module_table (MonoDomain *domain, MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly)
3074 {
3075         MonoDynamicTable *table;
3076         int i;
3077         char *name;
3078
3079         table = &assembly->tables [MONO_TABLE_MODULE];
3080         mb->table_idx = table->next_idx ++;
3081         name = mono_string_to_utf8 (mb->module.name);
3082         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_NAME] = string_heap_insert (&assembly->sheap, name);
3083         g_free (name);
3084         i = mono_image_add_stream_data (&assembly->guid, mono_array_addr (mb->guid, char, 0), 16);
3085         i /= 16;
3086         ++i;
3087         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_MVID] = i;
3088         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_ENC] = 0;
3089         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_ENCBASE] = 0;
3090 }
3091
3092 static guint32
3093 mono_image_fill_export_table_from_class (MonoDomain *domain, MonoClass *klass,
3094         guint32 module_index, guint32 parent_index, MonoDynamicImage *assembly)
3095 {
3096         MonoDynamicTable *table;
3097         guint32 *values;
3098         guint32 visib, res;
3099
3100         visib = klass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
3101         if (! ((visib & TYPE_ATTRIBUTE_PUBLIC) || (visib & TYPE_ATTRIBUTE_NESTED_PUBLIC)))
3102                 return 0;
3103
3104         table = &assembly->tables [MONO_TABLE_EXPORTEDTYPE];
3105         table->rows++;
3106         alloc_table (table, table->rows);
3107         values = table->values + table->next_idx * MONO_EXP_TYPE_SIZE;
3108
3109         values [MONO_EXP_TYPE_FLAGS] = klass->flags;
3110         values [MONO_EXP_TYPE_TYPEDEF] = klass->type_token;
3111         if (klass->nested_in)
3112                 values [MONO_EXP_TYPE_IMPLEMENTATION] = (parent_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_EXP_TYPE;
3113         else
3114                 values [MONO_EXP_TYPE_IMPLEMENTATION] = (module_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_FILE;
3115         values [MONO_EXP_TYPE_NAME] = string_heap_insert (&assembly->sheap, klass->name);
3116         values [MONO_EXP_TYPE_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
3117
3118         res = table->next_idx;
3119
3120         table->next_idx ++;
3121
3122         /* Emit nested types */
3123         if (klass->nested_classes) {
3124                 GList *tmp;
3125
3126                 for (tmp = klass->nested_classes; tmp; tmp = tmp->next)
3127                         mono_image_fill_export_table_from_class (domain, tmp->data, module_index, table->next_idx - 1, assembly);
3128         }
3129
3130         return res;
3131 }
3132
3133 static void
3134 mono_image_fill_export_table (MonoDomain *domain, MonoReflectionTypeBuilder *tb,
3135         guint32 module_index, guint32 parent_index, MonoDynamicImage *assembly)
3136 {
3137         MonoClass *klass;
3138         guint32 idx, i;
3139
3140         klass = mono_class_from_mono_type (tb->type.type);
3141
3142         klass->type_token = mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx);
3143
3144         idx = mono_image_fill_export_table_from_class (domain, klass, module_index,
3145                                                                                                    parent_index, assembly);
3146
3147         /*
3148          * Emit nested types
3149          * We need to do this ourselves since klass->nested_classes is not set up.
3150          */
3151         if (tb->subtypes) {
3152                 for (i = 0; i < mono_array_length (tb->subtypes); ++i)
3153                         mono_image_fill_export_table (domain, mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i), module_index, idx, assembly);
3154         }
3155 }
3156
3157 static void
3158 mono_image_fill_export_table_from_module (MonoDomain *domain, MonoReflectionModule *module,
3159         guint32 module_index, MonoDynamicImage *assembly)
3160 {
3161         MonoImage *image = module->image;
3162         MonoTableInfo  *t;
3163         guint32 i;
3164
3165         t = &image->tables [MONO_TABLE_TYPEDEF];
3166
3167         for (i = 0; i < t->rows; ++i) {
3168                 MonoClass *klass = mono_class_get (image, mono_metadata_make_token (MONO_TABLE_TYPEDEF, i + 1));
3169
3170                 if (klass->flags & TYPE_ATTRIBUTE_PUBLIC)
3171                         mono_image_fill_export_table_from_class (domain, klass, module_index, 0, assembly);
3172         }
3173 }
3174
3175 #define align_pointer(base,p)\
3176         do {\
3177                 guint32 __diff = (unsigned char*)(p)-(unsigned char*)(base);\
3178                 if (__diff & 3)\
3179                         (p) += 4 - (__diff & 3);\
3180         } while (0)
3181
3182 static int
3183 compare_semantics (const void *a, const void *b)
3184 {
3185         const guint32 *a_values = a;
3186         const guint32 *b_values = b;
3187         int assoc = a_values [MONO_METHOD_SEMA_ASSOCIATION] - b_values [MONO_METHOD_SEMA_ASSOCIATION];
3188         if (assoc)
3189                 return assoc;
3190         return a_values [MONO_METHOD_SEMA_SEMANTICS] - b_values [MONO_METHOD_SEMA_SEMANTICS];
3191 }
3192
3193 static int
3194 compare_custom_attrs (const void *a, const void *b)
3195 {
3196         const guint32 *a_values = a;
3197         const guint32 *b_values = b;
3198
3199         return a_values [MONO_CUSTOM_ATTR_PARENT] - b_values [MONO_CUSTOM_ATTR_PARENT];
3200 }
3201
3202 static int
3203 compare_field_marshal (const void *a, const void *b)
3204 {
3205         const guint32 *a_values = a;
3206         const guint32 *b_values = b;
3207
3208         return a_values [MONO_FIELD_MARSHAL_PARENT] - b_values [MONO_FIELD_MARSHAL_PARENT];
3209 }
3210
3211 static int
3212 compare_nested (const void *a, const void *b)
3213 {
3214         const guint32 *a_values = a;
3215         const guint32 *b_values = b;
3216
3217         return a_values [MONO_NESTED_CLASS_NESTED] - b_values [MONO_NESTED_CLASS_NESTED];
3218 }
3219
3220 static int
3221 compare_genericparam (const void *a, const void *b)
3222 {
3223         const GenericParamTableEntry **a_entry = (const GenericParamTableEntry **) a;
3224         const GenericParamTableEntry **b_entry = (const GenericParamTableEntry **) b;
3225
3226         return (*a_entry)->owner - (*b_entry)->owner;
3227 }
3228
3229 static int
3230 compare_declsecurity_attrs (const void *a, const void *b)
3231 {
3232         const guint32 *a_values = a;
3233         const guint32 *b_values = b;
3234
3235         return a_values [MONO_DECL_SECURITY_PARENT] - b_values [MONO_DECL_SECURITY_PARENT];
3236 }
3237
3238 static void
3239 pad_heap (MonoDynamicStream *sh)
3240 {
3241         if (sh->index & 3) {
3242                 int sz = 4 - (sh->index & 3);
3243                 memset (sh->data + sh->index, 0, sz);
3244                 sh->index += sz;
3245         }
3246 }
3247
3248 struct StreamDesc {
3249         const char *name;
3250         MonoDynamicStream *stream;
3251 };
3252
3253 /*
3254  * build_compressed_metadata() fills in the blob of data that represents the
3255  * raw metadata as it will be saved in the PE file. The five streams are output
3256  * and the metadata tables are comnpressed from the guint32 array representation,
3257  * to the compressed on-disk format.
3258  */
3259 static void
3260 build_compressed_metadata (MonoDynamicImage *assembly)
3261 {
3262         MonoDynamicTable *table;
3263         int i;
3264         guint64 valid_mask = 0;
3265         guint64 sorted_mask;
3266         guint32 heapt_size = 0;
3267         guint32 meta_size = 256; /* allow for header and other stuff */
3268         guint32 table_offset;
3269         guint32 ntables = 0;
3270         guint64 *int64val;
3271         guint32 *int32val;
3272         guint16 *int16val;
3273         MonoImage *meta;
3274         unsigned char *p;
3275         struct StreamDesc stream_desc [5];
3276
3277         qsort (assembly->gen_params->pdata, assembly->gen_params->len, sizeof (gpointer), compare_genericparam);
3278         for (i = 0; i < assembly->gen_params->len; i++){
3279                 GenericParamTableEntry *entry = g_ptr_array_index (assembly->gen_params, i);
3280                 write_generic_param_entry (assembly, entry);
3281         }
3282
3283         stream_desc [0].name  = "#~";
3284         stream_desc [0].stream = &assembly->tstream;
3285         stream_desc [1].name  = "#Strings";
3286         stream_desc [1].stream = &assembly->sheap;
3287         stream_desc [2].name  = "#US";
3288         stream_desc [2].stream = &assembly->us;
3289         stream_desc [3].name  = "#Blob";
3290         stream_desc [3].stream = &assembly->blob;
3291         stream_desc [4].name  = "#GUID";
3292         stream_desc [4].stream = &assembly->guid;
3293
3294         /* tables that are sorted */
3295         sorted_mask = ((guint64)1 << MONO_TABLE_CONSTANT) | ((guint64)1 << MONO_TABLE_FIELDMARSHAL)
3296                 | ((guint64)1 << MONO_TABLE_METHODSEMANTICS) | ((guint64)1 << MONO_TABLE_CLASSLAYOUT)
3297                 | ((guint64)1 << MONO_TABLE_FIELDLAYOUT) | ((guint64)1 << MONO_TABLE_FIELDRVA)
3298                 | ((guint64)1 << MONO_TABLE_IMPLMAP) | ((guint64)1 << MONO_TABLE_NESTEDCLASS)
3299                 | ((guint64)1 << MONO_TABLE_METHODIMPL) | ((guint64)1 << MONO_TABLE_CUSTOMATTRIBUTE)
3300                 | ((guint64)1 << MONO_TABLE_DECLSECURITY) | ((guint64)1 << MONO_TABLE_GENERICPARAM);
3301
3302         /* Compute table sizes */
3303         /* the MonoImage has already been created in mono_image_basic_init() */
3304         meta = &assembly->image;
3305
3306         /* sizes should be multiple of 4 */
3307         pad_heap (&assembly->blob);
3308         pad_heap (&assembly->guid);
3309         pad_heap (&assembly->sheap);
3310         pad_heap (&assembly->us);
3311
3312         /* Setup the info used by compute_sizes () */
3313         meta->idx_blob_wide = assembly->blob.index >= 65536 ? 1 : 0;
3314         meta->idx_guid_wide = assembly->guid.index >= 65536 ? 1 : 0;
3315         meta->idx_string_wide = assembly->sheap.index >= 65536 ? 1 : 0;
3316
3317         meta_size += assembly->blob.index;
3318         meta_size += assembly->guid.index;
3319         meta_size += assembly->sheap.index;
3320         meta_size += assembly->us.index;
3321
3322         for (i=0; i < 64; ++i)
3323                 meta->tables [i].rows = assembly->tables [i].rows;
3324
3325         for (i = 0; i < 64; i++){
3326                 if (meta->tables [i].rows == 0)
3327                         continue;
3328                 valid_mask |= (guint64)1 << i;
3329                 ntables ++;
3330                 meta->tables [i].row_size = mono_metadata_compute_size (
3331                         meta, i, &meta->tables [i].size_bitfield);
3332                 heapt_size += meta->tables [i].row_size * meta->tables [i].rows;
3333         }
3334         heapt_size += 24; /* #~ header size */
3335         heapt_size += ntables * 4;
3336         /* make multiple of 4 */
3337         heapt_size += 3;
3338         heapt_size &= ~3;
3339         meta_size += heapt_size;
3340         meta->raw_metadata = g_malloc0 (meta_size);
3341         p = meta->raw_metadata;
3342         /* the metadata signature */
3343         *p++ = 'B'; *p++ = 'S'; *p++ = 'J'; *p++ = 'B';
3344         /* version numbers and 4 bytes reserved */
3345         int16val = (guint16*)p;
3346         *int16val++ = GUINT16_TO_LE (1);
3347         *int16val = GUINT16_TO_LE (1);
3348         p += 8;
3349         /* version string */
3350         int32val = (guint32*)p;
3351         *int32val = GUINT32_TO_LE ((strlen (meta->version) + 3) & (~3)); /* needs to be multiple of 4 */
3352         p += 4;
3353         memcpy (p, meta->version, strlen (meta->version));
3354         p += GUINT32_FROM_LE (*int32val);
3355         align_pointer (meta->raw_metadata, p);
3356         int16val = (guint16*)p;
3357         *int16val++ = GUINT16_TO_LE (0); /* flags must be 0 */
3358         *int16val = GUINT16_TO_LE (5); /* number of streams */
3359         p += 4;
3360
3361         /*
3362          * write the stream info.
3363          */
3364         table_offset = (p - (unsigned char*)meta->raw_metadata) + 5 * 8 + 40; /* room needed for stream headers */
3365         table_offset += 3; table_offset &= ~3;
3366
3367         assembly->tstream.index = heapt_size;
3368         for (i = 0; i < 5; ++i) {
3369                 int32val = (guint32*)p;
3370                 stream_desc [i].stream->offset = table_offset;
3371                 *int32val++ = GUINT32_TO_LE (table_offset);
3372                 *int32val = GUINT32_TO_LE (stream_desc [i].stream->index);
3373                 table_offset += GUINT32_FROM_LE (*int32val);
3374                 table_offset += 3; table_offset &= ~3;
3375                 p += 8;
3376                 strcpy (p, stream_desc [i].name);
3377                 p += strlen (stream_desc [i].name) + 1;
3378                 align_pointer (meta->raw_metadata, p);
3379         }
3380         /*
3381          * now copy the data, the table stream header and contents goes first.
3382          */
3383         g_assert ((p - (unsigned char*)meta->raw_metadata) < assembly->tstream.offset);
3384         p = meta->raw_metadata + assembly->tstream.offset;
3385         int32val = (guint32*)p;
3386         *int32val = GUINT32_TO_LE (0); /* reserved */
3387         p += 4;
3388
3389         if ((assembly->tables [MONO_TABLE_GENERICPARAM].rows > 0) ||
3390                         (assembly->tables [MONO_TABLE_METHODSPEC].rows > 0) ||
3391                         (assembly->tables [MONO_TABLE_GENERICPARAMCONSTRAINT].rows > 0)) {
3392                 *p++ = 1; /* version */
3393                 *p++ = 1;
3394         } else {
3395                 *p++ = 1; /* version */
3396                 *p++ = 0;
3397         }
3398
3399         if (meta->idx_string_wide)
3400                 *p |= 0x01;
3401         if (meta->idx_guid_wide)
3402                 *p |= 0x02;
3403         if (meta->idx_blob_wide)
3404                 *p |= 0x04;
3405         ++p;
3406         *p++ = 1; /* reserved */
3407         int64val = (guint64*)p;
3408         *int64val++ = GUINT64_TO_LE (valid_mask);
3409         *int64val++ = GUINT64_TO_LE (valid_mask & sorted_mask); /* bitvector of sorted tables  */
3410         p += 16;
3411         int32val = (guint32*)p;
3412         for (i = 0; i < 64; i++){
3413                 if (meta->tables [i].rows == 0)
3414                         continue;
3415                 *int32val++ = GUINT32_TO_LE (meta->tables [i].rows);
3416         }
3417         p = (unsigned char*)int32val;
3418
3419         /* sort the tables that still need sorting */
3420         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
3421         if (table->rows)
3422                 qsort (table->values + MONO_METHOD_SEMA_SIZE, table->rows, sizeof (guint32) * MONO_METHOD_SEMA_SIZE, compare_semantics);
3423         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
3424         if (table->rows)
3425                 qsort (table->values + MONO_CUSTOM_ATTR_SIZE, table->rows, sizeof (guint32) * MONO_CUSTOM_ATTR_SIZE, compare_custom_attrs);
3426         table = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
3427         if (table->rows)
3428                 qsort (table->values + MONO_FIELD_MARSHAL_SIZE, table->rows, sizeof (guint32) * MONO_FIELD_MARSHAL_SIZE, compare_field_marshal);
3429         table = &assembly->tables [MONO_TABLE_NESTEDCLASS];
3430         if (table->rows)
3431                 qsort (table->values + MONO_NESTED_CLASS_SIZE, table->rows, sizeof (guint32) * MONO_NESTED_CLASS_SIZE, compare_nested);
3432         /* Section 21.11 DeclSecurity in Partition II doesn't specify this to be sorted by MS implementation requires it */
3433         table = &assembly->tables [MONO_TABLE_DECLSECURITY];
3434         if (table->rows)
3435                 qsort (table->values + MONO_DECL_SECURITY_SIZE, table->rows, sizeof (guint32) * MONO_DECL_SECURITY_SIZE, compare_declsecurity_attrs);
3436
3437         /* compress the tables */
3438         for (i = 0; i < 64; i++){
3439                 int row, col;
3440                 guint32 *values;
3441                 guint32 bitfield = meta->tables [i].size_bitfield;
3442                 if (!meta->tables [i].rows)
3443                         continue;
3444                 if (assembly->tables [i].columns != mono_metadata_table_count (bitfield))
3445                         g_error ("col count mismatch in %d: %d %d", i, assembly->tables [i].columns, mono_metadata_table_count (bitfield));
3446                 meta->tables [i].base = p;
3447                 for (row = 1; row <= meta->tables [i].rows; ++row) {
3448                         values = assembly->tables [i].values + row * assembly->tables [i].columns;
3449                         for (col = 0; col < assembly->tables [i].columns; ++col) {
3450                                 switch (mono_metadata_table_size (bitfield, col)) {
3451                                 case 1:
3452                                         *p++ = values [col];
3453                                         break;
3454                                 case 2:
3455                                         *p++ = values [col] & 0xff;
3456                                         *p++ = (values [col] >> 8) & 0xff;
3457                                         break;
3458                                 case 4:
3459                                         *p++ = values [col] & 0xff;
3460                                         *p++ = (values [col] >> 8) & 0xff;
3461                                         *p++ = (values [col] >> 16) & 0xff;
3462                                         *p++ = (values [col] >> 24) & 0xff;
3463                                         break;
3464                                 default:
3465                                         g_assert_not_reached ();
3466                                 }
3467                         }
3468                 }
3469                 g_assert ((p - (const unsigned char*)meta->tables [i].base) == (meta->tables [i].rows * meta->tables [i].row_size));
3470         }
3471
3472         g_assert (assembly->guid.offset + assembly->guid.index < meta_size);
3473         memcpy (meta->raw_metadata + assembly->sheap.offset, assembly->sheap.data, assembly->sheap.index);
3474         memcpy (meta->raw_metadata + assembly->us.offset, assembly->us.data, assembly->us.index);
3475         memcpy (meta->raw_metadata + assembly->blob.offset, assembly->blob.data, assembly->blob.index);
3476         memcpy (meta->raw_metadata + assembly->guid.offset, assembly->guid.data, assembly->guid.index);
3477
3478         assembly->meta_size = assembly->guid.offset + assembly->guid.index;
3479 }
3480
3481 /*
3482  * Some tables in metadata need to be sorted according to some criteria, but
3483  * when methods and fields are first created with reflection, they may be assigned a token
3484  * that doesn't correspond to the final token they will get assigned after the sorting.
3485  * ILGenerator.cs keeps a fixup table that maps the position of tokens in the IL code stream
3486  * with the reflection objects that represent them. Once all the tables are set up, the
3487  * reflection objects will contains the correct table index. fixup_method() will fixup the
3488  * tokens for the method with ILGenerator @ilgen.
3489  */
3490 static void
3491 fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *assembly) {
3492         guint32 code_idx = GPOINTER_TO_UINT (value);
3493         MonoReflectionILTokenInfo *iltoken;
3494         MonoReflectionFieldBuilder *field;
3495         MonoReflectionCtorBuilder *ctor;
3496         MonoReflectionMethodBuilder *method;
3497         MonoReflectionTypeBuilder *tb;
3498         MonoReflectionArrayMethod *am;
3499         guint32 i, idx = 0;
3500         unsigned char *target;
3501
3502         for (i = 0; i < ilgen->num_token_fixups; ++i) {
3503                 iltoken = (MonoReflectionILTokenInfo *)mono_array_addr_with_size (ilgen->token_fixups, sizeof (MonoReflectionILTokenInfo), i);
3504                 target = assembly->code.data + code_idx + iltoken->code_pos;
3505                 switch (target [3]) {
3506                 case MONO_TABLE_FIELD:
3507                         if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
3508                                 field = (MonoReflectionFieldBuilder *)iltoken->member;
3509                                 idx = field->table_idx;
3510                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) {
3511                                 MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field;
3512                                 idx = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->field_to_table_idx, f));
3513                         } else {
3514                                 g_assert_not_reached ();
3515                         }
3516                         break;
3517                 case MONO_TABLE_METHOD:
3518                         if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) {
3519                                 method = (MonoReflectionMethodBuilder *)iltoken->member;
3520                                 idx = method->table_idx;
3521                         } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) {
3522                                 ctor = (MonoReflectionCtorBuilder *)iltoken->member;
3523                                 idx = ctor->table_idx;
3524                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
3525                                            !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) {
3526                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
3527                                 idx = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->method_to_table_idx, m));
3528                         } else {
3529                                 g_assert_not_reached ();
3530                         }
3531                         break;
3532                 case MONO_TABLE_TYPEDEF:
3533                         if (strcmp (iltoken->member->vtable->klass->name, "TypeBuilder"))
3534                                 g_assert_not_reached ();
3535                         tb = (MonoReflectionTypeBuilder *)iltoken->member;
3536                         idx = tb->table_idx;
3537                         break;
3538                 case MONO_TABLE_MEMBERREF:
3539                         if (!strcmp (iltoken->member->vtable->klass->name, "MonoArrayMethod")) {
3540                                 am = (MonoReflectionArrayMethod*)iltoken->member;
3541                                 idx = am->table_idx;
3542                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
3543                                    !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) {
3544                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
3545                                 g_assert (m->klass->generic_inst);
3546                                 continue;
3547                         } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
3548                                 continue;
3549                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) {
3550                                 MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field;
3551                                 g_assert (f->generic_info);
3552                                 continue;
3553                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) {
3554                                 continue;
3555                         } else {
3556                                 g_assert_not_reached ();
3557                         }
3558                         break;
3559                 case MONO_TABLE_METHODSPEC:
3560                         if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod")) {
3561                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
3562                                 g_assert (m->signature->generic_param_count);
3563                                 continue;
3564                         } else {
3565                                 g_assert_not_reached ();
3566                         }
3567                         break;
3568                 default:
3569                         g_error ("got unexpected table 0x%02x in fixup", target [3]);
3570                 }
3571                 target [0] = idx & 0xff;
3572                 target [1] = (idx >> 8) & 0xff;
3573                 target [2] = (idx >> 16) & 0xff;
3574         }
3575 }
3576
3577 /*
3578  * fixup_cattrs:
3579  *
3580  *   The CUSTOM_ATTRIBUTE table might contain METHODDEF tokens whose final
3581  * value is not known when the table is emitted.
3582  */
3583 static void
3584 fixup_cattrs (MonoDynamicImage *assembly)
3585 {
3586         MonoDynamicTable *table;
3587         guint32 *values;
3588         guint32 type, i, idx, token;
3589         MonoObject *ctor;
3590
3591         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
3592
3593         for (i = 0; i < table->rows; ++i) {
3594                 values = table->values + ((i + 1) * MONO_CUSTOM_ATTR_SIZE);
3595
3596                 type = values [MONO_CUSTOM_ATTR_TYPE];
3597                 if ((type & MONO_CUSTOM_ATTR_TYPE_MASK) == MONO_CUSTOM_ATTR_TYPE_METHODDEF) {
3598                         idx = type >> MONO_CUSTOM_ATTR_TYPE_BITS;
3599                         token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
3600                         ctor = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
3601                         g_assert (ctor);
3602
3603                         if (!strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
3604                                 MonoMethod *m = ((MonoReflectionMethod*)ctor)->method;
3605                                 idx = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->method_to_table_idx, m));
3606                                 values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
3607                         }
3608                 }
3609         }
3610 }
3611
3612 static void
3613 assembly_add_resource_manifest (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc, guint32 implementation)
3614 {
3615         MonoDynamicTable *table;
3616         guint32 *values;
3617         char *name;
3618
3619         table = &assembly->tables [MONO_TABLE_MANIFESTRESOURCE];
3620         table->rows++;
3621         alloc_table (table, table->rows);
3622         values = table->values + table->next_idx * MONO_MANIFEST_SIZE;
3623         values [MONO_MANIFEST_OFFSET] = rsrc->offset;
3624         values [MONO_MANIFEST_FLAGS] = rsrc->attrs;
3625         name = mono_string_to_utf8 (rsrc->name);
3626         values [MONO_MANIFEST_NAME] = string_heap_insert (&assembly->sheap, name);
3627         g_free (name);
3628         values [MONO_MANIFEST_IMPLEMENTATION] = implementation;
3629         table->next_idx++;
3630 }
3631
3632 static void
3633 assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc)
3634 {
3635         MonoDynamicTable *table;
3636         guint32 *values;
3637         char blob_size [6];
3638         guchar hash [20];
3639         char *b = blob_size;
3640         char *name, *sname;
3641         guint32 idx, offset;
3642
3643         if (rsrc->filename) {
3644                 name = mono_string_to_utf8 (rsrc->filename);
3645                 sname = g_path_get_basename (name);
3646
3647                 table = &assembly->tables [MONO_TABLE_FILE];
3648                 table->rows++;
3649                 alloc_table (table, table->rows);
3650                 values = table->values + table->next_idx * MONO_FILE_SIZE;
3651                 values [MONO_FILE_FLAGS] = FILE_CONTAINS_NO_METADATA;
3652                 values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, sname);
3653                 g_free (sname);
3654
3655                 mono_sha1_get_digest_from_file (name, hash);
3656                 mono_metadata_encode_value (20, b, &b);
3657                 values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
3658                 mono_image_add_stream_data (&assembly->blob, hash, 20);
3659                 g_free (name);
3660                 idx = table->next_idx++;
3661                 rsrc->offset = 0;
3662                 idx = MONO_IMPLEMENTATION_FILE | (idx << MONO_IMPLEMENTATION_BITS);
3663         } else {
3664                 char sizebuf [4];
3665                 offset = mono_array_length (rsrc->data);
3666                 sizebuf [0] = offset; sizebuf [1] = offset >> 8;
3667                 sizebuf [2] = offset >> 16; sizebuf [3] = offset >> 24;
3668                 rsrc->offset = mono_image_add_stream_data (&assembly->resources, sizebuf, 4);
3669                 mono_image_add_stream_data (&assembly->resources, mono_array_addr (rsrc->data, char, 0), mono_array_length (rsrc->data));
3670
3671                 if (!mb->is_main)
3672                         /*
3673                          * The entry should be emitted into the MANIFESTRESOURCE table of
3674                          * the main module, but that needs to reference the FILE table
3675                          * which isn't emitted yet.
3676                          */
3677                         return;
3678                 else
3679                         idx = 0;
3680         }
3681
3682         assembly_add_resource_manifest (mb, assembly, rsrc, idx);
3683 }
3684
3685 static void
3686 set_version_from_string (MonoString *version, guint32 *values)
3687 {
3688         gchar *ver, *p, *str;
3689         guint32 i;
3690
3691         values [MONO_ASSEMBLY_MAJOR_VERSION] = 0;
3692         values [MONO_ASSEMBLY_MINOR_VERSION] = 0;
3693         values [MONO_ASSEMBLY_REV_NUMBER] = 0;
3694         values [MONO_ASSEMBLY_BUILD_NUMBER] = 0;
3695         if (!version)
3696                 return;
3697         ver = str = mono_string_to_utf8 (version);
3698         for (i = 0; i < 4; ++i) {
3699                 values [MONO_ASSEMBLY_MAJOR_VERSION + i] = strtol (ver, &p, 10);
3700                 switch (*p) {
3701                 case '.':
3702                         p++;
3703                         break;
3704                 case '*':
3705                         /* handle Revision and Build */
3706                         p++;
3707                         break;
3708                 }
3709                 ver = p;
3710         }
3711         g_free (str);
3712 }
3713
3714 static guint32
3715 load_public_key (MonoArray *pkey, MonoDynamicImage *assembly) {
3716         gsize len;
3717         guint32 token = 0;
3718         char blob_size [6];
3719         char *b = blob_size;
3720
3721         if (!pkey)
3722                 return token;
3723
3724         len = mono_array_length (pkey);
3725         mono_metadata_encode_value (len, b, &b);
3726         token = mono_image_add_stream_data (&assembly->blob, blob_size, b - blob_size);
3727         mono_image_add_stream_data (&assembly->blob, mono_array_addr (pkey, guint8, 0), len);
3728
3729         /* need to get the actual value from the key type... */
3730         assembly->strong_name_size = 128;
3731         assembly->strong_name = g_malloc0 (assembly->strong_name_size);
3732
3733         return token;
3734 }
3735
3736 static void
3737 mono_image_emit_manifest (MonoReflectionModuleBuilder *moduleb)
3738 {
3739         MonoDynamicTable *table;
3740         MonoDynamicImage *assembly;
3741         MonoReflectionAssemblyBuilder *assemblyb;
3742         MonoDomain *domain;
3743         guint32 *values;
3744         char *name;
3745         int i;
3746         guint32 module_index;
3747
3748         assemblyb = moduleb->assemblyb;
3749         assembly = moduleb->dynamic_image;
3750         domain = mono_object_domain (assemblyb);
3751
3752         /* Emit ASSEMBLY table */
3753         table = &assembly->tables [MONO_TABLE_ASSEMBLY];
3754         alloc_table (table, 1);
3755         values = table->values + MONO_ASSEMBLY_SIZE;
3756         values [MONO_ASSEMBLY_HASH_ALG] = assemblyb->algid? assemblyb->algid: ASSEMBLY_HASH_SHA1;
3757         name = mono_string_to_utf8 (assemblyb->name);
3758         values [MONO_ASSEMBLY_NAME] = string_heap_insert (&assembly->sheap, name);
3759         g_free (name);
3760         if (assemblyb->culture) {
3761                 name = mono_string_to_utf8 (assemblyb->culture);
3762                 values [MONO_ASSEMBLY_CULTURE] = string_heap_insert (&assembly->sheap, name);
3763                 g_free (name);
3764         } else {
3765                 values [MONO_ASSEMBLY_CULTURE] = string_heap_insert (&assembly->sheap, "");
3766         }
3767         values [MONO_ASSEMBLY_PUBLIC_KEY] = load_public_key (assemblyb->public_key, assembly);
3768         values [MONO_ASSEMBLY_FLAGS] = assemblyb->flags;
3769         set_version_from_string (assemblyb->version, values);
3770
3771         /* Emit FILE + EXPORTED_TYPE table */
3772         module_index = 0;
3773         for (i = 0; i < mono_array_length (assemblyb->modules); ++i) {
3774                 int j;
3775                 MonoReflectionModuleBuilder *file_module =
3776                         mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
3777                 if (file_module != moduleb) {
3778                         mono_image_fill_file_table (domain, (MonoReflectionModule*)file_module, assembly);
3779                         module_index ++;
3780                         if (file_module->types) {
3781                                 for (j = 0; j < file_module->num_types; ++j) {
3782                                         MonoReflectionTypeBuilder *tb = mono_array_get (file_module->types, MonoReflectionTypeBuilder*, j);
3783                                         mono_image_fill_export_table (domain, tb, module_index, 0, assembly);
3784                                 }
3785                         }
3786                 }
3787         }
3788         if (assemblyb->loaded_modules) {
3789                 for (i = 0; i < mono_array_length (assemblyb->loaded_modules); ++i) {
3790                         MonoReflectionModule *file_module =
3791                                 mono_array_get (assemblyb->loaded_modules, MonoReflectionModule*, i);
3792                         mono_image_fill_file_table (domain, file_module, assembly);
3793                         module_index ++;
3794                         mono_image_fill_export_table_from_module (domain, file_module, module_index, assembly);
3795                 }
3796         }
3797
3798         /* Emit MANIFESTRESOURCE table */
3799         module_index = 0;
3800         for (i = 0; i < mono_array_length (assemblyb->modules); ++i) {
3801                 int j;
3802                 MonoReflectionModuleBuilder *file_module =
3803                         mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
3804                 /* The table for the main module is emitted later */
3805                 if (file_module != moduleb) {
3806                         module_index ++;
3807                         if (file_module->resources) {
3808                                 int len = mono_array_length (file_module->resources);
3809                                 for (j = 0; j < len; ++j) {
3810                                         MonoReflectionResource* res = (MonoReflectionResource*)mono_array_addr (file_module->resources, MonoReflectionResource, j);
3811                                         assembly_add_resource_manifest (file_module, assembly, res, MONO_IMPLEMENTATION_FILE | (module_index << MONO_IMPLEMENTATION_BITS));
3812                                 }
3813                         }
3814                 }
3815         }
3816 }
3817
3818 /*
3819  * mono_image_build_metadata() will fill the info in all the needed metadata tables
3820  * for the modulebuilder @moduleb.
3821  * At the end of the process, method and field tokens are fixed up and the
3822  * on-disk compressed metadata representation is created.
3823  */
3824 void
3825 mono_image_build_metadata (MonoReflectionModuleBuilder *moduleb)
3826 {
3827         MonoDynamicTable *table;
3828         MonoDynamicImage *assembly;
3829         MonoReflectionAssemblyBuilder *assemblyb;
3830         MonoDomain *domain;
3831         guint32 *values;
3832         int i;
3833
3834         assemblyb = moduleb->assemblyb;
3835         assembly = moduleb->dynamic_image;
3836         domain = mono_object_domain (assemblyb);
3837
3838         if (assembly->text_rva)
3839                 return;
3840
3841         assembly->text_rva = START_TEXT_RVA;
3842
3843         if (moduleb->is_main) {
3844                 mono_image_emit_manifest (moduleb);
3845         }
3846
3847         table = &assembly->tables [MONO_TABLE_TYPEDEF];
3848         table->rows = 1; /* .<Module> */
3849         table->next_idx++;
3850         alloc_table (table, table->rows);
3851         /*
3852          * Set the first entry.
3853          */
3854         values = table->values + table->columns;
3855         values [MONO_TYPEDEF_FLAGS] = 0;
3856         values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, "<Module>") ;
3857         values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, "") ;
3858         values [MONO_TYPEDEF_EXTENDS] = 0;
3859         values [MONO_TYPEDEF_FIELD_LIST] = 1;
3860         values [MONO_TYPEDEF_METHOD_LIST] = 1;
3861
3862         /*
3863          * handle global methods
3864          * FIXME: test what to do when global methods are defined in multiple modules.
3865          */
3866         if (moduleb->global_methods) {
3867                 table = &assembly->tables [MONO_TABLE_METHOD];
3868                 table->rows += mono_array_length (moduleb->global_methods);
3869                 alloc_table (table, table->rows);
3870                 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i)
3871                         mono_image_get_method_info (
3872                                 mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i), assembly);
3873         }
3874         if (moduleb->global_fields) {
3875                 table = &assembly->tables [MONO_TABLE_FIELD];
3876                 table->rows += mono_array_length (moduleb->global_fields);
3877                 alloc_table (table, table->rows);
3878                 for (i = 0; i < mono_array_length (moduleb->global_fields); ++i)
3879                         mono_image_get_field_info (
3880                                 mono_array_get (moduleb->global_fields, MonoReflectionFieldBuilder*, i), assembly);
3881         }
3882
3883         table = &assembly->tables [MONO_TABLE_MODULE];
3884         alloc_table (table, 1);
3885         mono_image_fill_module_table (domain, moduleb, assembly);
3886
3887         /* Emit types */
3888         {
3889                 /* Collect all types into a list sorted by their table_idx */
3890                 GPtrArray *types = g_ptr_array_new ();
3891
3892                 if (moduleb->types)
3893                         for (i = 0; i < moduleb->num_types; ++i) {
3894                                 MonoReflectionTypeBuilder *type = mono_array_get (moduleb->types, MonoReflectionTypeBuilder*, i);
3895                                 collect_types (types, type);
3896                         }
3897
3898                 g_ptr_array_sort (types, (GCompareFunc)compare_types_by_table_idx);
3899                 table = &assembly->tables [MONO_TABLE_TYPEDEF];
3900                 table->rows += types->len;
3901                 alloc_table (table, table->rows);
3902
3903                 for (i = 0; i < types->len; ++i) {
3904                         MonoReflectionTypeBuilder *type = g_ptr_array_index (types, i);
3905                         mono_image_get_type_info (domain, type, assembly);
3906                 }
3907                 g_ptr_array_free (types, TRUE);
3908         }
3909
3910         /*
3911          * table->rows is already set above and in mono_image_fill_module_table.
3912          */
3913         /* add all the custom attributes at the end, once all the indexes are stable */
3914         mono_image_add_cattrs (assembly, 1, MONO_CUSTOM_ATTR_ASSEMBLY, assemblyb->cattrs);
3915
3916         /* CAS assembly permissions */
3917         if (assemblyb->permissions_minimum)
3918                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_minimum);
3919         if (assemblyb->permissions_optional)
3920                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_optional);
3921         if (assemblyb->permissions_refused)
3922                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_refused);
3923
3924         module_add_cattrs (assembly, moduleb);
3925
3926         /* fixup tokens */
3927         mono_g_hash_table_foreach (assembly->token_fixups, (GHFunc)fixup_method, assembly);
3928         fixup_cattrs (assembly);
3929 }
3930
3931 /*
3932  * mono_image_insert_string:
3933  * @module: module builder object
3934  * @str: a string
3935  *
3936  * Insert @str into the user string stream of @module.
3937  */
3938 guint32
3939 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str)
3940 {
3941         MonoDynamicImage *assembly;
3942         guint32 idx;
3943         char buf [16];
3944         char *b = buf;
3945
3946         MONO_ARCH_SAVE_REGS;
3947
3948         if (!module->dynamic_image)
3949                 mono_image_module_basic_init (module);
3950
3951         assembly = module->dynamic_image;
3952
3953         if (assembly->save) {
3954                 mono_metadata_encode_value (1 | (str->length * 2), b, &b);
3955                 idx = mono_image_add_stream_data (&assembly->us, buf, b-buf);
3956 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
3957         {
3958                 char *swapped = g_malloc (2 * mono_string_length (str));
3959                 const char *p = (const char*)mono_string_chars (str);
3960
3961                 swap_with_size (swapped, p, 2, mono_string_length (str));
3962                 mono_image_add_stream_data (&assembly->us, swapped, str->length * 2);
3963                 g_free (swapped);
3964         }
3965 #else
3966                 mono_image_add_stream_data (&assembly->us, (const char*)mono_string_chars (str), str->length * 2);
3967 #endif
3968                 mono_image_add_stream_data (&assembly->us, "", 1);
3969         } else {
3970                 idx = assembly->us.index ++;
3971         }
3972
3973         mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (MONO_TOKEN_STRING | idx), str);
3974
3975         return MONO_TOKEN_STRING | idx;
3976 }
3977
3978 guint32
3979 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types)
3980 {
3981         MonoClass *klass;
3982         guint32 token = 0;
3983
3984         klass = obj->vtable->klass;
3985         if (strcmp (klass->name, "MonoMethod") == 0) {
3986                 MonoMethod *method = ((MonoReflectionMethod *)obj)->method;
3987                 MonoMethodSignature *sig, *old;
3988                 guint32 sig_token, parent;
3989                 int nargs, i;
3990
3991                 g_assert (opt_param_types && (method->signature->sentinelpos >= 0));
3992
3993                 nargs = mono_array_length (opt_param_types);
3994                 old = method->signature;
3995                 sig = mono_metadata_signature_alloc ( &assembly->image, old->param_count + nargs);
3996
3997                 sig->hasthis = old->hasthis;
3998                 sig->explicit_this = old->explicit_this;
3999                 sig->call_convention = old->call_convention;
4000                 sig->generic_param_count = old->generic_param_count;
4001                 sig->param_count = old->param_count + nargs;
4002                 sig->sentinelpos = old->param_count;
4003                 sig->ret = old->ret;
4004
4005                 for (i = 0; i < old->param_count; i++)
4006                         sig->params [i] = old->params [i];
4007
4008                 for (i = 0; i < nargs; i++) {
4009                         MonoReflectionType *rt = mono_array_get (opt_param_types, MonoReflectionType *, i);
4010                         sig->params [old->param_count + i] = rt->type;
4011                 }
4012
4013                 parent = mono_image_typedef_or_ref (assembly, &method->klass->byval_arg);
4014                 g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF);
4015                 parent >>= MONO_TYPEDEFORREF_BITS;
4016
4017                 parent <<= MONO_MEMBERREF_PARENT_BITS;
4018                 parent |= MONO_MEMBERREF_PARENT_TYPEREF;
4019
4020                 sig_token = method_encode_signature (assembly, sig);
4021                 token = mono_image_get_varargs_method_token (assembly, parent, method->name, sig_token);
4022         } else if (strcmp (klass->name, "MethodBuilder") == 0) {
4023                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
4024                 ReflectionMethodBuilder rmb;
4025                 guint32 parent, sig;
4026
4027                 reflection_methodbuilder_from_method_builder (&rmb, mb);
4028                 rmb.opt_types = opt_param_types;
4029
4030                 sig = method_builder_encode_signature (assembly, &rmb);
4031
4032                 parent = mono_image_create_token (assembly, obj, TRUE);
4033                 g_assert (mono_metadata_token_table (parent) == MONO_TABLE_METHOD);
4034
4035                 parent = mono_metadata_token_index (parent) << MONO_MEMBERREF_PARENT_BITS;
4036                 parent |= MONO_MEMBERREF_PARENT_METHODDEF;
4037
4038                 token = mono_image_get_varargs_method_token (
4039                         assembly, parent, mono_string_to_utf8 (rmb.name), sig);
4040         } else {
4041                 g_error ("requested method token for %s\n", klass->name);
4042         }
4043
4044         return token;
4045 }
4046
4047 /*
4048  * mono_image_create_token:
4049  * @assembly: a dynamic assembly
4050  * @obj:
4051  *
4052  * Get a token to insert in the IL code stream for the given MemberInfo.
4053  * @obj can be one of:
4054  *      ConstructorBuilder
4055  *      MethodBuilder
4056  *      FieldBuilder
4057  *      MonoCMethod
4058  *      MonoMethod
4059  *      MonoField
4060  *      MonoType
4061  *      TypeBuilder
4062  */
4063 guint32
4064 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, gboolean create_methodspec)
4065 {
4066         MonoClass *klass;
4067         guint32 token = 0;
4068
4069         klass = obj->vtable->klass;
4070         if (strcmp (klass->name, "MethodBuilder") == 0) {
4071                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
4072
4073                 if (((MonoReflectionTypeBuilder*)mb->type)->module->dynamic_image == assembly)
4074                         token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
4075                 else
4076                         token = mono_image_get_methodbuilder_token (assembly, mb);
4077                 /*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
4078         } else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
4079                 MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
4080
4081                 if (((MonoReflectionTypeBuilder*)mb->type)->module->dynamic_image == assembly)
4082                         token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
4083                 else
4084                         token = mono_image_get_ctorbuilder_token (assembly, mb);
4085                 /*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
4086         } else if (strcmp (klass->name, "FieldBuilder") == 0) {
4087                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
4088                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)fb->typeb;
4089                 if (tb->generic_params) {
4090                         token = mono_image_get_generic_field_token (assembly, fb);
4091                 } else {
4092                         token = fb->table_idx | MONO_TOKEN_FIELD_DEF;
4093                 }
4094         } else if (strcmp (klass->name, "TypeBuilder") == 0) {
4095                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
4096                 token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
4097         } else if (strcmp (klass->name, "MonoType") == 0 ||
4098                  strcmp (klass->name, "GenericTypeParameterBuilder") == 0) {
4099                 MonoReflectionType *tb = (MonoReflectionType *)obj;
4100                 token = mono_metadata_token_from_dor (
4101                         mono_image_typedef_or_ref (assembly, tb->type));
4102         } else if (strcmp (klass->name, "MonoGenericInst") == 0) {
4103                 MonoReflectionType *tb = (MonoReflectionType *)obj;
4104                 token = mono_metadata_token_from_dor (
4105                         mono_image_typedef_or_ref (assembly, tb->type));
4106         } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
4107                         strcmp (klass->name, "MonoMethod") == 0) {
4108                 MonoReflectionMethod *m = (MonoReflectionMethod *)obj;
4109                 if (m->method->signature->is_inflated) {
4110                         if (create_methodspec)
4111                                 token = mono_image_get_methodspec_token (assembly, m->method);
4112                         else
4113                                 token = mono_image_get_inflated_method_token (assembly, m->method);
4114                 } else if (m->method->signature->generic_param_count) {
4115                         g_assert_not_reached ();
4116                 } else if ((m->method->klass->image == &assembly->image) &&
4117                          !m->method->klass->generic_inst) {
4118                         static guint32 method_table_idx = 0xffffff;
4119                         if (m->method->klass->wastypebuilder) {
4120                                 /* we use the same token as the one that was assigned
4121                                  * to the Methodbuilder.
4122                                  * FIXME: do the equivalent for Fields.
4123                                  */
4124                                 token = m->method->token;
4125                         } else {
4126                                 /*
4127                                  * Each token should have a unique index, but the indexes are
4128                                  * assigned by managed code, so we don't know about them. An
4129                                  * easy solution is to count backwards...
4130                                  */
4131                                 method_table_idx --;
4132                                 token = MONO_TOKEN_METHOD_DEF | method_table_idx;
4133                         }
4134                 } else {
4135                         token = mono_image_get_methodref_token (assembly, m->method);
4136                 }
4137                 /*g_print ("got token 0x%08x for %s\n", token, m->method->name);*/
4138         } else if (strcmp (klass->name, "MonoField") == 0) {
4139                 MonoReflectionField *f = (MonoReflectionField *)obj;
4140                 if ((f->klass->image == &assembly->image) && !f->field->generic_info) {
4141                         static guint32 field_table_idx = 0xffffff;
4142                         field_table_idx --;
4143                         token = MONO_TOKEN_FIELD_DEF | field_table_idx;
4144                 } else {
4145                         token = mono_image_get_fieldref_token (assembly, f);
4146                 }
4147                 /*g_print ("got token 0x%08x for %s\n", token, f->field->name);*/
4148         } else if (strcmp (klass->name, "MonoArrayMethod") == 0) {
4149                 MonoReflectionArrayMethod *m = (MonoReflectionArrayMethod *)obj;
4150                 token = mono_image_get_array_token (assembly, m);
4151         } else if (strcmp (klass->name, "SignatureHelper") == 0) {
4152                 MonoReflectionSigHelper *s = (MonoReflectionSigHelper*)obj;
4153                 token = MONO_TOKEN_SIGNATURE | mono_image_get_sighelper_token (assembly, s);
4154         } else {
4155                 g_error ("requested token for %s\n", klass->name);
4156         }
4157
4158         mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), obj);
4159
4160         return token;
4161 }
4162
4163 typedef struct {
4164         guint32 import_lookup_table;
4165         guint32 timestamp;
4166         guint32 forwarder;
4167         guint32 name_rva;
4168         guint32 import_address_table_rva;
4169 } MonoIDT;
4170
4171 typedef struct {
4172         guint32 name_rva;
4173         guint32 flags;
4174 } MonoILT;
4175
4176 static void register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly);
4177
4178 static MonoDynamicImage*
4179 create_dynamic_mono_image (MonoDynamicAssembly *assembly, char *assembly_name, char *module_name)
4180 {
4181         static const guchar entrycode [16] = {0xff, 0x25, 0};
4182         MonoDynamicImage *image;
4183         int i;
4184
4185         const char *version = mono_get_runtime_version ();
4186
4187 #if HAVE_BOEHM_GC
4188         image = GC_MALLOC (sizeof (MonoDynamicImage));
4189 #else
4190         image = g_new0 (MonoDynamicImage, 1);
4191 #endif
4192
4193         /* keep in sync with image.c */
4194         image->image.name = assembly_name;
4195         image->image.assembly_name = image->image.name; /* they may be different */
4196         image->image.module_name = module_name;
4197         image->image.version = g_strdup (version);
4198         image->image.dynamic = TRUE;
4199
4200         image->image.references = g_new0 (MonoAssembly*, 1);
4201         image->image.references [0] = NULL;
4202
4203         mono_image_init (&image->image);
4204
4205         image->token_fixups = mono_g_hash_table_new (NULL, NULL);
4206         image->method_to_table_idx = mono_g_hash_table_new (NULL, NULL);
4207         image->field_to_table_idx = mono_g_hash_table_new (NULL, NULL);
4208         image->method_aux_hash = mono_g_hash_table_new (NULL, NULL);
4209         image->handleref = g_hash_table_new (NULL, NULL);
4210         image->tokens = mono_g_hash_table_new (NULL, NULL);
4211         image->typespec = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
4212         image->typeref = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
4213         image->blob_cache = mono_g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal);
4214         image->gen_params = g_ptr_array_new ();
4215
4216         string_heap_init (&image->sheap);
4217         mono_image_add_stream_data (&image->us, "", 1);
4218         add_to_blob_cached (image, (char*) "", 1, NULL, 0);
4219         /* import tables... */
4220         mono_image_add_stream_data (&image->code, entrycode, sizeof (entrycode));
4221         image->iat_offset = mono_image_add_stream_zero (&image->code, 8); /* two IAT entries */
4222         image->idt_offset = mono_image_add_stream_zero (&image->code, 2 * sizeof (MonoIDT)); /* two IDT entries */
4223         image->imp_names_offset = mono_image_add_stream_zero (&image->code, 2); /* flags for name entry */
4224         mono_image_add_stream_data (&image->code, "_CorExeMain", 12);
4225         mono_image_add_stream_data (&image->code, "mscoree.dll", 12);
4226         image->ilt_offset = mono_image_add_stream_zero (&image->code, 8); /* two ILT entries */
4227         stream_data_align (&image->code);
4228
4229         image->cli_header_offset = mono_image_add_stream_zero (&image->code, sizeof (MonoCLIHeader));
4230
4231         for (i=0; i < 64; ++i) {
4232                 image->tables [i].next_idx = 1;
4233                 image->tables [i].columns = table_sizes [i];
4234         }
4235
4236         image->image.assembly = (MonoAssembly*)assembly;
4237         image->run = assembly->run;
4238         image->save = assembly->save;
4239         image->pe_kind = 0x1; /* ILOnly */
4240         image->machine = 0x14c; /* I386 */
4241
4242         return image;
4243 }
4244
4245 /*
4246  * mono_image_basic_init:
4247  * @assembly: an assembly builder object
4248  *
4249  * Create the MonoImage that represents the assembly builder and setup some
4250  * of the helper hash table and the basic metadata streams.
4251  */
4252 void
4253 mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
4254 {
4255         MonoDynamicAssembly *assembly;
4256         MonoDynamicImage *image;
4257
4258         MONO_ARCH_SAVE_REGS;
4259
4260         if (assemblyb->dynamic_assembly)
4261                 return;
4262
4263 #if HAVE_BOEHM_GC
4264         assembly = assemblyb->dynamic_assembly = GC_MALLOC (sizeof (MonoDynamicAssembly));
4265 #else
4266         assembly = assemblyb->dynamic_assembly = g_new0 (MonoDynamicImage, 1);
4267 #endif
4268
4269         assembly->assembly.dynamic = TRUE;
4270         assemblyb->assembly.assembly = (MonoAssembly*)assembly;
4271         assembly->assembly.basedir = mono_string_to_utf8 (assemblyb->dir);
4272         if (assemblyb->culture)
4273                 assembly->assembly.aname.culture = mono_string_to_utf8 (assemblyb->culture);
4274         else
4275                 assembly->assembly.aname.culture = g_strdup ("");
4276
4277         assembly->run = assemblyb->access != 2;
4278         assembly->save = assemblyb->access != 1;
4279
4280         image = create_dynamic_mono_image (assembly, mono_string_to_utf8 (assemblyb->name), g_strdup ("RefEmit_YouForgotToDefineAModule"));
4281         image->initial_image = TRUE;
4282         assembly->assembly.aname.name = image->image.name;
4283         assembly->assembly.image = &image->image;
4284
4285         register_assembly (mono_object_domain (assemblyb), &assemblyb->assembly, &assembly->assembly);
4286         mono_assembly_invoke_load_hook ((MonoAssembly*)assembly);
4287 }
4288
4289 static int
4290 calc_section_size (MonoDynamicImage *assembly)
4291 {
4292         int nsections = 0;
4293
4294         /* alignment constraints */
4295         assembly->code.index += 3;
4296         assembly->code.index &= ~3;
4297         assembly->meta_size += 3;
4298         assembly->meta_size &= ~3;
4299         assembly->resources.index += 3;
4300         assembly->resources.index &= ~3;
4301
4302         assembly->sections [MONO_SECTION_TEXT].size = assembly->meta_size + assembly->code.index + assembly->resources.index + assembly->strong_name_size;
4303         assembly->sections [MONO_SECTION_TEXT].attrs = SECT_FLAGS_HAS_CODE | SECT_FLAGS_MEM_EXECUTE | SECT_FLAGS_MEM_READ;
4304         nsections++;
4305
4306         if (assembly->win32_res) {
4307                 guint32 res_size = (assembly->win32_res_size + 3) & ~3;
4308
4309                 assembly->sections [MONO_SECTION_RSRC].size = res_size;
4310                 assembly->sections [MONO_SECTION_RSRC].attrs = SECT_FLAGS_HAS_INITIALIZED_DATA | SECT_FLAGS_MEM_READ;
4311                 nsections++;
4312         }
4313
4314         assembly->sections [MONO_SECTION_RELOC].size = 12;
4315         assembly->sections [MONO_SECTION_RELOC].attrs = SECT_FLAGS_MEM_READ | SECT_FLAGS_MEM_DISCARDABLE | SECT_FLAGS_HAS_INITIALIZED_DATA;
4316         nsections++;
4317
4318         return nsections;
4319 }
4320
4321 typedef struct {
4322         guint32 id;
4323         guint32 offset;
4324         GSList *children;
4325         MonoReflectionWin32Resource *win32_res; /* Only for leaf nodes */
4326 } ResTreeNode;
4327
4328 static int
4329 resource_tree_compare_by_id (gconstpointer a, gconstpointer b)
4330 {
4331         ResTreeNode *t1 = (ResTreeNode*)a;
4332         ResTreeNode *t2 = (ResTreeNode*)b;
4333
4334         return t1->id - t2->id;
4335 }
4336
4337 /*
4338  * resource_tree_create:
4339  *
4340  *  Organize the resources into a resource tree.
4341  */
4342 static ResTreeNode *
4343 resource_tree_create (MonoArray *win32_resources)
4344 {
4345         ResTreeNode *tree, *res_node, *type_node, *lang_node;
4346         GSList *l;
4347         int i;
4348
4349         tree = g_new0 (ResTreeNode, 1);
4350
4351         for (i = 0; i < mono_array_length (win32_resources); ++i) {
4352                 MonoReflectionWin32Resource *win32_res =
4353                         (MonoReflectionWin32Resource*)mono_array_addr (win32_resources, MonoReflectionWin32Resource, i);
4354
4355                 /* Create node */
4356
4357                 lang_node = g_new0 (ResTreeNode, 1);
4358                 lang_node->id = win32_res->lang_id;
4359                 lang_node->win32_res = win32_res;
4360
4361                 /* Create type node if neccesary */
4362                 type_node = NULL;
4363                 for (l = tree->children; l; l = l->next)
4364                         if (((ResTreeNode*)(l->data))->id == win32_res->res_type) {
4365                                 type_node = (ResTreeNode*)l->data;
4366                                 break;
4367                         }
4368
4369                 if (!type_node) {
4370                         type_node = g_new0 (ResTreeNode, 1);
4371                         type_node->id = win32_res->res_type;
4372
4373                         /*
4374                          * The resource types have to be sorted otherwise
4375                          * Windows Explorer can't display the version information.
4376                          */
4377                         tree->children = g_slist_insert_sorted (tree->children,
4378                                 type_node, resource_tree_compare_by_id);
4379                 }
4380
4381                 /* Create res node if neccesary */
4382                 res_node = NULL;
4383                 for (l = type_node->children; l; l = l->next)
4384                         if (((ResTreeNode*)(l->data))->id == win32_res->res_id) {
4385                                 res_node = (ResTreeNode*)l->data;
4386                                 break;
4387                         }
4388
4389                 if (!res_node) {
4390                         res_node = g_new0 (ResTreeNode, 1);
4391                         res_node->id = win32_res->res_id;
4392                         type_node->children = g_slist_append (type_node->children, res_node);
4393                 }
4394
4395                 res_node->children = g_slist_append (res_node->children, lang_node);
4396         }
4397
4398         return tree;
4399 }
4400
4401 /*
4402  * resource_tree_encode:
4403  *
4404  *   Encode the resource tree into the format used in the PE file.
4405  */
4406 static void
4407 resource_tree_encode (ResTreeNode *node, char *begin, char *p, char **endbuf)
4408 {
4409         char *entries;
4410         MonoPEResourceDir dir;
4411         MonoPEResourceDirEntry dir_entry;
4412         MonoPEResourceDataEntry data_entry;
4413         GSList *l;
4414
4415         /*
4416          * For the format of the resource directory, see the article
4417          * "An In-Depth Look into the Win32 Portable Executable File Format" by
4418          * Matt Pietrek
4419          */
4420
4421         memset (&dir, 0, sizeof (dir));
4422         memset (&dir_entry, 0, sizeof (dir_entry));
4423         memset (&data_entry, 0, sizeof (data_entry));
4424
4425         g_assert (sizeof (dir) == 16);
4426         g_assert (sizeof (dir_entry) == 8);
4427         g_assert (sizeof (data_entry) == 16);
4428
4429         node->offset = p - begin;
4430
4431         /* IMAGE_RESOURCE_DIRECTORY */
4432         dir.res_id_entries = GUINT32_TO_LE (g_slist_length (node->children));
4433
4434         memcpy (p, &dir, sizeof (dir));
4435         p += sizeof (dir);
4436
4437         /* Reserve space for entries */
4438         entries = p;
4439         p += sizeof (dir_entry) * dir.res_id_entries;
4440
4441         /* Write children */
4442         for (l = node->children; l; l = l->next) {
4443                 ResTreeNode *child = (ResTreeNode*)l->data;
4444
4445                 if (child->win32_res) {
4446
4447                         child->offset = p - begin;
4448
4449                         /* IMAGE_RESOURCE_DATA_ENTRY */
4450                         data_entry.rde_data_offset = GUINT32_TO_LE (p - begin + sizeof (data_entry));
4451                         data_entry.rde_size = mono_array_length (child->win32_res->res_data);
4452
4453                         memcpy (p, &data_entry, sizeof (data_entry));
4454                         p += sizeof (data_entry);
4455
4456                         memcpy (p, mono_array_addr (child->win32_res->res_data, char, 0), data_entry.rde_size);
4457                         p += data_entry.rde_size;
4458                 } else {
4459                         resource_tree_encode (child, begin, p, &p);
4460                 }
4461         }
4462
4463         /* IMAGE_RESOURCE_ENTRY */
4464         for (l = node->children; l; l = l->next) {
4465                 ResTreeNode *child = (ResTreeNode*)l->data;
4466                 dir_entry.name_offset = GUINT32_TO_LE (child->id);
4467
4468                 dir_entry.is_dir = child->win32_res ? 0 : 1;
4469                 dir_entry.dir_offset = GUINT32_TO_LE (child->offset);
4470
4471                 memcpy (entries, &dir_entry, sizeof (dir_entry));
4472                 entries += sizeof (dir_entry);
4473         }
4474
4475         *endbuf = p;
4476 }
4477
4478 static void
4479 assembly_add_win32_resources (MonoDynamicImage *assembly, MonoReflectionAssemblyBuilder *assemblyb)
4480 {
4481         char *buf;
4482         char *p;
4483         guint32 size, i;
4484         MonoReflectionWin32Resource *win32_res;
4485         ResTreeNode *tree;
4486
4487         if (!assemblyb->win32_resources)
4488                 return;
4489
4490         /*
4491          * Resources are stored in a three level tree inside the PE file.
4492          * - level one contains a node for each type of resource
4493          * - level two contains a node for each resource
4494          * - level three contains a node for each instance of a resource for a
4495          *   specific language.
4496          */
4497
4498         tree = resource_tree_create (assemblyb->win32_resources);
4499
4500         /* Estimate the size of the encoded tree */
4501         size = 0;
4502         for (i = 0; i < mono_array_length (assemblyb->win32_resources); ++i) {
4503                 win32_res = (MonoReflectionWin32Resource*)mono_array_addr (assemblyb->win32_resources, MonoReflectionWin32Resource, i);
4504                 size += mono_array_length (win32_res->res_data);
4505         }
4506         /* Directory structure */
4507         size += mono_array_length (assemblyb->win32_resources) * 256;
4508         p = buf = g_malloc (size);
4509
4510         resource_tree_encode (tree, p, p, &p);
4511
4512         g_assert (p - buf < size);
4513
4514         assembly->win32_res = g_malloc (p - buf);
4515         assembly->win32_res_size = p - buf;
4516         memcpy (assembly->win32_res, buf, p - buf);
4517
4518         g_free (buf);
4519 }
4520
4521 static void
4522 fixup_resource_directory (char *res_section, char *p, guint32 rva)
4523 {
4524         MonoPEResourceDir *dir = (MonoPEResourceDir*)p;
4525         int i;
4526
4527         p += sizeof (MonoPEResourceDir);
4528         for (i = 0; i < dir->res_named_entries + dir->res_id_entries; ++i) {
4529                 MonoPEResourceDirEntry *dir_entry = (MonoPEResourceDirEntry*)p;
4530                 char *child = res_section + (GUINT32_FROM_LE (dir_entry->dir_offset));
4531                 if (dir_entry->is_dir) {
4532                         fixup_resource_directory (res_section, child, rva);
4533                 } else {
4534                         MonoPEResourceDataEntry *data_entry = (MonoPEResourceDataEntry*)child;
4535                         data_entry->rde_data_offset = GUINT32_TO_LE (GUINT32_FROM_LE (data_entry->rde_data_offset) + rva);
4536                 }
4537
4538                 p += sizeof (MonoPEResourceDirEntry);
4539         }
4540 }
4541
4542 /*
4543  * mono_image_create_pefile:
4544  * @mb: a module builder object
4545  *
4546  * This function creates the PE-COFF header, the image sections, the CLI header  * etc. all the data is written in
4547  * assembly->pefile where it can be easily retrieved later in chunks.
4548  */
4549 void
4550 mono_image_create_pefile (MonoReflectionModuleBuilder *mb) {
4551         MonoMSDOSHeader *msdos;
4552         MonoDotNetHeader *header;
4553         MonoSectionTable *section;
4554         MonoCLIHeader *cli_header;
4555         guint32 size, image_size, virtual_base, text_offset;
4556         guint32 header_start, section_start, file_offset, virtual_offset;
4557         MonoDynamicImage *assembly;
4558         MonoReflectionAssemblyBuilder *assemblyb;
4559         MonoDynamicStream *pefile;
4560         int i, nsections;
4561         guint32 *rva, value;
4562         guint16 *data16;
4563         guchar *p;
4564         static const unsigned char msheader[] = {
4565                 0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00,  0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
4566                 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4567                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4568                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
4569                 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd,  0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21, 0x54, 0x68,
4570                 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72,  0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f,
4571                 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6e,  0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
4572                 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a,  0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4573         };
4574
4575         assemblyb = mb->assemblyb;
4576
4577         mono_image_basic_init (assemblyb);
4578         assembly = mb->dynamic_image;
4579
4580         assembly->pe_kind = assemblyb->pe_kind;
4581         assembly->machine = assemblyb->machine;
4582         ((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->pe_kind = assemblyb->pe_kind;
4583         ((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->machine = assemblyb->machine;
4584
4585         /* already created */
4586         if (assembly->pefile.index)
4587                 return;
4588
4589         mono_image_build_metadata (mb);
4590
4591         if (mb->is_main && assemblyb->resources) {
4592                 int len = mono_array_length (assemblyb->resources);
4593                 for (i = 0; i < len; ++i)
4594                         assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (assemblyb->resources, MonoReflectionResource, i));
4595         }
4596
4597         if (mb->resources) {
4598                 int len = mono_array_length (mb->resources);
4599                 for (i = 0; i < len; ++i)
4600                         assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (mb->resources, MonoReflectionResource, i));
4601         }
4602
4603         build_compressed_metadata (assembly);
4604
4605         if (mb->is_main)
4606                 assembly_add_win32_resources (assembly, assemblyb);
4607
4608         nsections = calc_section_size (assembly);
4609
4610         pefile = &assembly->pefile;
4611
4612         /* The DOS header and stub */
4613         g_assert (sizeof (MonoMSDOSHeader) == sizeof (msheader));
4614         mono_image_add_stream_data (pefile, msheader, sizeof (msheader));
4615
4616         /* the dotnet header */
4617         header_start = mono_image_add_stream_zero (pefile, sizeof (MonoDotNetHeader));
4618
4619         /* the section tables */
4620         section_start = mono_image_add_stream_zero (pefile, sizeof (MonoSectionTable) * nsections);
4621
4622         file_offset = section_start + sizeof (MonoSectionTable) * nsections;
4623         virtual_offset = VIRT_ALIGN;
4624         image_size = 0;
4625
4626         for (i = 0; i < MONO_SECTION_MAX; ++i) {
4627                 if (!assembly->sections [i].size)
4628                         continue;
4629                 /* align offsets */
4630                 file_offset += FILE_ALIGN - 1;
4631                 file_offset &= ~(FILE_ALIGN - 1);
4632                 virtual_offset += VIRT_ALIGN - 1;
4633                 virtual_offset &= ~(VIRT_ALIGN - 1);
4634
4635                 assembly->sections [i].offset = file_offset;
4636                 assembly->sections [i].rva = virtual_offset;
4637
4638                 file_offset += assembly->sections [i].size;
4639                 virtual_offset += assembly->sections [i].size;
4640                 image_size += (assembly->sections [i].size + VIRT_ALIGN - 1) & ~(VIRT_ALIGN - 1);
4641         }
4642
4643         file_offset += FILE_ALIGN - 1;
4644         file_offset &= ~(FILE_ALIGN - 1);
4645         mono_image_add_stream_zero (pefile, file_offset - pefile->index);
4646
4647         image_size += section_start + sizeof (MonoSectionTable) * nsections;
4648
4649         /* back-patch info */
4650         msdos = (MonoMSDOSHeader*)pefile->data;
4651         msdos->nlast_page = GUINT16_FROM_LE (file_offset & (512 - 1));
4652         msdos->npages = GUINT16_FROM_LE ((file_offset + (512 - 1)) / 512);
4653         msdos->pe_offset = GUINT32_FROM_LE (sizeof (MonoMSDOSHeader));
4654
4655         header = (MonoDotNetHeader*)(pefile->data + header_start);
4656         header->pesig [0] = 'P';
4657         header->pesig [1] = 'E';
4658
4659         header->coff.coff_machine = GUINT16_FROM_LE (assemblyb->machine);
4660         header->coff.coff_sections = GUINT16_FROM_LE (nsections);
4661         header->coff.coff_time = GUINT32_FROM_LE (time (NULL));
4662         header->coff.coff_opt_header_size = GUINT16_FROM_LE (sizeof (MonoDotNetHeader) - sizeof (MonoCOFFHeader) - 4);
4663         if (assemblyb->pekind == 1) {
4664                 /* it's a dll */
4665                 header->coff.coff_attributes = GUINT16_FROM_LE (0x210e);
4666         } else {
4667                 /* it's an exe */
4668                 header->coff.coff_attributes = GUINT16_FROM_LE (0x010e);
4669         }
4670
4671         virtual_base = 0x400000; /* FIXME: 0x10000000 if a DLL */
4672
4673         header->pe.pe_magic = GUINT16_FROM_LE (0x10B);
4674         header->pe.pe_major = 6;
4675         header->pe.pe_minor = 0;
4676         size = assembly->sections [MONO_SECTION_TEXT].size;
4677         size += FILE_ALIGN - 1;
4678         size &= ~(FILE_ALIGN - 1);
4679         header->pe.pe_code_size = GUINT32_FROM_LE(size);
4680         size = assembly->sections [MONO_SECTION_RSRC].size;
4681         size += FILE_ALIGN - 1;
4682         size &= ~(FILE_ALIGN - 1);
4683         header->pe.pe_data_size = GUINT32_FROM_LE(size);
4684         g_assert (START_TEXT_RVA == assembly->sections [MONO_SECTION_TEXT].rva);
4685         header->pe.pe_rva_code_base = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_TEXT].rva);
4686         header->pe.pe_rva_data_base = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].rva);
4687         /* pe_rva_entry_point always at the beginning of the text section */
4688         header->pe.pe_rva_entry_point = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_TEXT].rva);
4689
4690         header->nt.pe_image_base = GUINT32_FROM_LE (virtual_base);
4691         header->nt.pe_section_align = GUINT32_FROM_LE (VIRT_ALIGN);
4692         header->nt.pe_file_alignment = GUINT32_FROM_LE (FILE_ALIGN);
4693         header->nt.pe_os_major = GUINT16_FROM_LE (4);
4694         header->nt.pe_os_minor = GUINT16_FROM_LE (0);
4695         header->nt.pe_subsys_major = GUINT16_FROM_LE (4);
4696         size = section_start;
4697         size += FILE_ALIGN - 1;
4698         size &= ~(FILE_ALIGN - 1);
4699         header->nt.pe_header_size = GUINT32_FROM_LE (size);
4700         size = image_size;
4701         size += VIRT_ALIGN - 1;
4702         size &= ~(VIRT_ALIGN - 1);
4703         header->nt.pe_image_size = GUINT32_FROM_LE (size);
4704
4705         /*
4706         // Translate the PEFileKind value to the value expected by the Windows loader
4707         */
4708         {
4709                 short kind;
4710
4711                 /*
4712                 // PEFileKinds.Dll == 1
4713                 // PEFileKinds.ConsoleApplication == 2
4714                 // PEFileKinds.WindowApplication == 3
4715                 //
4716                 // need to get:
4717                 //     IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem.
4718                 //     IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem.
4719                 */
4720                 if (assemblyb->pekind == 3)
4721                         kind = 2;
4722                 else
4723                         kind = 3;
4724
4725                 header->nt.pe_subsys_required = GUINT16_FROM_LE (kind);
4726         }
4727         header->nt.pe_stack_reserve = GUINT32_FROM_LE (0x00100000);
4728         header->nt.pe_stack_commit = GUINT32_FROM_LE (0x00001000);
4729         header->nt.pe_heap_reserve = GUINT32_FROM_LE (0x00100000);
4730         header->nt.pe_heap_commit = GUINT32_FROM_LE (0x00001000);
4731         header->nt.pe_loader_flags = GUINT32_FROM_LE (0);
4732         header->nt.pe_data_dir_count = GUINT32_FROM_LE (16);
4733
4734         /* fill data directory entries */
4735
4736         header->datadir.pe_resource_table.size = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].size);
4737         header->datadir.pe_resource_table.rva = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].rva);
4738
4739         header->datadir.pe_reloc_table.size = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RELOC].size);
4740         header->datadir.pe_reloc_table.rva = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RELOC].rva);
4741
4742         header->datadir.pe_cli_header.size = GUINT32_FROM_LE (72);
4743         header->datadir.pe_cli_header.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->cli_header_offset);
4744         header->datadir.pe_iat.size = GUINT32_FROM_LE (8);
4745         header->datadir.pe_iat.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->iat_offset);
4746         /* patch entrypoint name */
4747         if (assemblyb->pekind == 1)
4748                 memcpy (assembly->code.data + assembly->imp_names_offset + 2, "_CorDllMain", 12);
4749         else
4750                 memcpy (assembly->code.data + assembly->imp_names_offset + 2, "_CorExeMain", 12);
4751         /* patch imported function RVA name */
4752         rva = (guint32*)(assembly->code.data + assembly->iat_offset);
4753         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->imp_names_offset);
4754
4755         /* the import table */
4756         header->datadir.pe_import_table.size = GUINT32_FROM_LE (79); /* FIXME: magic number? */
4757         header->datadir.pe_import_table.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->idt_offset);
4758         /* patch imported dll RVA name and other entries in the dir */
4759         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, name_rva));
4760         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->imp_names_offset + 14); /* 14 is hint+strlen+1 of func name */
4761         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, import_address_table_rva));
4762         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->iat_offset);
4763         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, import_lookup_table));
4764         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->ilt_offset);
4765
4766         p = (assembly->code.data + assembly->ilt_offset);
4767         value = (assembly->text_rva + assembly->imp_names_offset);
4768         *p++ = (value) & 0xff;
4769         *p++ = (value >> 8) & (0xff);
4770         *p++ = (value >> 16) & (0xff);
4771         *p++ = (value >> 24) & (0xff);
4772
4773         /* the CLI header info */
4774         cli_header = (MonoCLIHeader*)(assembly->code.data + assembly->cli_header_offset);
4775         cli_header->ch_size = GUINT32_FROM_LE (72);
4776         cli_header->ch_runtime_major = GUINT16_FROM_LE (2);
4777         cli_header->ch_flags = GUINT32_FROM_LE (assemblyb->pe_kind);
4778         if (assemblyb->entry_point) {
4779                 guint32 table_idx = 0;
4780                 if (!strcmp (assemblyb->entry_point->object.vtable->klass->name, "MethodBuilder")) {
4781                         MonoReflectionMethodBuilder *methodb = (MonoReflectionMethodBuilder*)assemblyb->entry_point;
4782                         table_idx = methodb->table_idx;
4783                 } else {
4784                         table_idx = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->method_to_table_idx, assemblyb->entry_point->method));
4785                 }
4786                 cli_header->ch_entry_point = GUINT32_FROM_LE (table_idx | MONO_TOKEN_METHOD_DEF);
4787         } else {
4788                 cli_header->ch_entry_point = GUINT32_FROM_LE (0);
4789         }
4790         /* The embedded managed resources */
4791         text_offset = assembly->text_rva + assembly->code.index;
4792         cli_header->ch_resources.rva = GUINT32_FROM_LE (text_offset);
4793         cli_header->ch_resources.size = GUINT32_FROM_LE (assembly->resources.index);
4794         text_offset += assembly->resources.index;
4795         cli_header->ch_metadata.rva = GUINT32_FROM_LE (text_offset);
4796         cli_header->ch_metadata.size = GUINT32_FROM_LE (assembly->meta_size);
4797         text_offset += assembly->meta_size;
4798         if (assembly->strong_name_size) {
4799                 cli_header->ch_strong_name.rva = GUINT32_FROM_LE (text_offset);
4800                 cli_header->ch_strong_name.size = GUINT32_FROM_LE (assembly->strong_name_size);
4801                 text_offset += assembly->strong_name_size;
4802         }
4803
4804         /* write the section tables and section content */
4805         section = (MonoSectionTable*)(pefile->data + section_start);
4806         for (i = 0; i < MONO_SECTION_MAX; ++i) {
4807                 static const char *section_names [] = {
4808                         ".text", ".rsrc", ".reloc"
4809                 };
4810                 if (!assembly->sections [i].size)
4811                         continue;
4812                 strcpy (section->st_name, section_names [i]);
4813                 /*g_print ("output section %s (%d), size: %d\n", section->st_name, i, assembly->sections [i].size);*/
4814                 section->st_virtual_address = GUINT32_FROM_LE (assembly->sections [i].rva);
4815                 section->st_virtual_size = GUINT32_FROM_LE (assembly->sections [i].size);
4816                 section->st_raw_data_size = GUINT32_FROM_LE (GUINT32_TO_LE (section->st_virtual_size) + (FILE_ALIGN - 1));
4817                 section->st_raw_data_size &= GUINT32_FROM_LE (~(FILE_ALIGN - 1));
4818                 section->st_raw_data_ptr = GUINT32_FROM_LE (assembly->sections [i].offset);
4819                 section->st_flags = GUINT32_FROM_LE (assembly->sections [i].attrs);
4820                 switch (i) {
4821                 case MONO_SECTION_TEXT:
4822                         /* patch entry point */
4823                         p = (assembly->code.data + 2);
4824                         value = (virtual_base + assembly->text_rva + assembly->iat_offset);
4825                         *p++ = (value) & 0xff;
4826                         *p++ = (value >> 8) & 0xff;
4827                         *p++ = (value >> 16) & 0xff;
4828                         *p++ = (value >> 24) & 0xff;
4829
4830                         text_offset = assembly->sections [i].offset;
4831                         memcpy (pefile->data + text_offset, assembly->code.data, assembly->code.index);
4832                         text_offset += assembly->code.index;
4833                         memcpy (pefile->data + text_offset, assembly->resources.data, assembly->resources.index);
4834                         text_offset += assembly->resources.index;
4835                         memcpy (pefile->data + text_offset, assembly->image.raw_metadata, assembly->meta_size);
4836                         text_offset += assembly->meta_size;
4837                         memcpy (pefile->data + text_offset, assembly->strong_name, assembly->strong_name_size);
4838
4839                         g_free (assembly->image.raw_metadata);
4840                         break;
4841                 case MONO_SECTION_RELOC:
4842                         rva = (guint32*)(pefile->data + assembly->sections [i].offset);
4843                         *rva = GUINT32_FROM_LE (assembly->text_rva);
4844                         ++rva;
4845                         *rva = GUINT32_FROM_LE (12);
4846                         ++rva;
4847                         data16 = (guint16*)rva;
4848                         /*
4849                          * the entrypoint is always at the start of the text section
4850                          * 3 is IMAGE_REL_BASED_HIGHLOW
4851                          * 2 is patch_size_rva - text_rva
4852                          */
4853                         *data16 = GUINT16_FROM_LE ((3 << 12) + (2));
4854                         data16++;
4855                         *data16 = 0; /* terminate */
4856                         break;
4857                 case MONO_SECTION_RSRC:
4858                         if (assembly->win32_res) {
4859                                 text_offset = assembly->sections [i].offset;
4860
4861                                 /* Fixup the offsets in the IMAGE_RESOURCE_DATA_ENTRY structures */
4862                                 fixup_resource_directory (assembly->win32_res, assembly->win32_res, assembly->sections [i].rva);
4863
4864                                 memcpy (pefile->data + text_offset, assembly->win32_res, assembly->win32_res_size);
4865                         }
4866                         break;
4867                 default:
4868                         g_assert_not_reached ();
4869                 }
4870                 section++;
4871         }
4872
4873         /* check that the file is properly padded */
4874 #if 0
4875         {
4876                 FILE *f = fopen ("mypetest.exe", "w");
4877                 fwrite (pefile->data, pefile->index, 1, f);
4878                 fclose (f);
4879         }
4880 #endif
4881 }
4882
4883 MonoReflectionModule *
4884 mono_image_load_module (MonoReflectionAssemblyBuilder *ab, MonoString *fileName)
4885 {
4886         char *name;
4887         MonoImage *image;
4888         MonoImageOpenStatus status;
4889         MonoDynamicAssembly *assembly;
4890         guint32 module_count;
4891         MonoImage **new_modules;
4892
4893         name = mono_string_to_utf8 (fileName);
4894
4895         image = mono_image_open (name, &status);
4896         if (status) {
4897                 MonoException *exc;
4898                 if (status == MONO_IMAGE_ERROR_ERRNO)
4899                         exc = mono_get_exception_file_not_found (fileName);
4900                 else
4901                         exc = mono_get_exception_bad_image_format (name);
4902                 g_free (name);
4903                 mono_raise_exception (exc);
4904         }
4905
4906         g_free (name);
4907
4908         assembly = ab->dynamic_assembly;
4909         image->assembly = (MonoAssembly*)assembly;
4910
4911         module_count = image->assembly->image->module_count;
4912         new_modules = g_new0 (MonoImage *, module_count + 1);
4913
4914         if (image->assembly->image->modules)
4915                 memcpy (new_modules, image->assembly->image->modules, module_count * sizeof (MonoImage *));
4916         new_modules [module_count] = image;
4917
4918         g_free (image->assembly->image->modules);
4919         image->assembly->image->modules = new_modules;
4920         image->assembly->image->module_count ++;
4921
4922         mono_assembly_load_references (image, &status);
4923         if (status) {
4924                 mono_image_close (image);
4925                 mono_raise_exception (mono_get_exception_file_not_found (fileName));
4926         }
4927
4928         return mono_module_get_object (mono_domain_get (), image);
4929 }
4930
4931 /*
4932  * We need to return always the same object for MethodInfo, FieldInfo etc..
4933  * but we need to consider the reflected type.
4934  * type uses a different hash, since it uses custom hash/equal functions.
4935  */
4936
4937 typedef struct {
4938         gpointer item;
4939         MonoClass *refclass;
4940 } ReflectedEntry;
4941
4942 static gboolean
4943 reflected_equal (gconstpointer a, gconstpointer b) {
4944         const ReflectedEntry *ea = a;
4945         const ReflectedEntry *eb = b;
4946
4947         return (ea->item == eb->item) && (ea->refclass == eb->refclass);
4948 }
4949
4950 static guint
4951 reflected_hash (gconstpointer a) {
4952         const ReflectedEntry *ea = a;
4953         return GPOINTER_TO_UINT (ea->item);
4954 }
4955
4956 #define CHECK_OBJECT(t,p,k)     \
4957         do {    \
4958                 t _obj; \
4959                 ReflectedEntry e;       \
4960                 e.item = (p);   \
4961                 e.refclass = (k);       \
4962                 mono_domain_lock (domain);      \
4963                 if (!domain->refobject_hash)    \
4964                         domain->refobject_hash = mono_g_hash_table_new (reflected_hash, reflected_equal);       \
4965                 if ((_obj = mono_g_hash_table_lookup (domain->refobject_hash, &e))) {   \
4966                         mono_domain_unlock (domain);    \
4967                         return _obj;    \
4968                 }       \
4969         } while (0)
4970
4971 #if HAVE_BOEHM_GC
4972 #define ALLOC_REFENTRY GC_MALLOC (sizeof (ReflectedEntry))
4973 #else
4974 #define ALLOC_REFENTRY mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
4975 #endif
4976
4977 #define CACHE_OBJECT(p,o,k)     \
4978         do {    \
4979                 ReflectedEntry *e = ALLOC_REFENTRY;     \
4980                 e->item = (p);  \
4981                 e->refclass = (k);      \
4982                 mono_g_hash_table_insert (domain->refobject_hash, e,o); \
4983                 mono_domain_unlock (domain);    \
4984         } while (0)
4985
4986 static void
4987 register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly)
4988 {
4989         /* this is done only once */
4990         mono_domain_lock (domain);
4991         CACHE_OBJECT (assembly, res, NULL);
4992 }
4993
4994 static void
4995 register_module (MonoDomain *domain, MonoReflectionModuleBuilder *res, MonoDynamicImage *module)
4996 {
4997         /* this is done only once */
4998         mono_domain_lock (domain);
4999         CACHE_OBJECT (module, res, NULL);
5000 }
5001
5002 void
5003 mono_image_module_basic_init (MonoReflectionModuleBuilder *moduleb)
5004 {
5005         MonoDynamicImage *image = moduleb->dynamic_image;
5006         MonoReflectionAssemblyBuilder *ab = moduleb->assemblyb;
5007         if (!image) {
5008                 /*
5009                  * FIXME: we already created an image in mono_image_basic_init (), but
5010                  * we don't know which module it belongs to, since that is only
5011                  * determined at assembly save time.
5012                  */
5013                 /*image = (MonoDynamicImage*)ab->dynamic_assembly->assembly.image; */
5014                 image = create_dynamic_mono_image (ab->dynamic_assembly, mono_string_to_utf8 (ab->name), mono_string_to_utf8 (moduleb->module.fqname));
5015
5016                 moduleb->module.image = &image->image;
5017                 moduleb->dynamic_image = image;
5018                 register_module (mono_object_domain (moduleb), moduleb, image);
5019         }
5020 }
5021
5022 /*
5023  * mono_assembly_get_object:
5024  * @domain: an app domain
5025  * @assembly: an assembly
5026  *
5027  * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
5028  */
5029 MonoReflectionAssembly*
5030 mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
5031 {
5032         static MonoClass *System_Reflection_Assembly;
5033         MonoReflectionAssembly *res;
5034
5035         CHECK_OBJECT (MonoReflectionAssembly *, assembly, NULL);
5036         if (!System_Reflection_Assembly)
5037                 System_Reflection_Assembly = mono_class_from_name (
5038                         mono_defaults.corlib, "System.Reflection", "Assembly");
5039         res = (MonoReflectionAssembly *)mono_object_new (domain, System_Reflection_Assembly);
5040         res->assembly = assembly;
5041         CACHE_OBJECT (assembly, res, NULL);
5042         return res;
5043 }
5044
5045
5046
5047 MonoReflectionModule*
5048 mono_module_get_object   (MonoDomain *domain, MonoImage *image)
5049 {
5050         static MonoClass *System_Reflection_Module;
5051         MonoReflectionModule *res;
5052         char* basename;
5053
5054         CHECK_OBJECT (MonoReflectionModule *, image, NULL);
5055         if (!System_Reflection_Module)
5056                 System_Reflection_Module = mono_class_from_name (
5057                         mono_defaults.corlib, "System.Reflection", "Module");
5058         res = (MonoReflectionModule *)mono_object_new (domain, System_Reflection_Module);
5059
5060         res->image = image;
5061         res->assembly = (MonoReflectionAssembly *) mono_assembly_get_object(domain, image->assembly);
5062
5063         res->fqname    = mono_string_new (domain, image->name);
5064         res->name      = mono_string_new (domain, basename = g_path_get_basename (image->name));
5065         res->scopename = mono_string_new (domain, image->module_name);
5066
5067         g_free (basename);
5068
5069         if (image->assembly->image == image) {
5070                 res->token = mono_metadata_make_token (MONO_TABLE_MODULE, 1);
5071         } else {
5072                 int i;
5073                 g_assert (image->assembly->image->modules);
5074                 res->token = 0;
5075                 for (i = 0; i < image->assembly->image->module_count; i++) {
5076                         if (image->assembly->image->modules [i] == image)
5077                                 res->token = mono_metadata_make_token (MONO_TABLE_MODULEREF, i + 1);
5078                 }
5079                 g_assert (res->token);
5080         }
5081
5082         mono_image_addref (image);
5083
5084         CACHE_OBJECT (image, res, NULL);
5085         return res;
5086 }
5087
5088 MonoReflectionModule*
5089 mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index)
5090 {
5091         static MonoClass *System_Reflection_Module;
5092         MonoReflectionModule *res;
5093         MonoTableInfo *table;
5094         guint32 cols [MONO_FILE_SIZE];
5095         const char *name;
5096         guint32 i, name_idx;
5097         const char *val;
5098
5099         if (!System_Reflection_Module)
5100                 System_Reflection_Module = mono_class_from_name (
5101                         mono_defaults.corlib, "System.Reflection", "Module");
5102         res = (MonoReflectionModule *)mono_object_new (domain, System_Reflection_Module);
5103
5104         table = &image->tables [MONO_TABLE_FILE];
5105         g_assert (table_index < table->rows);
5106         mono_metadata_decode_row (table, table_index, cols, MONO_FILE_SIZE);
5107
5108         res->image = 0;
5109         res->assembly = (MonoReflectionAssembly *) mono_assembly_get_object(domain, image->assembly);
5110         name = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]);
5111
5112         /* Check whenever the row has a corresponding row in the moduleref table */
5113         table = &image->tables [MONO_TABLE_MODULEREF];
5114         for (i = 0; i < table->rows; ++i) {
5115                 name_idx = mono_metadata_decode_row_col (table, i, MONO_MODULEREF_NAME);
5116                 val = mono_metadata_string_heap (image, name_idx);
5117                 if (strcmp (val, name) == 0)
5118                         res->image = image->modules [i];
5119         }
5120
5121         res->fqname    = mono_string_new (domain, name);
5122         res->name      = mono_string_new (domain, name);
5123         res->scopename = mono_string_new (domain, name);
5124         res->is_resource = cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA;
5125         res->token = mono_metadata_make_token (MONO_TABLE_FILE, table_index + 1);
5126
5127         return res;
5128 }
5129
5130 static gboolean
5131 mymono_metadata_type_equal (MonoType *t1, MonoType *t2)
5132 {
5133         if ((t1->type != t2->type) ||
5134             (t1->byref != t2->byref))
5135                 return FALSE;
5136
5137         switch (t1->type) {
5138         case MONO_TYPE_VOID:
5139         case MONO_TYPE_BOOLEAN:
5140         case MONO_TYPE_CHAR:
5141         case MONO_TYPE_I1:
5142         case MONO_TYPE_U1:
5143         case MONO_TYPE_I2:
5144         case MONO_TYPE_U2:
5145         case MONO_TYPE_I4:
5146         case MONO_TYPE_U4:
5147         case MONO_TYPE_I8:
5148         case MONO_TYPE_U8:
5149         case MONO_TYPE_R4:
5150         case MONO_TYPE_R8:
5151         case MONO_TYPE_STRING:
5152         case MONO_TYPE_I:
5153         case MONO_TYPE_U:
5154         case MONO_TYPE_OBJECT:
5155         case MONO_TYPE_TYPEDBYREF:
5156                 return TRUE;
5157         case MONO_TYPE_VALUETYPE:
5158         case MONO_TYPE_CLASS:
5159         case MONO_TYPE_SZARRAY:
5160                 return t1->data.klass == t2->data.klass;
5161         case MONO_TYPE_PTR:
5162                 return mymono_metadata_type_equal (t1->data.type, t2->data.type);
5163         case MONO_TYPE_ARRAY:
5164                 if (t1->data.array->rank != t2->data.array->rank)
5165                         return FALSE;
5166                 return t1->data.array->eklass == t2->data.array->eklass;
5167         case MONO_TYPE_GENERICINST: {
5168                 int i;
5169                 if (t1->data.generic_inst->type_argc != t2->data.generic_inst->type_argc)
5170                         return FALSE;
5171                 if (!mono_metadata_type_equal (t1->data.generic_inst->generic_type, t2->data.generic_inst->generic_type))
5172                         return FALSE;
5173                 for (i = 0; i < t1->data.generic_inst->type_argc; ++i) {
5174                         if (!mono_metadata_type_equal (t1->data.generic_inst->type_argv [i], t2->data.generic_inst->type_argv [i]))
5175                                 return FALSE;
5176                 }
5177                 return TRUE;
5178         }
5179         case MONO_TYPE_VAR:
5180         case MONO_TYPE_MVAR:
5181                 return t1->data.generic_param == t2->data.generic_param;
5182         default:
5183                 g_error ("implement type compare for %0x!", t1->type);
5184                 return FALSE;
5185         }
5186
5187         return FALSE;
5188 }
5189
5190 static guint
5191 mymono_metadata_type_hash (MonoType *t1)
5192 {
5193         guint hash;
5194
5195         hash = t1->type;
5196
5197         hash |= t1->byref << 6; /* do not collide with t1->type values */
5198         switch (t1->type) {
5199         case MONO_TYPE_VALUETYPE:
5200         case MONO_TYPE_CLASS:
5201         case MONO_TYPE_SZARRAY:
5202                 /* check if the distribution is good enough */
5203                 return ((hash << 5) - hash) ^ g_str_hash (t1->data.klass->name);
5204         case MONO_TYPE_PTR:
5205                 return ((hash << 5) - hash) ^ mymono_metadata_type_hash (t1->data.type);
5206         }
5207         return hash;
5208 }
5209
5210 static MonoReflectionGenericInst*
5211 mono_generic_inst_get_object (MonoDomain *domain, MonoType *geninst)
5212 {
5213         static MonoClass *System_Reflection_MonoGenericInst;
5214         MonoReflectionGenericInst *res;
5215         MonoGenericInst *ginst;
5216         MonoClass *gklass;
5217
5218         if (!System_Reflection_MonoGenericInst) {
5219                 System_Reflection_MonoGenericInst = mono_class_from_name (
5220                         mono_defaults.corlib, "System.Reflection", "MonoGenericInst");
5221                 g_assert (System_Reflection_MonoGenericInst);
5222         }
5223
5224         ginst = geninst->data.generic_inst;
5225         gklass = mono_class_from_mono_type (ginst->generic_type);
5226
5227         mono_class_init (ginst->klass);
5228
5229         res = (MonoReflectionGenericInst *) mono_object_new (domain, System_Reflection_MonoGenericInst);
5230
5231         res->type.type = geninst;
5232         if (gklass->wastypebuilder && gklass->reflection_info)
5233                 res->generic_type = gklass->reflection_info;
5234         else
5235                 res->generic_type = mono_type_get_object (domain, ginst->generic_type);
5236
5237         return res;
5238 }
5239
5240 /*
5241  * mono_type_get_object:
5242  * @domain: an app domain
5243  * @type: a type
5244  *
5245  * Return an System.MonoType object representing the type @type.
5246  */
5247 MonoReflectionType*
5248 mono_type_get_object (MonoDomain *domain, MonoType *type)
5249 {
5250         MonoReflectionType *res;
5251         MonoClass *klass = mono_class_from_mono_type (type);
5252
5253         mono_domain_lock (domain);
5254         if (!domain->type_hash)
5255                 domain->type_hash = mono_g_hash_table_new ((GHashFunc)mymono_metadata_type_hash,
5256                                 (GCompareFunc)mymono_metadata_type_equal);
5257         if ((res = mono_g_hash_table_lookup (domain->type_hash, type))) {
5258                 mono_domain_unlock (domain);
5259                 return res;
5260         }
5261         if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_inst->is_dynamic) {
5262                 res = (MonoReflectionType *)mono_generic_inst_get_object (domain, type);
5263                 mono_g_hash_table_insert (domain->type_hash, type, res);
5264                 mono_domain_unlock (domain);
5265                 return res;
5266         }
5267         if (klass->reflection_info && !klass->wastypebuilder) {
5268                 /* g_assert_not_reached (); */
5269                 /* should this be considered an error condition? */
5270                 if (!type->byref) {
5271                         mono_domain_unlock (domain);
5272                         return klass->reflection_info;
5273                 }
5274         }
5275         mono_class_init (klass);
5276         res = (MonoReflectionType *)mono_object_new (domain, mono_defaults.monotype_class);
5277         res->type = type;
5278         mono_g_hash_table_insert (domain->type_hash, type, res);
5279         mono_domain_unlock (domain);
5280         return res;
5281 }
5282
5283 /*
5284  * mono_method_get_object:
5285  * @domain: an app domain
5286  * @method: a method
5287  * @refclass: the reflected type (can be NULL)
5288  *
5289  * Return an System.Reflection.MonoMethod object representing the method @method.
5290  */
5291 MonoReflectionMethod*
5292 mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
5293 {
5294         /*
5295          * We use the same C representation for methods and constructors, but the type
5296          * name in C# is different.
5297          */
5298         const char *cname;
5299         MonoClass *klass;
5300         MonoReflectionMethod *ret;
5301
5302         if (!refclass)
5303                 refclass = method->klass;
5304
5305         CHECK_OBJECT (MonoReflectionMethod *, method, refclass);
5306         if (*method->name == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0))
5307                 cname = "MonoCMethod";
5308         else
5309                 cname = "MonoMethod";
5310         klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", cname);
5311
5312         ret = (MonoReflectionMethod*)mono_object_new (domain, klass);
5313         ret->method = method;
5314         ret->name = mono_string_new (domain, method->name);
5315         ret->reftype = mono_type_get_object (domain, &refclass->byval_arg);
5316         CACHE_OBJECT (method, ret, refclass);
5317         return ret;
5318 }
5319
5320 /*
5321  * mono_field_get_object:
5322  * @domain: an app domain
5323  * @klass: a type
5324  * @field: a field
5325  *
5326  * Return an System.Reflection.MonoField object representing the field @field
5327  * in class @klass.
5328  */
5329 MonoReflectionField*
5330 mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field)
5331 {
5332         MonoReflectionField *res;
5333         MonoClass *oklass;
5334
5335         CHECK_OBJECT (MonoReflectionField *, field, klass);
5336         oklass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoField");
5337         res = (MonoReflectionField *)mono_object_new (domain, oklass);
5338         res->klass = klass;
5339         res->field = field;
5340         res->name = mono_string_new (domain, field->name);
5341         if (field->generic_info)
5342                 res->attrs = field->generic_info->generic_type->attrs;
5343         else
5344                 res->attrs = field->type->attrs;
5345         res->type = mono_type_get_object (domain, field->type);
5346         CACHE_OBJECT (field, res, klass);
5347         return res;
5348 }
5349
5350 /*
5351  * mono_property_get_object:
5352  * @domain: an app domain
5353  * @klass: a type
5354  * @property: a property
5355  *
5356  * Return an System.Reflection.MonoProperty object representing the property @property
5357  * in class @klass.
5358  */
5359 MonoReflectionProperty*
5360 mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property)
5361 {
5362         MonoReflectionProperty *res;
5363         MonoClass *oklass;
5364
5365         CHECK_OBJECT (MonoReflectionProperty *, property, klass);
5366         oklass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoProperty");
5367         res = (MonoReflectionProperty *)mono_object_new (domain, oklass);
5368         res->klass = klass;
5369         res->property = property;
5370         CACHE_OBJECT (property, res, klass);
5371         return res;
5372 }
5373
5374 /*
5375  * mono_event_get_object:
5376  * @domain: an app domain
5377  * @klass: a type
5378  * @event: a event
5379  *
5380  * Return an System.Reflection.MonoEvent object representing the event @event
5381  * in class @klass.
5382  */
5383 MonoReflectionEvent*
5384 mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
5385 {
5386         MonoReflectionEvent *res;
5387         MonoClass *oklass;
5388
5389         CHECK_OBJECT (MonoReflectionEvent *, event, klass);
5390         oklass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MonoEvent");
5391         res = (MonoReflectionEvent *)mono_object_new (domain, oklass);
5392         res->klass = klass;
5393         res->event = event;
5394         CACHE_OBJECT (event, res, klass);
5395         return res;
5396 }
5397
5398 /*
5399  * mono_param_get_objects:
5400  * @domain: an app domain
5401  * @method: a method
5402  *
5403  * Return an System.Reflection.ParameterInfo array object representing the parameters
5404  * in the method @method.
5405  */
5406 MonoArray*
5407 mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
5408 {
5409         static MonoClass *System_Reflection_ParameterInfo;
5410         MonoArray *res = NULL;
5411         MonoReflectionMethod *member = NULL;
5412         MonoReflectionParameter *param = NULL;
5413         char **names, **blobs = NULL;
5414         MonoObject *dbnull = mono_get_dbnull_object (domain);
5415         MonoMarshalSpec **mspecs;
5416         int i;
5417
5418         if (!System_Reflection_ParameterInfo)
5419                 System_Reflection_ParameterInfo = mono_class_from_name (
5420                         mono_defaults.corlib, "System.Reflection", "ParameterInfo");
5421
5422         if (!method->signature->param_count)
5423                 return mono_array_new (domain, System_Reflection_ParameterInfo, 0);
5424
5425         /* Note: the cache is based on the address of the signature into the method
5426          * since we already cache MethodInfos with the method as keys.
5427          */
5428         CHECK_OBJECT (MonoArray*, &(method->signature), NULL);
5429
5430         member = mono_method_get_object (domain, method, NULL);
5431         names = g_new (char *, method->signature->param_count);
5432         mono_method_get_param_names (method, (const char **) names);
5433
5434         mspecs = g_new (MonoMarshalSpec*, method->signature->param_count + 1);
5435         mono_method_get_marshal_info (method, mspecs);
5436
5437         res = mono_array_new (domain, System_Reflection_ParameterInfo, method->signature->param_count);
5438         for (i = 0; i < method->signature->param_count; ++i) {
5439                 param = (MonoReflectionParameter *)mono_object_new (domain, System_Reflection_ParameterInfo);
5440                 param->ClassImpl = mono_type_get_object (domain, method->signature->params [i]);
5441                 param->MemberImpl = (MonoObject*)member;
5442                 param->NameImpl = mono_string_new (domain, names [i]);
5443                 param->PositionImpl = i;
5444                 param->AttrsImpl = method->signature->params [i]->attrs;
5445
5446                 if (!(param->AttrsImpl & PARAM_ATTRIBUTE_HAS_DEFAULT)) {
5447                         param->DefaultValueImpl = dbnull;
5448                 } else {
5449                         MonoType *type = param->ClassImpl->type;
5450
5451                         if (!blobs) {
5452                                 blobs = g_new0 (char *, method->signature->param_count);
5453                                 get_default_param_value_blobs (method, blobs);
5454                         }
5455
5456                         param->DefaultValueImpl = mono_get_object_from_blob (domain, type, blobs [i]);
5457
5458                         if (!param->DefaultValueImpl) {
5459                                 param->DefaultValueImpl = dbnull;
5460                         }
5461                 }
5462
5463                 if (mspecs [i + 1])
5464                         param->MarshalAsImpl = (MonoObject*)mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [i + 1]);
5465
5466                 mono_array_set (res, gpointer, i, param);
5467         }
5468         g_free (names);
5469         g_free (blobs);
5470
5471         for (i = method->signature->param_count; i >= 0; i--)
5472                 if (mspecs [i])
5473                         mono_metadata_free_marshal_spec (mspecs [i]);
5474         g_free (mspecs);
5475
5476         CACHE_OBJECT (&(method->signature), res, NULL);
5477         return res;
5478 }
5479
5480 /*
5481  * mono_method_body_get_object:
5482  * @domain: an app domain
5483  * @method: a method
5484  *
5485  * Return an System.Reflection.MethodBody object representing the method @method.
5486  */
5487 MonoReflectionMethodBody*
5488 mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
5489 {
5490         static MonoClass *System_Reflection_MethodBody = NULL;
5491         static MonoClass *System_Reflection_LocalVariableInfo = NULL;
5492         MonoReflectionMethodBody *ret;
5493         MonoMethodNormal *mn;
5494         MonoMethodHeader *header;
5495         int i;
5496
5497         if (!System_Reflection_MethodBody)
5498                 System_Reflection_MethodBody = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "MethodBody");
5499         if (!System_Reflection_LocalVariableInfo)
5500                 System_Reflection_LocalVariableInfo = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "LocalVariableInfo");
5501
5502         CHECK_OBJECT (MonoReflectionMethodBody *, method, NULL);
5503
5504         if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
5505             (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
5506                 return NULL;
5507         mn = (MonoMethodNormal *)method;
5508         header = mn->header;
5509
5510         ret = (MonoReflectionMethodBody*)mono_object_new (domain, System_Reflection_MethodBody);
5511         /* FIXME: Other fields */
5512         ret->init_locals = header->init_locals;
5513         ret->max_stack = header->max_stack;
5514         ret->il = mono_array_new (domain, mono_defaults.byte_class, header->code_size);
5515         memcpy (mono_array_addr (ret->il, guint8*, 0), header->code, header->code_size);
5516         ret->locals = mono_array_new (domain, System_Reflection_LocalVariableInfo, header->num_locals);
5517         for (i = 0; i < header->num_locals; ++i) {
5518                 MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new (domain, System_Reflection_LocalVariableInfo);
5519                 info->local_type = mono_type_get_object (domain, header->locals [i]);
5520                 info->is_pinned = header->locals [i]->pinned;
5521                 info->local_index = 0;
5522         }
5523
5524         CACHE_OBJECT (method, ret, NULL);
5525         return ret;
5526 }
5527
5528 MonoObject *
5529 mono_get_dbnull_object (MonoDomain *domain)
5530 {
5531         MonoObject *obj;
5532         MonoClass *klass;
5533         static MonoClassField *dbnull_value_field = NULL;
5534
5535         if (!dbnull_value_field) {
5536                 klass = mono_class_from_name (mono_defaults.corlib, "System", "DBNull");
5537                 mono_class_init (klass);
5538                 dbnull_value_field = mono_class_get_field_from_name (klass, "Value");
5539                 g_assert (dbnull_value_field);
5540         }
5541         obj = mono_field_get_value_object (domain, dbnull_value_field, NULL);
5542         g_assert (obj);
5543         return obj;
5544 }
5545
5546
5547 static void
5548 get_default_param_value_blobs (MonoMethod *method, char **blobs)
5549 {
5550         guint32 param_index, i, lastp, crow = 0;
5551         guint32 param_cols [MONO_PARAM_SIZE], const_cols [MONO_CONSTANT_SIZE];
5552         gint32 idx = -1;
5553
5554         MonoClass *klass = method->klass;
5555         MonoImage *image = klass->image;
5556         MonoMethodSignature *methodsig = method->signature;
5557
5558         MonoTableInfo *constt;
5559         MonoTableInfo *methodt;
5560         MonoTableInfo *paramt;
5561
5562         if (!methodsig->param_count)
5563                 return;
5564
5565         if (klass->generic_inst) {
5566                 return; /* FIXME - ??? */
5567         }
5568
5569         mono_class_init (klass);
5570
5571         if (klass->image->dynamic) {
5572                 MonoReflectionMethodAux *aux = mono_g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
5573                 if (aux && aux->param_defaults)
5574                         memcpy (blobs, &(aux->param_defaults [1]), methodsig->param_count * sizeof (char*));
5575                 return;
5576         }
5577
5578         methodt = &klass->image->tables [MONO_TABLE_METHOD];
5579         paramt = &klass->image->tables [MONO_TABLE_PARAM];
5580         constt = &image->tables [MONO_TABLE_CONSTANT];
5581
5582         for (i = 0; i < klass->method.count; ++i) {
5583                 if (method == klass->methods [i]) {
5584                         idx = klass->method.first + i;
5585                         break;
5586                 }
5587         }
5588
5589         g_assert (idx != -1);
5590
5591         param_index = mono_metadata_decode_row_col (methodt, idx, MONO_METHOD_PARAMLIST);
5592         if (idx + 1 < methodt->rows)
5593                 lastp = mono_metadata_decode_row_col (methodt, idx + 1, MONO_METHOD_PARAMLIST);
5594         else
5595                 lastp = paramt->rows + 1;
5596
5597         for (i = param_index; i < lastp; ++i) {
5598                 guint32 paramseq;
5599
5600                 mono_metadata_decode_row (paramt, i - 1, param_cols, MONO_PARAM_SIZE);
5601                 paramseq = param_cols [MONO_PARAM_SEQUENCE];
5602
5603                 if (!param_cols [MONO_PARAM_FLAGS] & PARAM_ATTRIBUTE_HAS_DEFAULT)
5604                         continue;
5605
5606                 crow = mono_metadata_get_constant_index (image, MONO_TOKEN_PARAM_DEF | i, crow + 1);
5607                 if (!crow) {
5608                         continue;
5609                 }
5610
5611                 mono_metadata_decode_row (constt, crow - 1, const_cols, MONO_CONSTANT_SIZE);
5612                 blobs [paramseq - 1] = (gpointer) mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
5613         }
5614
5615         return;
5616 }
5617
5618 static MonoObject *
5619 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob)
5620 {
5621         void *retval;
5622         MonoClass *klass;
5623         MonoObject *object;
5624
5625         if (!blob)
5626                 return NULL;
5627
5628         klass = mono_class_from_mono_type (type);
5629         if (klass->valuetype) {
5630                 object = mono_object_new (domain, klass);
5631                 retval = ((gchar *) object + sizeof (MonoObject));
5632         } else {
5633                 retval = &object;
5634         }
5635
5636         if (!mono_get_constant_value_from_blob (domain, type->type,  blob, retval))
5637                 return object;
5638         else
5639                 return NULL;
5640 }
5641
5642 static int
5643 assembly_name_to_aname (MonoAssemblyName *assembly, char *p) {
5644         int found_sep;
5645         char *s;
5646
5647         memset (assembly, 0, sizeof (MonoAssemblyName));
5648         assembly->name = p;
5649         assembly->culture = "";
5650         memset (assembly->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
5651
5652         while (*p && (isalnum (*p) || *p == '.' || *p == '-' || *p == '_' || *p == '$' || *p == '@'))
5653                 p++;
5654         found_sep = 0;
5655         while (*p == ' ' || *p == ',') {
5656                 *p++ = 0;
5657                 found_sep = 1;
5658                 continue;
5659         }
5660         /* failed */
5661         if (!found_sep)
5662                 return 1;
5663         while (*p) {
5664                 if (*p == 'V' && g_ascii_strncasecmp (p, "Version=", 8) == 0) {
5665                         p += 8;
5666                         assembly->major = strtoul (p, &s, 10);
5667                         if (s == p || *s != '.')
5668                                 return 1;
5669                         p = ++s;
5670                         assembly->minor = strtoul (p, &s, 10);
5671                         if (s == p || *s != '.')
5672                                 return 1;
5673                         p = ++s;
5674                         assembly->build = strtoul (p, &s, 10);
5675                         if (s == p || *s != '.')
5676                                 return 1;
5677                         p = ++s;
5678                         assembly->revision = strtoul (p, &s, 10);
5679                         if (s == p)
5680                                 return 1;
5681                         p = s;
5682                 } else if (*p == 'C' && g_ascii_strncasecmp (p, "Culture=", 8) == 0) {
5683                         p += 8;
5684                         if (g_ascii_strncasecmp (p, "neutral", 7) == 0) {
5685                                 assembly->culture = "";
5686                                 p += 7;
5687                         } else {
5688                                 assembly->culture = p;
5689                                 while (*p && *p != ',') {
5690                                         p++;
5691                                 }
5692                         }
5693                 } else if (*p == 'P' && g_ascii_strncasecmp (p, "PublicKeyToken=", 15) == 0) {
5694                         p += 15;
5695                         if (strncmp (p, "null", 4) == 0) {
5696                                 p += 4;
5697                         } else {
5698                                 int len;
5699                                 gchar *start = p;
5700                                 while (*p && *p != ',') {
5701                                         p++;
5702                                 }
5703                                 len = (p - start + 1);
5704                                 if (len > MONO_PUBLIC_KEY_TOKEN_LENGTH)
5705                                         len = MONO_PUBLIC_KEY_TOKEN_LENGTH;
5706                                 g_strlcpy (assembly->public_key_token, start, len);
5707                         }
5708                 } else {
5709                         while (*p && *p != ',')
5710                                 p++;
5711                 }
5712                 found_sep = 0;
5713                 while (*p == ' ' || *p == ',') {
5714                         *p++ = 0;
5715                         found_sep = 1;
5716                         continue;
5717                 }
5718                 /* failed */
5719                 if (!found_sep)
5720                         return 1;
5721         }
5722
5723         return 0;
5724 }
5725
5726 /*
5727  * mono_reflection_parse_type:
5728  * @name: type name
5729  *
5730  * Parse a type name as accepted by the GetType () method and output the info
5731  * extracted in the info structure.
5732  * the name param will be mangled, so, make a copy before passing it to this function.
5733  * The fields in info will be valid until the memory pointed to by name is valid.
5734  * Returns 0 on parse error.
5735  * See also mono_type_get_name () below.
5736  */
5737 int
5738 mono_reflection_parse_type (char *name, MonoTypeNameParse *info) {
5739
5740         char *start, *p, *w, *last_point, *startn;
5741         int in_modifiers = 0;
5742         int isbyref = 0, rank;
5743
5744         start = p = w = name;
5745
5746         memset (&info->assembly, 0, sizeof (MonoAssemblyName));
5747         info->name = info->name_space = NULL;
5748         info->nested = NULL;
5749         info->modifiers = NULL;
5750
5751         /* last_point separates the namespace from the name */
5752         last_point = NULL;
5753
5754         while (*p) {
5755                 switch (*p) {
5756                 case '+':
5757                         *p = 0; /* NULL terminate the name */
5758                         startn = p + 1;
5759                         info->nested = g_list_append (info->nested, startn);
5760                         /* we have parsed the nesting namespace + name */
5761                         if (info->name)
5762                                 break;
5763                         if (last_point) {
5764                                 info->name_space = start;
5765                                 *last_point = 0;
5766                                 info->name = last_point + 1;
5767                         } else {
5768                                 info->name_space = (char *)"";
5769                                 info->name = start;
5770                         }
5771                         break;
5772                 case '.':
5773                         last_point = w;
5774                         break;
5775                 case '\\':
5776                         ++p;
5777                         break;
5778                 case '&':
5779                 case '*':
5780                 case '[':
5781                 case ',':
5782                         in_modifiers = 1;
5783                         break;
5784                 default:
5785                         break;
5786                 }
5787                 if (in_modifiers)
5788                         break;
5789                 *w++ = *p++;
5790         }
5791
5792         if (!info->name) {
5793                 if (last_point) {
5794                         info->name_space = start;
5795                         *last_point = 0;
5796                         info->name = last_point + 1;
5797                 } else {
5798                         info->name_space = (char *)"";
5799                         info->name = start;
5800                 }
5801         }
5802         while (*p) {
5803                 switch (*p) {
5804                 case '&':
5805                         if (isbyref) /* only one level allowed by the spec */
5806                                 return 0;
5807                         isbyref = 1;
5808                         info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (0));
5809                         *p++ = 0;
5810                         break;
5811                 case '*':
5812                         info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-1));
5813                         *p++ = 0;
5814                         break;
5815                 case '[':
5816                         rank = 1;
5817                         *p++ = 0;
5818                         while (*p) {
5819                                 if (*p == ']')
5820                                         break;
5821                                 if (*p == ',')
5822                                         rank++;
5823                                 else if (*p != '*') /* '*' means unknown lower bound */
5824                                         return 0;
5825                                 ++p;
5826                         }
5827                         if (*p++ != ']')
5828                                 return 0;
5829                         info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (rank));
5830                         break;
5831                 case ',':
5832                         *p++ = 0;
5833                         while (*p) {
5834                                 if (*p == ' ') {
5835                                         ++p;
5836                                         continue;
5837                                 }
5838                                 break;
5839                         }
5840                         if (!*p)
5841                                 return 0; /* missing assembly name */
5842                         if (!assembly_name_to_aname (&info->assembly, p))
5843                                 return 0;
5844                         break;
5845                 default:
5846                         return 0;
5847                         break;
5848                 }
5849                 if (info->assembly.name)
5850                         break;
5851         }
5852         *w = 0; /* terminate class name */
5853         if (!info->name || !*info->name)
5854                 return 0;
5855         /* add other consistency checks */
5856         return 1;
5857 }
5858
5859 static MonoType*
5860 mono_reflection_get_type_internal (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase)
5861 {
5862         MonoClass *klass;
5863         GList *mod;
5864         int modval;
5865
5866         if (!image)
5867                 image = mono_defaults.corlib;
5868
5869         if (ignorecase)
5870                 klass = mono_class_from_name_case (image, info->name_space, info->name);
5871         else
5872                 klass = mono_class_from_name (image, info->name_space, info->name);
5873         if (!klass)
5874                 return NULL;
5875         for (mod = info->nested; mod; mod = mod->next) {
5876                 GList *nested;
5877
5878                 mono_class_init (klass);
5879                 nested = klass->nested_classes;
5880                 klass = NULL;
5881                 while (nested) {
5882                         klass = nested->data;
5883                         if (ignorecase) {
5884                                 if (g_strcasecmp (klass->name, mod->data) == 0)
5885                                         break;
5886                         } else {
5887                                 if (strcmp (klass->name, mod->data) == 0)
5888                                         break;
5889                         }
5890                         klass = NULL;
5891                         nested = nested->next;
5892                 }
5893                 if (!klass)
5894                         break;
5895         }
5896         if (!klass)
5897                 return NULL;
5898         mono_class_init (klass);
5899         for (mod = info->modifiers; mod; mod = mod->next) {
5900                 modval = GPOINTER_TO_UINT (mod->data);
5901                 if (!modval) { /* byref: must be last modifier */
5902                         return &klass->this_arg;
5903                 } else if (modval == -1) {
5904                         klass = mono_ptr_class_get (&klass->byval_arg);
5905                 } else { /* array rank */
5906                         klass = mono_array_class_get (klass, modval);
5907                 }
5908                 mono_class_init (klass);
5909         }
5910
5911         return &klass->byval_arg;
5912 }
5913
5914 /*
5915  * mono_reflection_get_type:
5916  * @image: a metadata context
5917  * @info: type description structure
5918  * @ignorecase: flag for case-insensitive string compares
5919  * @type_resolve: whenever type resolve was already tried
5920  *
5921  * Build a MonoType from the type description in @info.
5922  *
5923  */
5924
5925 MonoType*
5926 mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve)
5927 {
5928         MonoType *type;
5929         MonoReflectionAssembly *assembly;
5930         GString *fullName;
5931         GList *mod;
5932
5933         type = mono_reflection_get_type_internal (image, info, ignorecase);
5934         if (type)
5935                 return type;
5936         if (!mono_domain_has_type_resolve (mono_domain_get ()))
5937                 return NULL;
5938
5939         if (type_resolve) {
5940                 if (*type_resolve)
5941                         return NULL;
5942                 else
5943                         *type_resolve = TRUE;
5944         }
5945
5946         /* Reconstruct the type name */
5947         fullName = g_string_new ("");
5948         if (info->name_space && (info->name_space [0] != '\0'))
5949                 g_string_printf (fullName, "%s.%s", info->name_space, info->name);
5950         else
5951                 g_string_printf (fullName, info->name);
5952         for (mod = info->nested; mod; mod = mod->next)
5953                 g_string_append_printf (fullName, "+%s", (char*)mod->data);
5954
5955         assembly = mono_domain_try_type_resolve ( mono_domain_get (), fullName->str, NULL);
5956         if (assembly) {
5957                 if (assembly->assembly->dynamic) {
5958                         /* Enumerate all modules */
5959                         MonoReflectionAssemblyBuilder *abuilder = (MonoReflectionAssemblyBuilder*)assembly;
5960                         int i;
5961
5962                         type = NULL;
5963                         if (abuilder->modules) {
5964                                 for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
5965                                         MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
5966                                         type = mono_reflection_get_type_internal (&mb->dynamic_image->image, info, ignorecase);
5967                                         if (type)
5968                                                 break;
5969                                 }
5970                         }
5971
5972                         if (!type && abuilder->loaded_modules) {
5973                                 for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
5974                                         MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
5975                                         type = mono_reflection_get_type_internal (mod->image, info, ignorecase);
5976                                         if (type)
5977                                                 break;
5978                                 }
5979                         }
5980                 }
5981                 else
5982                         type = mono_reflection_get_type_internal (assembly->assembly->image,
5983                                                                                                           info, ignorecase);
5984         }
5985         g_string_free (fullName, TRUE);
5986         return type;
5987 }
5988
5989 /*
5990  * mono_reflection_type_from_name:
5991  * @name: type name.
5992  * @image: a metadata context (can be NULL).
5993  *
5994  * Retrieves a MonoType from its @name. If the name is not fully qualified,
5995  * it defaults to get the type from @image or, if @image is NULL or loading
5996  * from it fails, uses corlib.
5997  *
5998  */
5999 MonoType*
6000 mono_reflection_type_from_name (char *name, MonoImage *image)
6001 {
6002         MonoType *type;
6003         MonoTypeNameParse info;
6004         MonoAssembly *assembly;
6005         char *tmp;
6006         gboolean type_resolve = FALSE;
6007
6008         /* Make a copy since parse_type modifies its argument */
6009         tmp = g_strdup (name);
6010
6011         /*g_print ("requested type %s\n", str);*/
6012         if (!mono_reflection_parse_type (tmp, &info)) {
6013                 g_free (tmp);
6014                 g_list_free (info.modifiers);
6015                 g_list_free (info.nested);
6016                 return NULL;
6017         }
6018
6019         if (info.assembly.name) {
6020                 assembly = mono_assembly_loaded (&info.assembly);
6021                 if (!assembly) {
6022                         /* then we must load the assembly ourselve - see #60439 */
6023                         assembly = mono_assembly_load (&info.assembly, NULL, NULL);
6024                         if (!assembly) {
6025                                 g_free (tmp);
6026                                 g_list_free (info.modifiers);
6027                                 g_list_free (info.nested);
6028                                 return NULL;
6029                         }
6030                 }
6031                 image = assembly->image;
6032         } else if (image == NULL) {
6033                 image = mono_defaults.corlib;
6034         }
6035
6036         type = mono_reflection_get_type (image, &info, FALSE, &type_resolve);
6037         if (type == NULL && !info.assembly.name && image != mono_defaults.corlib) {
6038                 image = mono_defaults.corlib;
6039                 type = mono_reflection_get_type (image, &info, FALSE, &type_resolve);
6040         }
6041
6042         g_free (tmp);
6043         g_list_free (info.modifiers);
6044         g_list_free (info.nested);
6045         return type;
6046 }
6047
6048 /*
6049  * mono_reflection_get_token:
6050  *
6051  *   Return the metadata token of OBJ which should be an object
6052  * representing a metadata element.
6053  */
6054 guint32
6055 mono_reflection_get_token (MonoObject *obj)
6056 {
6057         MonoClass *klass;
6058         guint32 token = 0;
6059
6060         klass = obj->vtable->klass;
6061
6062         if (strcmp (klass->name, "MethodBuilder") == 0) {
6063                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
6064
6065                 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
6066         } else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
6067                 MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
6068
6069                 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
6070         } else if (strcmp (klass->name, "FieldBuilder") == 0) {
6071                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
6072                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)fb->typeb;
6073                 if (tb->generic_params) {
6074                         g_assert_not_reached ();
6075                 } else {
6076                         token = fb->table_idx | MONO_TOKEN_FIELD_DEF;
6077                 }
6078         } else if (strcmp (klass->name, "TypeBuilder") == 0) {
6079                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
6080                 token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
6081         } else if (strcmp (klass->name, "MonoType") == 0) {
6082                 MonoReflectionType *tb = (MonoReflectionType *)obj;
6083                 token = mono_class_from_mono_type (tb->type)->type_token;
6084         } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
6085                         strcmp (klass->name, "MonoMethod") == 0) {
6086                 MonoReflectionMethod *m = (MonoReflectionMethod *)obj;
6087                 if (m->method->signature->is_inflated) {
6088                         g_assert_not_reached ();
6089                 } else if (m->method->signature->generic_param_count) {
6090                         g_assert_not_reached ();
6091                 } else if (m->method->klass->generic_inst) {
6092                         g_assert_not_reached ();
6093                 } else {
6094                         token = m->method->token;
6095                 }
6096         } else if (strcmp (klass->name, "MonoField") == 0) {
6097                 MonoReflectionField *f = (MonoReflectionField*)obj;
6098
6099                 token = mono_class_get_field_token (f->field);
6100         } else if (strcmp (klass->name, "MonoProperty") == 0) {
6101                 MonoReflectionProperty *p = (MonoReflectionProperty*)obj;
6102
6103                 token = mono_class_get_property_token (p->property);
6104         } else if (strcmp (klass->name, "MonoEvent") == 0) {
6105                 MonoReflectionEvent *p = (MonoReflectionEvent*)obj;
6106
6107                 token = mono_class_get_event_token (p->event);
6108         } else if (strcmp (klass->name, "ParameterInfo") == 0) {
6109                 MonoReflectionParameter *p = (MonoReflectionParameter*)obj;
6110
6111                 token = mono_method_get_param_token (((MonoReflectionMethod*)p->MemberImpl)->method, p->PositionImpl);
6112         } else if (strcmp (klass->name, "Module") == 0) {
6113                 MonoReflectionModule *m = (MonoReflectionModule*)obj;
6114
6115                 token = m->token;
6116         } else if (strcmp (klass->name, "Assembly") == 0) {
6117                 token = mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1);
6118         } else {
6119                 gchar *msg = g_strdup_printf ("MetadataToken is not supported for type '%s.%s'", klass->name_space, klass->name);
6120                 MonoException *ex = mono_get_exception_not_implemented (msg);
6121                 g_free (msg);
6122                 mono_raise_exception (ex);
6123         }
6124
6125         return token;
6126 }
6127
6128 static void*
6129 load_cattr_value (MonoImage *image, MonoType *t, const char *p, const char **end)
6130 {
6131         int slen, type = t->type;
6132 handle_enum:
6133         switch (type) {
6134         case MONO_TYPE_U1:
6135         case MONO_TYPE_I1:
6136         case MONO_TYPE_BOOLEAN: {
6137                 MonoBoolean *bval = g_malloc (sizeof (MonoBoolean));
6138                 *bval = *p;
6139                 *end = p + 1;
6140                 return bval;
6141         }
6142         case MONO_TYPE_CHAR:
6143         case MONO_TYPE_U2:
6144         case MONO_TYPE_I2: {
6145                 guint16 *val = g_malloc (sizeof (guint16));
6146                 *val = read16 (p);
6147                 *end = p + 2;
6148                 return val;
6149         }
6150 #if SIZEOF_VOID_P == 4
6151         case MONO_TYPE_U:
6152         case MONO_TYPE_I:
6153 #endif
6154         case MONO_TYPE_R4:
6155         case MONO_TYPE_U4:
6156         case MONO_TYPE_I4: {
6157                 guint32 *val = g_malloc (sizeof (guint32));
6158                 *val = read32 (p);
6159                 *end = p + 4;
6160                 return val;
6161         }
6162 #if SIZEOF_VOID_P == 8
6163         case MONO_TYPE_U: /* error out instead? this should probably not happen */
6164         case MONO_TYPE_I:
6165 #endif
6166         case MONO_TYPE_R8:
6167         case MONO_TYPE_U8:
6168         case MONO_TYPE_I8: {
6169                 guint64 *val = g_malloc (sizeof (guint64));
6170                 *val = read64 (p);
6171                 *end = p + 8;
6172                 return val;
6173         }
6174         case MONO_TYPE_VALUETYPE:
6175                 if (t->data.klass->enumtype) {
6176                         type = t->data.klass->enum_basetype->type;
6177                         goto handle_enum;
6178                 } else {
6179                         g_error ("generic valutype %s not handled in custom attr value decoding", t->data.klass->name);
6180                 }
6181                 break;
6182         case MONO_TYPE_STRING:
6183                 if (*p == (char)0xFF) {
6184                         *end = p + 1;
6185                         return NULL;
6186                 }
6187                 slen = mono_metadata_decode_value (p, &p);
6188                 *end = p + slen;
6189                 return mono_string_new_len (mono_domain_get (), p, slen);
6190         case MONO_TYPE_CLASS: {
6191                 char *n;
6192                 MonoType *t;
6193                 if (*p == (char)0xFF) {
6194                         *end = p + 1;
6195                         return NULL;
6196                 }
6197 handle_type:
6198                 slen = mono_metadata_decode_value (p, &p);
6199                 n = g_memdup (p, slen + 1);
6200                 n [slen] = 0;
6201                 t = mono_reflection_type_from_name (n, image);
6202                 if (!t)
6203                         g_warning ("Cannot load type '%s'", n);
6204                 g_free (n);
6205                 *end = p + slen;
6206                 if (t)
6207                         return mono_type_get_object (mono_domain_get (), t);
6208                 else
6209                         return NULL;
6210         }
6211         case MONO_TYPE_OBJECT: {
6212                 char subt = *p++;
6213                 MonoObject *obj;
6214                 MonoClass *subc = NULL;
6215                 void *val;
6216
6217                 if (subt == 0x50) {
6218                         goto handle_type;
6219                 } else if (subt == 0x0E) {
6220                         type = MONO_TYPE_STRING;
6221                         goto handle_enum;
6222                 } else if (subt == 0x55) {
6223                         char *n;
6224                         MonoType *t;
6225                         slen = mono_metadata_decode_value (p, &p);
6226                         n = g_memdup (p, slen + 1);
6227                         n [slen] = 0;
6228                         t = mono_reflection_type_from_name (n, image);
6229                         if (!t)
6230                                 g_warning ("Cannot load type '%s'", n);
6231                         g_free (n);
6232                         p += slen;
6233                         subc = mono_class_from_mono_type (t);
6234                 } else if (subt >= MONO_TYPE_BOOLEAN && subt <= MONO_TYPE_R8) {
6235                         MonoType simple_type = {{0}};
6236                         simple_type.type = subt;
6237                         subc = mono_class_from_mono_type (&simple_type);
6238                 } else {
6239                         g_error ("Unknown type 0x%02x for object type encoding in custom attr", subt);
6240                 }
6241                 val = load_cattr_value (image, &subc->byval_arg, p, end);
6242                 obj = mono_object_new (mono_domain_get (), subc);
6243                 memcpy ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
6244                 g_free (val);
6245                 return obj;
6246         }
6247         case MONO_TYPE_SZARRAY: {
6248                 MonoArray *arr;
6249                 guint32 i, alen, basetype;
6250                 alen = read32 (p);
6251                 p += 4;
6252                 if (alen == 0xffffffff) {
6253                         *end = p;
6254                         return NULL;
6255                 }
6256                 arr = mono_array_new (mono_domain_get(), t->data.klass, alen);
6257                 basetype = t->data.klass->byval_arg.type;
6258                 switch (basetype)
6259                 {
6260                         case MONO_TYPE_U1:
6261                         case MONO_TYPE_I1:
6262                         case MONO_TYPE_BOOLEAN:
6263                                 for (i = 0; i < alen; i++) {
6264                                         MonoBoolean val = *p++;
6265                                         mono_array_set (arr, MonoBoolean, i, val);
6266                                 }
6267                                 break;
6268                         case MONO_TYPE_CHAR:
6269                         case MONO_TYPE_U2:
6270                         case MONO_TYPE_I2:
6271                                 for (i = 0; i < alen; i++) {
6272                                         guint16 val = read16 (p);
6273                                         mono_array_set (arr, guint16, i, val);
6274                                         p += 2;
6275                                 }
6276                                 break;
6277                         case MONO_TYPE_R4:
6278                         case MONO_TYPE_U4:
6279                         case MONO_TYPE_I4:
6280                                 for (i = 0; i < alen; i++) {
6281                                         guint32 val = read32 (p);
6282                                         mono_array_set (arr, guint32, i, val);
6283                                         p += 4;
6284                                 }
6285                                 break;
6286                         case MONO_TYPE_R8:
6287                         case MONO_TYPE_U8:
6288                         case MONO_TYPE_I8:
6289                                 for (i = 0; i < alen; i++) {
6290                                         guint64 val = read64 (p);
6291                                         mono_array_set (arr, guint64, i, val);
6292                                         p += 8;
6293                                 }
6294                                 break;
6295                         case MONO_TYPE_CLASS:
6296                         case MONO_TYPE_OBJECT:
6297                         case MONO_TYPE_STRING:
6298                                 for (i = 0; i < alen; i++) {
6299                                         MonoObject *item = load_cattr_value (image, &t->data.klass->byval_arg, p, &p);
6300                                         mono_array_set (arr, gpointer, i, item);
6301                                 }
6302                                 break;
6303                         default:
6304                                 g_error("Type 0x%02x not handled in custom attr array decoding",t->data.type->type);
6305                 }
6306                 *end=p;
6307                 return arr;
6308         }
6309         default:
6310                 g_error ("Type 0x%02x not handled in custom attr value decoding", type);
6311         }
6312         return NULL;
6313 }
6314
6315 static gboolean
6316 type_is_reference (MonoType *type)
6317 {
6318         switch (type->type) {
6319         case MONO_TYPE_BOOLEAN:
6320         case MONO_TYPE_CHAR:
6321         case MONO_TYPE_U:
6322         case MONO_TYPE_I:
6323         case MONO_TYPE_U1:
6324         case MONO_TYPE_I1:
6325         case MONO_TYPE_U2:
6326         case MONO_TYPE_I2:
6327         case MONO_TYPE_U4:
6328         case MONO_TYPE_I4:
6329         case MONO_TYPE_U8:
6330         case MONO_TYPE_I8:
6331         case MONO_TYPE_R8:
6332         case MONO_TYPE_R4:
6333         case MONO_TYPE_VALUETYPE:
6334                 return FALSE;
6335         default:
6336                 return TRUE;
6337         }
6338 }
6339
6340 static void
6341 free_param_data (MonoMethodSignature *sig, void **params) {
6342         int i;
6343         for (i = 0; i < sig->param_count; ++i) {
6344                 if (!type_is_reference (sig->params [i]))
6345                         g_free (params [i]);
6346         }
6347 }
6348
6349 /*
6350  * Find the method index in the metadata methodDef table.
6351  * Later put these three helper methods in metadata and export them.
6352  */
6353 static guint32
6354 find_method_index (MonoMethod *method) {
6355         MonoClass *klass = method->klass;
6356         int i;
6357
6358         for (i = 0; i < klass->method.count; ++i) {
6359                 if (method == klass->methods [i])
6360                         return klass->method.first + 1 + i;
6361         }
6362         return 0;
6363 }
6364
6365 /*
6366  * Find the field index in the metadata FieldDef table.
6367  */
6368 static guint32
6369 find_field_index (MonoClass *klass, MonoClassField *field) {
6370         int i;
6371
6372         for (i = 0; i < klass->field.count; ++i) {
6373                 if (field == &klass->fields [i])
6374                         return klass->field.first + 1 + i;
6375         }
6376         return 0;
6377 }
6378
6379 /*
6380  * Find the property index in the metadata Property table.
6381  */
6382 static guint32
6383 find_property_index (MonoClass *klass, MonoProperty *property) {
6384         int i;
6385
6386         for (i = 0; i < klass->property.count; ++i) {
6387                 if (property == &klass->properties [i])
6388                         return klass->property.first + 1 + i;
6389         }
6390         return 0;
6391 }
6392
6393 /*
6394  * Find the event index in the metadata Event table.
6395  */
6396 static guint32
6397 find_event_index (MonoClass *klass, MonoEvent *event) {
6398         int i;
6399
6400         for (i = 0; i < klass->event.count; ++i) {
6401                 if (event == &klass->events [i])
6402                         return klass->event.first + 1 + i;
6403         }
6404         return 0;
6405 }
6406
6407 static MonoObject*
6408 create_custom_attr (MonoImage *image, MonoMethod *method, const char *data, guint32 len)
6409 {
6410         const char *p = data;
6411         const char *named;
6412         guint32 i, j, num_named;
6413         MonoObject *attr;
6414         void **params;
6415
6416         mono_class_init (method->klass);
6417
6418         if (len == 0) {
6419                 attr = mono_object_new (mono_domain_get (), method->klass);
6420                 mono_runtime_invoke (method, attr, NULL, NULL);
6421                 return attr;
6422         }
6423
6424         if (len < 2 || read16 (p) != 0x0001) /* Prolog */
6425                 return NULL;
6426
6427         /*g_print ("got attr %s\n", method->klass->name);*/
6428
6429         params = g_new (void*, method->signature->param_count);
6430
6431         /* skip prolog */
6432         p += 2;
6433         for (i = 0; i < method->signature->param_count; ++i) {
6434                 params [i] = load_cattr_value (image, method->signature->params [i], p, &p);
6435         }
6436
6437         named = p;
6438         attr = mono_object_new (mono_domain_get (), method->klass);
6439         mono_runtime_invoke (method, attr, params, NULL);
6440         free_param_data (method->signature, params);
6441         g_free (params);
6442         num_named = read16 (named);
6443         named += 2;
6444         for (j = 0; j < num_named; j++) {
6445                 gint name_len;
6446                 char *name, named_type, data_type;
6447                 named_type = *named++;
6448                 data_type = *named++; /* type of data */
6449                 if (data_type == 0x55) {
6450                         gint type_len;
6451                         char *type_name;
6452                         type_len = mono_metadata_decode_blob_size (named, &named);
6453                         type_name = g_malloc (type_len + 1);
6454                         memcpy (type_name, named, type_len);
6455                         type_name [type_len] = 0;
6456                         named += type_len;
6457                         /* FIXME: lookup the type and check type consistency */
6458                 } else if (data_type == MONO_TYPE_SZARRAY && (named_type == 0x54 || named_type == 0x53)) {
6459                         /* this seems to be the type of the element of the array */
6460                         /* g_print ("skipping 0x%02x after prop\n", *named); */
6461                         named++;
6462                 }
6463                 name_len = mono_metadata_decode_blob_size (named, &named);
6464                 name = g_malloc (name_len + 1);
6465                 memcpy (name, named, name_len);
6466                 name [name_len] = 0;
6467                 named += name_len;
6468                 if (named_type == 0x53) {
6469                         MonoClassField *field = mono_class_get_field_from_name (mono_object_class (attr), name);
6470                         void *val = load_cattr_value (image, field->type, named, &named);
6471                         mono_field_set_value (attr, field, val);
6472                         if (!type_is_reference (field->type))
6473                                 g_free (val);
6474                 } else if (named_type == 0x54) {
6475                         MonoProperty *prop;
6476                         void *pparams [1];
6477                         MonoType *prop_type;
6478
6479                         prop = mono_class_get_property_from_name (mono_object_class (attr), name);
6480                         /* can we have more that 1 arg in a custom attr named property? */
6481                         prop_type = prop->get? prop->get->signature->ret: prop->set->signature->params [prop->set->signature->param_count - 1];
6482                         pparams [0] = load_cattr_value (image, prop_type, named, &named);
6483                         mono_property_set_value (prop, attr, pparams, NULL);
6484                         if (!type_is_reference (prop_type))
6485                                 g_free (pparams [0]);
6486                 }
6487                 g_free (name);
6488         }
6489
6490         return attr;
6491 }
6492
6493 MonoArray*
6494 mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo)
6495 {
6496         MonoArray *result;
6497         MonoClass *klass;
6498         MonoObject *attr;
6499         int i;
6500
6501         klass = mono_class_from_name (mono_defaults.corlib, "System", "Attribute");
6502         result = mono_array_new (mono_domain_get (), klass, cinfo->num_attrs);
6503         for (i = 0; i < cinfo->num_attrs; ++i) {
6504                 attr = create_custom_attr (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size);
6505                 mono_array_set (result, gpointer, i, attr);
6506         }
6507         return result;
6508 }
6509
6510 MonoCustomAttrInfo*
6511 mono_custom_attrs_from_index (MonoImage *image, guint32 idx)
6512 {
6513         guint32 mtoken, i, len;
6514         guint32 cols [MONO_CUSTOM_ATTR_SIZE];
6515         MonoTableInfo *ca;
6516         MonoCustomAttrInfo *ainfo;
6517         GList *tmp, *list = NULL;
6518         const char *data;
6519
6520         ca = &image->tables [MONO_TABLE_CUSTOMATTRIBUTE];
6521
6522         i = mono_metadata_custom_attrs_from_index (image, idx);
6523         if (!i)
6524                 return NULL;
6525         i --;
6526         while (i < ca->rows) {
6527                 if (mono_metadata_decode_row_col (ca, i, MONO_CUSTOM_ATTR_PARENT) != idx)
6528                         break;
6529                 list = g_list_prepend (list, GUINT_TO_POINTER (i));
6530                 ++i;
6531         }
6532         len = g_list_length (list);
6533         if (!len)
6534                 return NULL;
6535         ainfo = g_malloc0 (sizeof (MonoCustomAttrInfo) + sizeof (MonoCustomAttrEntry) * (len - MONO_ZERO_LEN_ARRAY));
6536         ainfo->num_attrs = len;
6537         ainfo->image = image;
6538         for (i = 0, tmp = list; i < len; ++i, tmp = tmp->next) {
6539                 mono_metadata_decode_row (ca, GPOINTER_TO_UINT (tmp->data), cols, MONO_CUSTOM_ATTR_SIZE);
6540                 mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> MONO_CUSTOM_ATTR_TYPE_BITS;
6541                 switch (cols [MONO_CUSTOM_ATTR_TYPE] & MONO_CUSTOM_ATTR_TYPE_MASK) {
6542                 case MONO_CUSTOM_ATTR_TYPE_METHODDEF:
6543                         mtoken |= MONO_TOKEN_METHOD_DEF;
6544                         break;
6545                 case MONO_CUSTOM_ATTR_TYPE_MEMBERREF:
6546                         mtoken |= MONO_TOKEN_MEMBER_REF;
6547                         break;
6548                 default:
6549                         g_error ("Unknown table for custom attr type %08x", cols [MONO_CUSTOM_ATTR_TYPE]);
6550                         break;
6551                 }
6552                 ainfo->attrs [i].ctor = mono_get_method (image, mtoken, NULL);
6553                 if (!ainfo->attrs [i].ctor)
6554                         g_error ("Can't find custom attr constructor image: %s mtoken: 0x%08x", image->name, mtoken);
6555                 data = mono_metadata_blob_heap (image, cols [MONO_CUSTOM_ATTR_VALUE]);
6556                 ainfo->attrs [i].data_size = mono_metadata_decode_value (data, &data);
6557                 ainfo->attrs [i].data = data;
6558         }
6559         g_list_free (list);
6560
6561         return ainfo;
6562 }
6563
6564 MonoCustomAttrInfo*
6565 mono_custom_attrs_from_method (MonoMethod *method)
6566 {
6567         MonoCustomAttrInfo *cinfo;
6568         guint32 idx;
6569
6570         if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, method)))
6571                 return cinfo;
6572         idx = find_method_index (method);
6573         idx <<= MONO_CUSTOM_ATTR_BITS;
6574         idx |= MONO_CUSTOM_ATTR_METHODDEF;
6575         return mono_custom_attrs_from_index (method->klass->image, idx);
6576 }
6577
6578 MonoCustomAttrInfo*
6579 mono_custom_attrs_from_class (MonoClass *klass)
6580 {
6581         MonoCustomAttrInfo *cinfo;
6582         guint32 idx;
6583
6584         if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, klass)))
6585                 return cinfo;
6586         idx = mono_metadata_token_index (klass->type_token);
6587         idx <<= MONO_CUSTOM_ATTR_BITS;
6588         idx |= MONO_CUSTOM_ATTR_TYPEDEF;
6589         return mono_custom_attrs_from_index (klass->image, idx);
6590 }
6591
6592 MonoCustomAttrInfo*
6593 mono_custom_attrs_from_assembly (MonoAssembly *assembly)
6594 {
6595         MonoCustomAttrInfo *cinfo;
6596         guint32 idx;
6597
6598         if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, assembly)))
6599                 return cinfo;
6600         idx = 1; /* there is only one assembly */
6601         idx <<= MONO_CUSTOM_ATTR_BITS;
6602         idx |= MONO_CUSTOM_ATTR_ASSEMBLY;
6603         return mono_custom_attrs_from_index (assembly->image, idx);
6604 }
6605
6606 static MonoCustomAttrInfo*
6607 mono_custom_attrs_from_module (MonoImage *image)
6608 {
6609         MonoCustomAttrInfo *cinfo;
6610         guint32 idx;
6611
6612         if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, image)))
6613                 return cinfo;
6614         idx = 1; /* there is only one module */
6615         idx <<= MONO_CUSTOM_ATTR_BITS;
6616         idx |= MONO_CUSTOM_ATTR_MODULE;
6617         return mono_custom_attrs_from_index (image, idx);
6618 }
6619
6620 MonoCustomAttrInfo*
6621 mono_custom_attrs_from_property (MonoClass *klass, MonoProperty *property)
6622 {
6623         MonoCustomAttrInfo *cinfo;
6624         guint32 idx;
6625
6626         if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, property)))
6627                 return cinfo;
6628         idx = find_property_index (klass, property);
6629         idx <<= MONO_CUSTOM_ATTR_BITS;
6630         idx |= MONO_CUSTOM_ATTR_PROPERTY;
6631         return mono_custom_attrs_from_index (klass->image, idx);
6632 }
6633
6634 MonoCustomAttrInfo*
6635 mono_custom_attrs_from_event (MonoClass *klass, MonoEvent *event)
6636 {
6637         MonoCustomAttrInfo *cinfo;
6638         guint32 idx;
6639
6640         if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, event)))
6641                 return cinfo;
6642         idx = find_event_index (klass, event);
6643         idx <<= MONO_CUSTOM_ATTR_BITS;
6644         idx |= MONO_CUSTOM_ATTR_EVENT;
6645         return mono_custom_attrs_from_index (klass->image, idx);
6646 }
6647
6648 MonoCustomAttrInfo*
6649 mono_custom_attrs_from_field (MonoClass *klass, MonoClassField *field)
6650 {
6651         MonoCustomAttrInfo *cinfo;
6652         guint32 idx;
6653
6654         if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, field)))
6655                 return cinfo;
6656         idx = find_field_index (klass, field);
6657         idx <<= MONO_CUSTOM_ATTR_BITS;
6658         idx |= MONO_CUSTOM_ATTR_FIELDDEF;
6659         return mono_custom_attrs_from_index (klass->image, idx);
6660 }
6661
6662 MonoCustomAttrInfo*
6663 mono_custom_attrs_from_param (MonoMethod *method, guint32 param)
6664 {
6665         MonoTableInfo *ca;
6666         guint32 i, idx, method_index;
6667         guint32 param_list, param_last, param_pos, found;
6668         MonoImage *image;
6669         MonoReflectionMethodAux *aux;
6670
6671         if (method->klass->image->dynamic) {
6672                 aux = mono_g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
6673                 if (!aux || !aux->param_cattr)
6674                         return NULL;
6675                 return aux->param_cattr [param];
6676         }
6677
6678         image = method->klass->image;
6679         method_index = find_method_index (method);
6680         ca = &image->tables [MONO_TABLE_METHOD];
6681
6682         if (method->klass->generic_inst || method->klass->generic_container ||
6683             method->signature->generic_param_count) {
6684                 /* FIXME FIXME FIXME */
6685                 return NULL;
6686         }
6687
6688         param_list = mono_metadata_decode_row_col (ca, method_index - 1, MONO_METHOD_PARAMLIST);
6689         if (method_index == ca->rows) {
6690                 ca = &image->tables [MONO_TABLE_PARAM];
6691                 param_last = ca->rows + 1;
6692         } else {
6693                 param_last = mono_metadata_decode_row_col (ca, method_index, MONO_METHOD_PARAMLIST);
6694                 ca = &image->tables [MONO_TABLE_PARAM];
6695         }
6696         found = FALSE;
6697         for (i = param_list; i < param_last; ++i) {
6698                 param_pos = mono_metadata_decode_row_col (ca, i - 1, MONO_PARAM_SEQUENCE);
6699                 if (param_pos == param) {
6700                         found = TRUE;
6701                         break;
6702                 }
6703         }
6704         if (!found)
6705                 return NULL;
6706         idx = i;
6707         idx <<= MONO_CUSTOM_ATTR_BITS;
6708         idx |= MONO_CUSTOM_ATTR_PARAMDEF;
6709         return mono_custom_attrs_from_index (image, idx);
6710 }
6711
6712 /*
6713  * mono_reflection_get_custom_attrs:
6714  * @obj: a reflection object handle
6715  *
6716  * Return an array with all the custom attributes defined of the
6717  * reflection handle @obj. The objects are fully build.
6718  */
6719 MonoArray*
6720 mono_reflection_get_custom_attrs (MonoObject *obj)
6721 {
6722         MonoClass *klass;
6723         MonoArray *result;
6724         MonoCustomAttrInfo *cinfo = NULL;
6725
6726         MONO_ARCH_SAVE_REGS;
6727
6728         klass = obj->vtable->klass;
6729         if (klass == mono_defaults.monotype_class) {
6730                 MonoReflectionType *rtype = (MonoReflectionType*)obj;
6731                 klass = mono_class_from_mono_type (rtype->type);
6732                 cinfo = mono_custom_attrs_from_class (klass);
6733         } else if (strcmp ("Assembly", klass->name) == 0) {
6734                 MonoReflectionAssembly *rassembly = (MonoReflectionAssembly*)obj;
6735                 cinfo = mono_custom_attrs_from_assembly (rassembly->assembly);
6736         } else if (strcmp ("Module", klass->name) == 0) {
6737                 MonoReflectionModule *module = (MonoReflectionModule*)obj;
6738                 cinfo = mono_custom_attrs_from_module (module->image);
6739         } else if (strcmp ("MonoProperty", klass->name) == 0) {
6740                 MonoReflectionProperty *rprop = (MonoReflectionProperty*)obj;
6741                 cinfo = mono_custom_attrs_from_property (rprop->property->parent, rprop->property);
6742         } else if (strcmp ("MonoEvent", klass->name) == 0) {
6743                 MonoReflectionEvent *revent = (MonoReflectionEvent*)obj;
6744                 cinfo = mono_custom_attrs_from_event (revent->event->parent, revent->event);
6745         } else if (strcmp ("MonoField", klass->name) == 0) {
6746                 MonoReflectionField *rfield = (MonoReflectionField*)obj;
6747                 cinfo = mono_custom_attrs_from_field (rfield->field->parent, rfield->field);
6748         } else if ((strcmp ("MonoMethod", klass->name) == 0) || (strcmp ("MonoCMethod", klass->name) == 0)) {
6749                 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)obj;
6750                 cinfo = mono_custom_attrs_from_method (rmethod->method);
6751         } else if (strcmp ("ParameterInfo", klass->name) == 0) {
6752                 MonoReflectionParameter *param = (MonoReflectionParameter*)obj;
6753                 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)param->MemberImpl;
6754                 cinfo = mono_custom_attrs_from_param (rmethod->method, param->PositionImpl + 1);
6755         } else if (strcmp ("AssemblyBuilder", klass->name) == 0) {
6756                 MonoReflectionAssemblyBuilder *assemblyb = (MonoReflectionAssemblyBuilder*)obj;
6757                 cinfo = mono_custom_attrs_from_builders (assemblyb->assembly.assembly->image, assemblyb->cattrs);
6758         } else if (strcmp ("TypeBuilder", klass->name) == 0) {
6759                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)obj;
6760                 cinfo = mono_custom_attrs_from_builders (&tb->module->dynamic_image->image, tb->cattrs);
6761         } else { /* handle other types here... */
6762                 g_error ("get custom attrs not yet supported for %s", klass->name);
6763         }
6764
6765         if (cinfo) {
6766                 result = mono_custom_attrs_construct (cinfo);
6767                 if (!cinfo->cached)
6768                         mono_custom_attrs_free (cinfo);
6769         } else {
6770                 klass = mono_class_from_name (mono_defaults.corlib, "System", "Attribute");
6771                 result = mono_array_new (mono_domain_get (), klass, 0);
6772         }
6773
6774         return result;
6775 }
6776
6777 static MonoMethodSignature*
6778 parameters_to_signature (MonoArray *parameters) {
6779         MonoMethodSignature *sig;
6780         int count, i;
6781
6782         count = parameters? mono_array_length (parameters): 0;
6783
6784         sig = g_malloc0 (sizeof (MonoMethodSignature) + sizeof (MonoType*) * count);
6785         sig->param_count = count;
6786         sig->sentinelpos = -1; /* FIXME */
6787         for (i = 0; i < count; ++i) {
6788                 MonoReflectionType *pt = mono_array_get (parameters, MonoReflectionType*, i);
6789                 sig->params [i] = pt->type;
6790         }
6791         return sig;
6792 }
6793
6794 static MonoMethodSignature*
6795 ctor_builder_to_signature (MonoReflectionCtorBuilder *ctor) {
6796         MonoMethodSignature *sig;
6797
6798         sig = parameters_to_signature (ctor->parameters);
6799         sig->hasthis = ctor->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
6800         sig->ret = &mono_defaults.void_class->byval_arg;
6801         return sig;
6802 }
6803
6804 static MonoMethodSignature*
6805 method_builder_to_signature (MonoReflectionMethodBuilder *method) {
6806         MonoMethodSignature *sig;
6807
6808         sig = parameters_to_signature (method->parameters);
6809         sig->hasthis = method->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
6810         sig->ret = method->rtype? method->rtype->type: &mono_defaults.void_class->byval_arg;
6811         sig->generic_param_count = method->generic_params ? mono_array_length (method->generic_params) : 0;
6812         return sig;
6813 }
6814
6815 static MonoMethodSignature*
6816 dynamic_method_to_signature (MonoReflectionDynamicMethod *method) {
6817         MonoMethodSignature *sig;
6818
6819         sig = parameters_to_signature (method->parameters);
6820         sig->hasthis = method->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
6821         sig->ret = method->rtype? method->rtype->type: &mono_defaults.void_class->byval_arg;
6822         sig->generic_param_count = 0;
6823         return sig;
6824 }
6825
6826 static void
6827 get_prop_name_and_type (MonoObject *prop, char **name, MonoType **type)
6828 {
6829         MonoClass *klass = mono_object_class (prop);
6830         if (strcmp (klass->name, "PropertyBuilder") == 0) {
6831                 MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *)prop;
6832                 *name = mono_string_to_utf8 (pb->name);
6833                 *type = pb->type->type;
6834         } else {
6835                 MonoReflectionProperty *p = (MonoReflectionProperty *)prop;
6836                 *name = g_strdup (p->property->name);
6837                 if (p->property->get)
6838                         *type = p->property->get->signature->ret;
6839                 else
6840                         *type = p->property->set->signature->params [p->property->set->signature->param_count - 1];
6841         }
6842 }
6843
6844 static void
6845 get_field_name_and_type (MonoObject *field, char **name, MonoType **type)
6846 {
6847         MonoClass *klass = mono_object_class (field);
6848         if (strcmp (klass->name, "FieldBuilder") == 0) {
6849                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)field;
6850                 *name = mono_string_to_utf8 (fb->name);
6851                 *type = fb->type->type;
6852         } else {
6853                 MonoReflectionField *f = (MonoReflectionField *)field;
6854                 *name = g_strdup (f->field->name);
6855                 *type = f->field->type;
6856         }
6857 }
6858
6859 /*
6860  * Encode a value in a custom attribute stream of bytes.
6861  * The value to encode is either supplied as an object in argument val
6862  * (valuetypes are boxed), or as a pointer to the data in the
6863  * argument argval.
6864  * @type represents the type of the value
6865  * @buffer is the start of the buffer
6866  * @p the current position in the buffer
6867  * @buflen contains the size of the buffer and is used to return the new buffer size
6868  * if this needs to be realloced.
6869  * @retbuffer and @retp return the start and the position of the buffer
6870  */
6871 static void
6872 encode_cattr_value (MonoAssembly *assembly, char *buffer, char *p, char **retbuffer, char **retp, guint32 *buflen, MonoType *type, MonoObject *arg, char *argval)
6873 {
6874         MonoTypeEnum simple_type;
6875
6876         if ((p-buffer) + 10 >= *buflen) {
6877                 char *newbuf;
6878                 *buflen *= 2;
6879                 newbuf = g_realloc (buffer, *buflen);
6880                 p = newbuf + (p-buffer);
6881                 buffer = newbuf;
6882         }
6883         if (!argval)
6884                 argval = ((char*)arg + sizeof (MonoObject));
6885         simple_type = type->type;
6886 handle_enum:
6887         switch (simple_type) {
6888         case MONO_TYPE_BOOLEAN:
6889         case MONO_TYPE_U1:
6890         case MONO_TYPE_I1:
6891                 *p++ = *argval;
6892                 break;
6893         case MONO_TYPE_CHAR:
6894         case MONO_TYPE_U2:
6895         case MONO_TYPE_I2:
6896                 swap_with_size (p, argval, 2, 1);
6897                 p += 2;
6898                 break;
6899         case MONO_TYPE_U4:
6900         case MONO_TYPE_I4:
6901         case MONO_TYPE_R4:
6902                 swap_with_size (p, argval, 4, 1);
6903                 p += 4;
6904                 break;
6905         case MONO_TYPE_U8:
6906         case MONO_TYPE_I8:
6907         case MONO_TYPE_R8:
6908                 swap_with_size (p, argval, 8, 1);
6909                 p += 8;
6910                 break;
6911         case MONO_TYPE_VALUETYPE:
6912                 if (type->data.klass->enumtype) {
6913                         simple_type = type->data.klass->enum_basetype->type;
6914                         goto handle_enum;
6915                 } else {
6916                         g_warning ("generic valutype %s not handled in custom attr value decoding", type->data.klass->name);
6917                 }
6918                 break;
6919         case MONO_TYPE_STRING: {
6920                 char *str;
6921                 guint32 slen;
6922                 if (!arg) {
6923                         *p++ = 0xFF;
6924                         break;
6925                 }
6926                 str = mono_string_to_utf8 ((MonoString*)arg);
6927                 slen = strlen (str);
6928                 if ((p-buffer) + 10 + slen >= *buflen) {
6929                         char *newbuf;
6930                         *buflen *= 2;
6931                         *buflen += slen;
6932                         newbuf = g_realloc (buffer, *buflen);
6933                         p = newbuf + (p-buffer);
6934                         buffer = newbuf;
6935                 }
6936                 mono_metadata_encode_value (slen, p, &p);
6937                 memcpy (p, str, slen);
6938                 p += slen;
6939                 g_free (str);
6940                 break;
6941         }
6942         case MONO_TYPE_CLASS: {
6943                 char *str;
6944                 guint32 slen;
6945                 MonoClass *k;
6946                 if (!arg) {
6947                         *p++ = 0xFF;
6948                         break;
6949                 }
6950                 k = mono_object_class (arg);
6951                 if (!mono_object_isinst (arg, mono_defaults.monotype_class) &&
6952                                 (strcmp (k->name, "TypeBuilder") || strcmp (k->name_space, "System.Reflection.Emit")))
6953                         g_error ("only types allowed, not %s.%s", k->name_space, k->name);
6954 handle_type:
6955                 str = type_get_qualified_name (((MonoReflectionType*)arg)->type, NULL);
6956                 slen = strlen (str);
6957                 if ((p-buffer) + 10 + slen >= *buflen) {
6958                         char *newbuf;
6959                         *buflen *= 2;
6960                         *buflen += slen;
6961                         newbuf = g_realloc (buffer, *buflen);
6962                         p = newbuf + (p-buffer);
6963                         buffer = newbuf;
6964                 }
6965                 mono_metadata_encode_value (slen, p, &p);
6966                 memcpy (p, str, slen);
6967                 p += slen;
6968                 g_free (str);
6969                 break;
6970         }
6971         case MONO_TYPE_SZARRAY: {
6972                 int len, i;
6973                 MonoClass *eclass, *arg_eclass;
6974
6975                 if (!arg) {
6976                         *p++ = 0xff; *p++ = 0xff; *p++ = 0xff; *p++ = 0xff;
6977                         break;
6978                 }
6979                 len = mono_array_length ((MonoArray*)arg);
6980                 *p++ = len & 0xff;
6981                 *p++ = (len >> 8) & 0xff;
6982                 *p++ = (len >> 16) & 0xff;
6983                 *p++ = (len >> 24) & 0xff;
6984                 *retp = p;
6985                 *retbuffer = buffer;
6986                 eclass = type->data.klass;
6987                 arg_eclass = mono_object_class (arg)->element_class;
6988                 if (eclass->valuetype && arg_eclass->valuetype) {
6989                         char *elptr = mono_array_addr ((MonoArray*)arg, char, 0);
6990                         int elsize = mono_class_array_element_size (eclass);
6991                         for (i = 0; i < len; ++i) {
6992                                 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &eclass->byval_arg, NULL, elptr);
6993                                 elptr += elsize;
6994                         }
6995                 } else {
6996                         for (i = 0; i < len; ++i) {
6997                                 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &eclass->byval_arg, mono_array_get ((MonoArray*)arg, MonoObject*, i), NULL);
6998                         }
6999                 }
7000                 break;
7001         }
7002         /* it may be a boxed value or a Type */
7003         case MONO_TYPE_OBJECT: {
7004                 MonoClass *klass = mono_object_class (arg);
7005                 char *str;
7006                 guint32 slen;
7007
7008                 if (mono_object_isinst (arg, mono_defaults.monotype_class)) {
7009                         *p++ = 0x50;
7010                         goto handle_type;
7011                 } else if (klass->enumtype) {
7012                         *p++ = 0x55;
7013                 } else if (klass == mono_defaults.string_class) {
7014                         simple_type = MONO_TYPE_STRING;
7015                         *p++ = 0x0E;
7016                         goto handle_enum;
7017                 } else if (klass->byval_arg.type >= MONO_TYPE_BOOLEAN && klass->byval_arg.type <= MONO_TYPE_R8) {
7018                         *p++ = simple_type = klass->byval_arg.type;
7019                         goto handle_enum;
7020                 } else {
7021                         g_error ("unhandled type in custom attr");
7022                 }
7023                 str = type_get_qualified_name (mono_class_get_type(klass), NULL);
7024                 slen = strlen (str);
7025                 if ((p-buffer) + 10 + slen >= *buflen) {
7026                         char *newbuf;
7027                         *buflen *= 2;
7028                         *buflen += slen;
7029                         newbuf = g_realloc (buffer, *buflen);
7030                         p = newbuf + (p-buffer);
7031                         buffer = newbuf;
7032                 }
7033                 mono_metadata_encode_value (slen, p, &p);
7034                 memcpy (p, str, slen);
7035                 p += slen;
7036                 g_free (str);
7037                 simple_type = klass->enum_basetype->type;
7038                 goto handle_enum;
7039         }
7040         default:
7041                 g_error ("type 0x%02x not yet supported in custom attr encoder", simple_type);
7042         }
7043         *retp = p;
7044         *retbuffer = buffer;
7045 }
7046
7047 /*
7048  * mono_reflection_get_custom_attrs_blob:
7049  * @ctor: custom attribute constructor
7050  * @ctorArgs: arguments o the constructor
7051  * @properties:
7052  * @propValues:
7053  * @fields:
7054  * @fieldValues:
7055  *
7056  * Creates the blob of data that needs to be saved in the metadata and that represents
7057  * the custom attributed described by @ctor, @ctorArgs etc.
7058  * Returns: a Byte array representing the blob of data.
7059  */
7060 MonoArray*
7061 mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
7062 {
7063         MonoArray *result;
7064         MonoMethodSignature *sig;
7065         MonoObject *arg;
7066         char *buffer, *p;
7067         guint32 buflen, i;
7068
7069         MONO_ARCH_SAVE_REGS;
7070
7071         if (strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
7072                 sig = ctor_builder_to_signature ((MonoReflectionCtorBuilder*)ctor);
7073         } else {
7074                 sig = ((MonoReflectionMethod*)ctor)->method->signature;
7075         }
7076         g_assert (mono_array_length (ctorArgs) == sig->param_count);
7077         buflen = 256;
7078         p = buffer = g_malloc (buflen);
7079         /* write the prolog */
7080         *p++ = 1;
7081         *p++ = 0;
7082         for (i = 0; i < sig->param_count; ++i) {
7083                 arg = mono_array_get (ctorArgs, MonoObject*, i);
7084                 encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, &buflen, sig->params [i], arg, NULL);
7085         }
7086         i = 0;
7087         if (properties)
7088                 i += mono_array_length (properties);
7089         if (fields)
7090                 i += mono_array_length (fields);
7091         *p++ = i & 0xff;
7092         *p++ = (i >> 8) & 0xff;
7093         if (properties) {
7094                 MonoObject *prop;
7095                 for (i = 0; i < mono_array_length (properties); ++i) {
7096                         MonoType *ptype;
7097                         char *pname;
7098                         int len;
7099
7100                         prop = mono_array_get (properties, gpointer, i);
7101                         get_prop_name_and_type (prop, &pname, &ptype);
7102                         *p++ = 0x54; /* PROPERTY signature */
7103
7104                         /* Preallocate a large enough buffer */
7105                         if (ptype->type == MONO_TYPE_VALUETYPE && ptype->data.klass->enumtype) {
7106                                 char *str = type_get_qualified_name (ptype, NULL);
7107                                 len = strlen (str);
7108                                 g_free (str);
7109                         }
7110                         else
7111                                 len = 0;
7112                         len += strlen (pname);
7113
7114                         if ((p-buffer) + 20 + len >= buflen) {
7115                                 char *newbuf;
7116                                 buflen *= 2;
7117                                 buflen += len;
7118                                 newbuf = g_realloc (buffer, buflen);
7119                                 p = newbuf + (p-buffer);
7120                                 buffer = newbuf;
7121                         }
7122
7123                         if (ptype->type == MONO_TYPE_VALUETYPE && ptype->data.klass->enumtype) {
7124                                 char *str = type_get_qualified_name (ptype, NULL);
7125                                 int slen = strlen (str);
7126
7127                                 *p++ = 0x55;
7128                                 /*
7129                                  * This seems to be optional...
7130                                  * *p++ = 0x80;
7131                                  */
7132                                 mono_metadata_encode_value (slen, p, &p);
7133                                 memcpy (p, str, slen);
7134                                 p += slen;
7135                                 g_free (str);
7136                         } else {
7137                                 mono_metadata_encode_value (ptype->type, p, &p);
7138                                 if (ptype->type == MONO_TYPE_SZARRAY)
7139                                         mono_metadata_encode_value (ptype->data.klass->this_arg.type, p, &p);
7140                         }
7141                         len = strlen (pname);
7142                         mono_metadata_encode_value (len, p, &p);
7143                         memcpy (p, pname, len);
7144                         p += len;
7145                         encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, &buflen, ptype, (MonoObject*)mono_array_get (propValues, gpointer, i), NULL);
7146                         g_free (pname);
7147                 }
7148         }
7149
7150         if (fields) {
7151                 MonoObject *field;
7152                 for (i = 0; i < mono_array_length (fields); ++i) {
7153                         MonoType *ftype;
7154                         char *fname;
7155                         int len;
7156
7157                         field = mono_array_get (fields, gpointer, i);
7158                         get_field_name_and_type (field, &fname, &ftype);
7159                         *p++ = 0x53; /* FIELD signature */
7160                         if (ftype->type == MONO_TYPE_VALUETYPE && ftype->data.klass->enumtype) {
7161                                 char *str = type_get_qualified_name (ftype, NULL);
7162                                 int slen = strlen (str);
7163                                 if ((p-buffer) + 10 + slen >= buflen) {
7164                                         char *newbuf;
7165                                         buflen *= 2;
7166                                         buflen += slen;
7167                                         newbuf = g_realloc (buffer, buflen);
7168                                         p = newbuf + (p-buffer);
7169                                         buffer = newbuf;
7170                                 }
7171                                 *p++ = 0x55;
7172                                 /*
7173                                  * This seems to be optional...
7174                                  * *p++ = 0x80;
7175                                  */
7176                                 mono_metadata_encode_value (slen, p, &p);
7177                                 memcpy (p, str, slen);
7178                                 p += slen;
7179                                 g_free (str);
7180                         } else {
7181                                 mono_metadata_encode_value (ftype->type, p, &p);
7182                                 if (ftype->type == MONO_TYPE_SZARRAY)
7183                                         mono_metadata_encode_value (ftype->data.klass->this_arg.type, p, &p);
7184                         }
7185                         len = strlen (fname);
7186                         mono_metadata_encode_value (len, p, &p);
7187                         memcpy (p, fname, len);
7188                         p += len;
7189                         encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, &buflen, ftype, (MonoObject*)mono_array_get (fieldValues, gpointer, i), NULL);
7190                         g_free (fname);
7191                 }
7192         }
7193
7194         g_assert (p - buffer <= buflen);
7195         buflen = p - buffer;
7196         result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
7197         p = mono_array_addr (result, char, 0);
7198         memcpy (p, buffer, buflen);
7199         g_free (buffer);
7200         if (strcmp (ctor->vtable->klass->name, "MonoCMethod"))
7201                 g_free (sig);
7202         return result;
7203 }
7204
7205 /*
7206  * mono_reflection_setup_internal_class:
7207  * @tb: a TypeBuilder object
7208  *
7209  * Creates a MonoClass that represents the TypeBuilder.
7210  * This is a trick that lets us simplify a lot of reflection code
7211  * (and will allow us to support Build and Run assemblies easier).
7212  */
7213 void
7214 mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb)
7215 {
7216         MonoClass *klass, *parent;
7217
7218         MONO_ARCH_SAVE_REGS;
7219
7220         if (tb->parent) {
7221                 /* check so we can compile corlib correctly */
7222                 if (strcmp (mono_object_class (tb->parent)->name, "TypeBuilder") == 0) {
7223                         /* mono_class_setup_mono_type () guaranteess type->data.klass is valid */
7224                         parent = tb->parent->type->data.klass;
7225                 } else {
7226                         parent = my_mono_class_from_mono_type (tb->parent->type);
7227                 }
7228         } else {
7229                 parent = NULL;
7230         }
7231
7232         /* the type has already being created: it means we just have to change the parent */
7233         if (tb->type.type) {
7234                 klass = mono_class_from_mono_type (tb->type.type);
7235                 klass->parent = NULL;
7236                 /* fool mono_class_setup_parent */
7237                 g_free (klass->supertypes);
7238                 klass->supertypes = NULL;
7239                 mono_class_setup_parent (klass, parent);
7240                 mono_class_setup_mono_type (klass);
7241                 return;
7242         }
7243
7244         klass = g_new0 (MonoClass, 1);
7245
7246         klass->image = &tb->module->dynamic_image->image;
7247
7248         klass->inited = 1; /* we lie to the runtime */
7249         klass->name = mono_string_to_utf8 (tb->name);
7250         klass->name_space = mono_string_to_utf8 (tb->nspace);
7251         klass->type_token = MONO_TOKEN_TYPE_DEF | tb->table_idx;
7252         klass->flags = tb->attrs;
7253
7254         klass->element_class = klass;
7255         klass->reflection_info = tb; /* need to pin. */
7256
7257         /* Put into cache so mono_class_get () will find it */
7258         mono_image_add_to_name_cache (klass->image, klass->name_space, klass->name, tb->table_idx);
7259
7260         mono_g_hash_table_insert (tb->module->dynamic_image->tokens,
7261                 GUINT_TO_POINTER (MONO_TOKEN_TYPE_DEF | tb->table_idx), tb);
7262
7263         if (parent != NULL) {
7264                 mono_class_setup_parent (klass, parent);
7265         } else if (strcmp (klass->name, "Object") == 0 && strcmp (klass->name_space, "System") == 0) {
7266                 const char *old_n = klass->name;
7267                 /* trick to get relative numbering right when compiling corlib */
7268                 klass->name = "BuildingObject";
7269                 mono_class_setup_parent (klass, mono_defaults.object_class);
7270                 klass->name = old_n;
7271         }
7272
7273         if ((!strcmp (klass->name, "ValueType") && !strcmp (klass->name_space, "System")) ||
7274                         (!strcmp (klass->name, "Object") && !strcmp (klass->name_space, "System")) ||
7275                         (!strcmp (klass->name, "Enum") && !strcmp (klass->name_space, "System"))) {
7276                 klass->instance_size = sizeof (MonoObject);
7277                 klass->size_inited = 1;
7278                 mono_class_setup_vtable (klass, NULL, 0);
7279         }
7280
7281         mono_class_setup_mono_type (klass);
7282
7283         mono_class_setup_supertypes (klass);
7284
7285         /*
7286          * FIXME: handle interfaces.
7287          */
7288
7289         tb->type.type = &klass->byval_arg;
7290
7291         if (tb->nesting_type) {
7292                 g_assert (tb->nesting_type->type);
7293                 klass->nested_in = mono_class_from_mono_type (tb->nesting_type->type);
7294         }
7295
7296         /*g_print ("setup %s as %s (%p)\n", klass->name, ((MonoObject*)tb)->vtable->klass->name, tb);*/
7297 }
7298
7299 /*
7300  * mono_reflection_setup_generic_class:
7301  * @tb: a TypeBuilder object
7302  *
7303  * Setup the generic class before adding the first generic parameter.
7304  */
7305 void
7306 mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb)
7307 {
7308         MonoClass *klass;
7309
7310         MONO_ARCH_SAVE_REGS;
7311
7312         klass = my_mono_class_from_mono_type (tb->type.type);
7313         if (tb->generic_container)
7314                 return;
7315
7316         tb->generic_container = g_new0 (MonoGenericContainer, 1);
7317         tb->generic_container->klass = klass;
7318 }
7319
7320 /*
7321  * mono_reflection_create_generic_class:
7322  * @tb: a TypeBuilder object
7323  *
7324  * Creates the generic class after all generic parameters have been added.
7325  */
7326 void
7327 mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb)
7328 {
7329         MonoClass *klass;
7330         int count, i;
7331
7332         MONO_ARCH_SAVE_REGS;
7333
7334         klass = my_mono_class_from_mono_type (tb->type.type);
7335
7336         count = tb->generic_params ? mono_array_length (tb->generic_params) : 0;
7337
7338         if (klass->generic_container || (count == 0))
7339                 return;
7340
7341         g_assert (tb->generic_container && (tb->generic_container->klass == klass));
7342
7343         klass->generic_container = tb->generic_container;
7344
7345         klass->generic_container->type_argc = count;
7346         klass->generic_container->type_params = g_new0 (MonoGenericParam, count);
7347
7348         for (i = 0; i < count; i++) {
7349                 MonoReflectionGenericParam *gparam = mono_array_get (tb->generic_params, gpointer, i);
7350                 klass->generic_container->type_params [i] = *gparam->type.type->data.generic_param;
7351                 g_assert (klass->generic_container->type_params [i].owner);
7352         }
7353 }
7354
7355 /*
7356  * mono_reflection_create_internal_class:
7357  * @tb: a TypeBuilder object
7358  *
7359  * Actually create the MonoClass that is associated with the TypeBuilder.
7360  */
7361 void
7362 mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb)
7363 {
7364         MonoClass *klass;
7365
7366         MONO_ARCH_SAVE_REGS;
7367
7368         klass = my_mono_class_from_mono_type (tb->type.type);
7369
7370         if (klass->enumtype && klass->enum_basetype == NULL) {
7371                 MonoReflectionFieldBuilder *fb;
7372                 MonoClass *ec;
7373
7374                 g_assert (tb->fields != NULL);
7375                 g_assert (mono_array_length (tb->fields) >= 1);
7376
7377                 fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, 0);
7378
7379                 klass->enum_basetype = fb->type->type;
7380                 klass->element_class = my_mono_class_from_mono_type (klass->enum_basetype);
7381                 if (!klass->element_class)
7382                         klass->element_class = mono_class_from_mono_type (klass->enum_basetype);
7383
7384                 /*
7385                  * get the element_class from the current corlib.
7386                  */
7387                 ec = default_class_from_mono_type (klass->enum_basetype);
7388                 klass->instance_size = ec->instance_size;
7389                 klass->size_inited = 1;
7390                 /*
7391                  * this is almost safe to do with enums and it's needed to be able
7392                  * to create objects of the enum type (for use in SetConstant).
7393                  */
7394                 /* FIXME: Does this mean enums can't have method overrides ? */
7395                 mono_class_setup_vtable (klass, NULL, 0);
7396         }
7397 }
7398
7399 static MonoMarshalSpec*
7400 mono_marshal_spec_from_builder (MonoAssembly *assembly,
7401                                                                 MonoReflectionMarshal *minfo)
7402 {
7403         MonoMarshalSpec *res;
7404
7405         res = g_new0 (MonoMarshalSpec, 1);
7406         res->native = minfo->type;
7407
7408         switch (minfo->type) {
7409         case MONO_NATIVE_LPARRAY:
7410                 res->data.array_data.elem_type = minfo->eltype;
7411                 res->data.array_data.param_num = 0; /* Not yet */
7412                 res->data.array_data.num_elem = minfo->count;
7413                 break;
7414
7415         case MONO_NATIVE_BYVALTSTR:
7416         case MONO_NATIVE_BYVALARRAY:
7417                 res->data.array_data.num_elem = minfo->count;
7418                 break;
7419
7420         case MONO_NATIVE_CUSTOM:
7421                 if (minfo->marshaltyperef)
7422                         res->data.custom_data.custom_name =
7423                                 type_get_fully_qualified_name (minfo->marshaltyperef->type);
7424                 if (minfo->mcookie)
7425                         res->data.custom_data.cookie = mono_string_to_utf8 (minfo->mcookie);
7426                 break;
7427
7428         default:
7429                 break;
7430         }
7431
7432         return res;
7433 }
7434
7435 MonoReflectionMarshal*
7436 mono_reflection_marshal_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
7437                                                                                    MonoMarshalSpec *spec)
7438 {
7439         static MonoClass *System_Reflection_Emit_UnmanagedMarshalClass;
7440         MonoReflectionMarshal *minfo;
7441         MonoType *mtype;
7442
7443         if (!System_Reflection_Emit_UnmanagedMarshalClass) {
7444                 System_Reflection_Emit_UnmanagedMarshalClass = mono_class_from_name (
7445                    mono_defaults.corlib, "System.Reflection.Emit", "UnmanagedMarshal");
7446                 g_assert (System_Reflection_Emit_UnmanagedMarshalClass);
7447         }
7448
7449         minfo = (MonoReflectionMarshal*)mono_object_new (domain, System_Reflection_Emit_UnmanagedMarshalClass);
7450         minfo->type = spec->native;
7451
7452         switch (minfo->type) {
7453         case MONO_NATIVE_LPARRAY:
7454                 minfo->eltype = spec->data.array_data.elem_type;
7455                 minfo->count = spec->data.array_data.num_elem;
7456                 break;
7457
7458         case MONO_NATIVE_BYVALTSTR:
7459         case MONO_NATIVE_BYVALARRAY:
7460                 minfo->count = spec->data.array_data.num_elem;
7461                 break;
7462
7463         case MONO_NATIVE_CUSTOM:
7464                 if (spec->data.custom_data.custom_name) {
7465                         mtype = mono_reflection_type_from_name (spec->data.custom_data.custom_name, klass->image);
7466                         if (mtype)
7467                                 minfo->marshaltyperef = mono_type_get_object (domain, mtype);
7468
7469                         minfo->marshaltype = mono_string_new (domain, spec->data.custom_data.custom_name);
7470                 }
7471                 if (spec->data.custom_data.cookie)
7472                         minfo->mcookie = mono_string_new (domain, spec->data.custom_data.cookie);
7473                 break;
7474
7475         default:
7476                 break;
7477         }
7478
7479         return minfo;
7480 }
7481
7482 static MonoMethod*
7483 reflection_methodbuilder_to_mono_method (MonoClass *klass,
7484                                          ReflectionMethodBuilder *rmb,
7485                                          MonoMethodSignature *sig)
7486 {
7487         MonoMethod *m;
7488         MonoMethodNormal *pm;
7489         MonoMarshalSpec **specs;
7490         MonoReflectionMethodAux *method_aux;
7491         int i;
7492
7493         if ((rmb->attrs & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
7494                         (rmb->iattrs & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
7495                 m = (MonoMethod *)g_new0 (MonoMethodPInvoke, 1);
7496         else if (rmb->refs)
7497                 m = (MonoMethod *)g_new0 (MonoMethodWrapper, 1);
7498         else
7499                 m = (MonoMethod *)g_new0 (MonoMethodNormal, 1);
7500
7501         pm = (MonoMethodNormal*)m;
7502
7503         m->slot = -1;
7504         m->flags = rmb->attrs;
7505         m->iflags = rmb->iattrs;
7506         m->name = mono_string_to_utf8 (rmb->name);
7507         m->klass = klass;
7508         m->signature = sig;
7509         if (rmb->table_idx)
7510                 m->token = MONO_TOKEN_METHOD_DEF | (*rmb->table_idx);
7511
7512         if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
7513                 if (klass == mono_defaults.string_class && !strcmp (m->name, ".ctor"))
7514                         m->string_ctor = 1;
7515
7516                 m->signature->pinvoke = 1;
7517         } else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
7518                 m->signature->pinvoke = 1;
7519
7520                 method_aux = g_new0 (MonoReflectionMethodAux, 1);
7521
7522                 method_aux->dllentry = g_strdup (mono_string_to_utf8 (rmb->dllentry));
7523                 method_aux->dll = g_strdup (mono_string_to_utf8 (rmb->dll));
7524
7525                 ((MonoMethodPInvoke*)m)->piflags = (rmb->native_cc << 8) | (rmb->charset ? (rmb->charset - 1) * 2 : 1) | rmb->lasterr;
7526
7527                 if (klass->image->dynamic)
7528                         mono_g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
7529
7530                 return m;
7531         } else if (!m->klass->dummy &&
7532                            !(m->flags & METHOD_ATTRIBUTE_ABSTRACT) &&
7533                            !(m->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
7534                 MonoMethodHeader *header;
7535                 guint32 code_size;
7536                 gint32 max_stack, i;
7537                 gint32 num_locals = 0;
7538                 gint32 num_clauses = 0;
7539                 guint8 *code;
7540
7541                 if (rmb->ilgen) {
7542                         code = mono_array_addr (rmb->ilgen->code, guint8, 0);
7543                         code_size = rmb->ilgen->code_len;
7544                         max_stack = rmb->ilgen->max_stack;
7545                         num_locals = rmb->ilgen->locals ? mono_array_length (rmb->ilgen->locals) : 0;
7546                         if (rmb->ilgen->ex_handlers)
7547                                 num_clauses = method_count_clauses (rmb->ilgen);
7548                 } else {
7549                         if (rmb->code) {
7550                                 code = mono_array_addr (rmb->code, guint8, 0);
7551                                 code_size = mono_array_length (rmb->code);
7552                                 /* we probably need to run a verifier on the code... */
7553                                 max_stack = 8;
7554                         }
7555                         else {
7556                                 code = NULL;
7557                                 code_size = 0;
7558                                 max_stack = 8;
7559                         }
7560                 }
7561
7562                 header = g_malloc0 (sizeof (MonoMethodHeader) +
7563                         (num_locals - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*));
7564                 header->code_size = code_size;
7565                 header->code = g_malloc (code_size);
7566                 memcpy ((char*)header->code, code, code_size);
7567                 header->max_stack = max_stack;
7568                 header->init_locals = rmb->init_locals;
7569                 header->num_locals = num_locals;
7570
7571                 for (i = 0; i < num_locals; ++i) {
7572                         MonoReflectionLocalBuilder *lb =
7573                                 mono_array_get (rmb->ilgen->locals, MonoReflectionLocalBuilder*, i);
7574
7575                         header->locals [i] = g_new0 (MonoType, 1);
7576                         memcpy (header->locals [i], lb->type->type, sizeof (MonoType));
7577                 }
7578
7579                 header->num_clauses = num_clauses;
7580                 if (num_clauses) {
7581                         header->clauses = method_encode_clauses ((MonoDynamicImage*)klass->image,
7582                                  rmb->ilgen, num_clauses);
7583                 }
7584
7585                 pm->header = header;
7586         }
7587
7588         if (rmb->generic_params) {
7589                 int count = mono_array_length (rmb->generic_params);
7590                 MonoGenericContainer *container;
7591
7592                 pm->generic_container = container = g_new0 (MonoGenericContainer, 1);
7593                 container->type_argc = count;
7594                 container->type_params = g_new0 (MonoGenericParam, count);
7595
7596                 for (i = 0; i < count; i++) {
7597                         MonoReflectionGenericParam *gp =
7598                                 mono_array_get (rmb->generic_params, MonoReflectionGenericParam*, i);
7599
7600                         container->type_params [i] = *gp->type.type->data.generic_param;
7601                 }
7602         }
7603
7604         if (rmb->refs) {
7605                 MonoMethodWrapper *mw = (MonoMethodWrapper*)m;
7606                 int i;
7607
7608                 m->wrapper_type = MONO_WRAPPER_DYNAMIC_METHOD;
7609
7610                 for (i = 0; i < rmb->nrefs; ++i)
7611                         mw->data = g_list_append (mw->data, rmb->refs [i]);
7612         }
7613
7614         method_aux = NULL;
7615
7616         /* Parameter info */
7617         if (rmb->pinfo) {
7618                 if (!method_aux)
7619                         method_aux = g_new0 (MonoReflectionMethodAux, 1);
7620                 method_aux->param_names = g_new0 (char *, m->signature->param_count + 1);
7621                 for (i = 0; i <= m->signature->param_count; ++i) {
7622                         MonoReflectionParamBuilder *pb;
7623                         if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) {
7624                                 if (i > 0)
7625                                         m->signature->params [i - 1]->attrs = pb->attrs;
7626
7627                                 if (pb->def_value) {
7628                                         MonoDynamicImage *assembly;
7629                                         guint32 idx, def_type, len;
7630                                         char *p;
7631                                         const char *p2;
7632
7633                                         if (!method_aux->param_defaults)
7634                                                 method_aux->param_defaults = g_new0 (guint8*, m->signature->param_count + 1);
7635                                         assembly = (MonoDynamicImage*)klass->image;
7636                                         idx = encode_constant (assembly, pb->def_value, &def_type);
7637                                         /* Copy the data from the blob since it might get realloc-ed */
7638                                         p = assembly->blob.data + idx;
7639                                         len = mono_metadata_decode_blob_size (p, &p2);
7640                                         len += p2 - p;
7641                                         method_aux->param_defaults [i] = g_malloc (len);
7642                                         memcpy ((gpointer)method_aux->param_defaults [i], p, len);
7643                                 }
7644
7645                                 if (pb->name)
7646                                         method_aux->param_names [i] = mono_string_to_utf8 (pb->name);
7647                                 if (pb->cattrs) {
7648                                         if (!method_aux->param_cattr)
7649                                                 method_aux->param_cattr = g_new0 (MonoCustomAttrInfo*, m->signature->param_count + 1);
7650                                         method_aux->param_cattr [i] = mono_custom_attrs_from_builders (klass->image, pb->cattrs);
7651                                 }
7652                         }
7653                 }
7654         }
7655
7656         /* Parameter marshalling */
7657         specs = NULL;
7658         if (rmb->pinfo)
7659                 for (i = 0; i < mono_array_length (rmb->pinfo); ++i) {
7660                         MonoReflectionParamBuilder *pb;
7661                         if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) {
7662                                 if (pb->marshal_info) {
7663                                         if (specs == NULL)
7664                                                 specs = g_new0 (MonoMarshalSpec*, sig->param_count + 1);
7665                                         specs [pb->position] =
7666                                                 mono_marshal_spec_from_builder (klass->image->assembly, pb->marshal_info);
7667                                 }
7668                         }
7669                 }
7670         if (specs != NULL) {
7671                 if (!method_aux)
7672                         method_aux = g_new0 (MonoReflectionMethodAux, 1);
7673                 method_aux->param_marshall = specs;
7674         }
7675
7676         if (klass->image->dynamic && method_aux)
7677                 mono_g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
7678
7679         return m;
7680 }
7681
7682 static MonoMethod*
7683 ctorbuilder_to_mono_method (MonoClass *klass, MonoReflectionCtorBuilder* mb)
7684 {
7685         ReflectionMethodBuilder rmb;
7686         MonoMethodSignature *sig;
7687
7688         sig = ctor_builder_to_signature (mb);
7689
7690         reflection_methodbuilder_from_ctor_builder (&rmb, mb);
7691
7692         mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
7693         mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
7694
7695         if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save) {
7696                 /* ilgen is no longer needed */
7697                 mb->ilgen = NULL;
7698         }
7699
7700         return mb->mhandle;
7701 }
7702
7703 static MonoMethod*
7704 methodbuilder_to_mono_method (MonoClass *klass, MonoReflectionMethodBuilder* mb)
7705 {
7706         ReflectionMethodBuilder rmb;
7707         MonoMethodSignature *sig;
7708
7709         sig = method_builder_to_signature (mb);
7710
7711         reflection_methodbuilder_from_method_builder (&rmb, mb);
7712
7713         mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
7714         mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
7715
7716         if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save) {
7717                 /* ilgen is no longer needed */
7718                 mb->ilgen = NULL;
7719         }
7720         return mb->mhandle;
7721 }
7722
7723 static MonoClassField*
7724 fieldbuilder_to_mono_class_field (MonoClass *klass, MonoReflectionFieldBuilder* fb)
7725 {
7726         MonoClassField *field;
7727         const char *p, *p2;
7728         guint32 len, idx;
7729
7730         if (fb->handle)
7731                 return fb->handle;
7732
7733         field = g_new0 (MonoClassField, 1);
7734
7735         field->name = mono_string_to_utf8 (fb->name);
7736         if (fb->attrs) {
7737                 /* FIXME: handle type modifiers */
7738                 field->type = g_memdup (fb->type->type, sizeof (MonoType));
7739                 field->type->attrs = fb->attrs;
7740         } else {
7741                 field->type = fb->type->type;
7742         }
7743         if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && fb->rva_data)
7744                 field->data = mono_array_addr (fb->rva_data, char, 0);
7745         if (fb->offset != -1)
7746                 field->offset = fb->offset;
7747         field->parent = klass;
7748         fb->handle = field;
7749         mono_save_custom_attrs (klass->image, field, fb->cattrs);
7750
7751         if (fb->def_value) {
7752                 MonoDynamicImage *assembly = (MonoDynamicImage*)klass->image;
7753                 field->type->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
7754                 idx = encode_constant (assembly, fb->def_value, &field->def_type);
7755                 /* Copy the data from the blob since it might get realloc-ed */
7756                 p = assembly->blob.data + idx;
7757                 len = mono_metadata_decode_blob_size (p, &p2);
7758                 len += p2 - p;
7759                 field->data = g_malloc (len);
7760                 memcpy ((gpointer)field->data, p, len);
7761         }
7762
7763         return field;
7764 }
7765
7766 static MonoType*
7767 do_mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types)
7768 {
7769         MonoClass *klass, *gklass;
7770         MonoReflectionTypeBuilder *tb = NULL;
7771         MonoGenericInst *ginst, *cached;
7772         MonoDomain *domain;
7773         MonoType *geninst;
7774         int icount, i;
7775
7776         klass = mono_class_from_mono_type (type->type);
7777         if (!klass->generic_container && !klass->generic_inst &&
7778             !(klass->nested_in && klass->nested_in->generic_container))
7779                 return NULL;
7780
7781         mono_loader_lock ();
7782
7783         domain = mono_object_domain (type);
7784
7785         ginst = g_new0 (MonoGenericInst, 1);
7786
7787         if (!klass->generic_inst) {
7788                 ginst->type_argc = type_argc;
7789                 ginst->type_argv = types;
7790
7791                 for (i = 0; i < ginst->type_argc; ++i) {
7792                         if (!ginst->is_open)
7793                                 ginst->is_open = mono_class_is_open_constructed_type (types [i]);
7794                 }
7795
7796                 ginst->generic_type = &klass->byval_arg;
7797         } else {
7798                 MonoGenericInst *kginst = klass->generic_inst;
7799
7800                 ginst->type_argc = kginst->type_argc;
7801                 ginst->type_argv = g_new0 (MonoType *, ginst->type_argc);
7802
7803                 for (i = 0; i < ginst->type_argc; i++) {
7804                         MonoType *t = kginst->type_argv [i];
7805
7806                         if (t->type == MONO_TYPE_VAR)
7807                                 t = types [t->data.generic_param->num];
7808
7809                         if (!ginst->is_open)
7810                                 ginst->is_open = mono_class_is_open_constructed_type (t);
7811
7812                         ginst->type_argv [i] = t;
7813                 }
7814
7815                 ginst->generic_type = kginst->generic_type;
7816         }
7817
7818         geninst = g_new0 (MonoType, 1);
7819         geninst->type = MONO_TYPE_GENERICINST;
7820
7821         cached = g_hash_table_lookup (klass->image->generic_inst_cache, ginst);
7822         if (cached) {
7823                 g_free (ginst);
7824                 mono_loader_unlock ();
7825                 geninst->data.generic_inst = cached;
7826                 return geninst;
7827         }
7828
7829         gklass = mono_class_from_mono_type (ginst->generic_type);
7830         g_assert ((ginst->container = gklass->generic_container) != NULL);
7831
7832         geninst->data.generic_inst = ginst;
7833
7834         ginst->context = g_new0 (MonoGenericContext, 1);
7835         ginst->context->ginst = ginst;
7836
7837         if (!strcmp (((MonoObject *) type)->vtable->klass->name, "TypeBuilder")) {
7838                 tb = (MonoReflectionTypeBuilder *) type;
7839
7840                 icount = tb->interfaces ? mono_array_length (tb->interfaces) : 0;
7841                 ginst->is_dynamic = TRUE;
7842         } else if (!strcmp (((MonoObject *) type)->vtable->klass->name, "MonoGenericInst")) {
7843                 MonoReflectionGenericInst *rgi = (MonoReflectionGenericInst *) type;
7844                 MonoReflectionType *rgt = rgi->generic_type;
7845
7846                 g_assert (!strcmp (((MonoObject *) rgt)->vtable->klass->name, "TypeBuilder"));
7847                 tb = (MonoReflectionTypeBuilder *) rgt;
7848
7849                 icount = tb->interfaces ? mono_array_length (tb->interfaces) : 0;
7850                 ginst->is_dynamic = TRUE;
7851         } else {
7852                 icount = klass->interface_count;
7853         }
7854
7855         ginst->ifaces = g_new0 (MonoType *, icount);
7856         ginst->count_ifaces = icount;
7857
7858         for (i = 0; i < icount; i++) {
7859                 MonoReflectionType *itype;
7860
7861                 if (tb)
7862                         itype = mono_array_get (tb->interfaces, MonoReflectionType *, i);
7863                 else
7864                         itype = mono_type_get_object (domain, &klass->interfaces [i]->byval_arg);
7865                 ginst->ifaces [i] = mono_reflection_bind_generic_parameters (itype, type_argc, types);
7866                 if (!ginst->ifaces [i])
7867                         ginst->ifaces [i] = itype->type;
7868         }
7869
7870         mono_class_create_generic (ginst);
7871
7872         g_hash_table_insert (klass->image->generic_inst_cache, ginst, ginst);
7873
7874         mono_loader_unlock ();
7875
7876         return geninst;
7877 }
7878
7879 MonoType*
7880 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types)
7881 {
7882         MonoClass *klass, *pklass = NULL;
7883         MonoReflectionType *parent = NULL;
7884         MonoType *geninst;
7885         MonoReflectionTypeBuilder *tb = NULL;
7886         MonoGenericInst *ginst;
7887         MonoDomain *domain;
7888
7889         domain = mono_object_domain (type);
7890         klass = mono_class_from_mono_type (type->type);
7891
7892         if (!strcmp (((MonoObject *) type)->vtable->klass->name, "TypeBuilder")) {
7893                 tb = (MonoReflectionTypeBuilder *) type;
7894
7895                 if (tb->parent) {
7896                         parent = tb->parent;
7897                         pklass = mono_class_from_mono_type (parent->type);
7898                 }
7899         } else {
7900                 pklass = klass->parent;
7901                 if (pklass)
7902                         parent = mono_type_get_object (domain, &pklass->byval_arg);
7903                 else if (klass->generic_inst && klass->generic_inst->parent) {
7904                         parent = mono_type_get_object (domain, klass->generic_inst->parent);
7905                         pklass = mono_class_from_mono_type (klass->generic_inst->parent);
7906                 }
7907         }
7908
7909         geninst = do_mono_reflection_bind_generic_parameters (type, type_argc, types);
7910         if (!geninst)
7911                 return NULL;
7912
7913         ginst = geninst->data.generic_inst;
7914
7915         if (pklass && pklass->generic_inst)
7916                 ginst->parent = mono_reflection_bind_generic_parameters (parent, type_argc, types);
7917
7918         return geninst;
7919 }
7920
7921 MonoReflectionMethod*
7922 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types)
7923 {
7924         MonoMethod *method, *inflated;
7925         MonoReflectionMethodBuilder *mb = NULL;
7926         MonoGenericMethod *gmethod;
7927         MonoGenericContext *context;
7928         int count, i;
7929
7930         MONO_ARCH_SAVE_REGS;
7931         if (!strcmp (rmethod->object.vtable->klass->name, "MethodBuilder")) {
7932                 MonoReflectionTypeBuilder *tb;
7933                 MonoClass *klass;
7934
7935                 mb = (MonoReflectionMethodBuilder *) rmethod;
7936                 tb = (MonoReflectionTypeBuilder *) mb->type;
7937                 klass = mono_class_from_mono_type (tb->type.type);
7938
7939                 method = methodbuilder_to_mono_method (klass, mb);
7940         } else {
7941                 method = rmethod->method;
7942         }
7943
7944         count = method->signature->generic_param_count;
7945         if (count != mono_array_length (types))
7946                 return NULL;
7947
7948         gmethod = g_new0 (MonoGenericMethod, 1);
7949         gmethod->mtype_argc = count;
7950         gmethod->mtype_argv = g_new0 (MonoType *, count);
7951         for (i = 0; i < count; i++) {
7952                 MonoReflectionType *garg = mono_array_get (types, gpointer, i);
7953                 gmethod->mtype_argv [i] = garg->type;
7954         }
7955
7956         gmethod->reflection_info = rmethod;
7957
7958         context = g_new0 (MonoGenericContext, 1);
7959         context->ginst = method->klass->generic_inst;
7960         context->gmethod = gmethod;
7961
7962         inflated = mono_class_inflate_generic_method (method, context, NULL);
7963
7964         return mono_method_get_object (
7965                 mono_object_domain (rmethod), inflated, NULL);
7966 }
7967
7968 static MonoMethod *
7969 inflate_mono_method (MonoReflectionGenericInst *type, MonoMethod *method, MonoObject *obj)
7970 {
7971         MonoGenericMethod *gmethod;
7972         MonoGenericInst *ginst;
7973         MonoGenericContext *context;
7974         int i;
7975
7976         ginst = type->type.type->data.generic_inst;
7977
7978         gmethod = g_new0 (MonoGenericMethod, 1);
7979         gmethod->reflection_info = obj;
7980
7981         gmethod->mtype_argc = method->signature->generic_param_count;
7982         gmethod->mtype_argv = g_new0 (MonoType *, gmethod->mtype_argc);
7983
7984         for (i = 0; i < gmethod->mtype_argc; i++) {
7985                 MonoMethodNormal *mn = (MonoMethodNormal *) method;
7986                 MonoGenericParam *gparam = &mn->generic_container->type_params [i];
7987
7988                 g_assert (gparam->pklass);
7989                 gmethod->mtype_argv [i] = &gparam->pklass->byval_arg;
7990         }
7991
7992         context = g_new0 (MonoGenericContext, 1);
7993         context->ginst = ginst;
7994         context->gmethod = gmethod;
7995
7996         return mono_class_inflate_generic_method (method, context, ginst->klass);
7997 }
7998
7999 static MonoMethod *
8000 inflate_method (MonoReflectionGenericInst *type, MonoObject *obj)
8001 {
8002         MonoMethod *method;
8003         MonoClass *klass;
8004
8005         klass = mono_class_from_mono_type (type->type.type);
8006
8007         if (!strcmp (obj->vtable->klass->name, "MethodBuilder"))
8008                 method = methodbuilder_to_mono_method (klass, (MonoReflectionMethodBuilder *) obj);
8009         else if (!strcmp (obj->vtable->klass->name, "ConstructorBuilder"))
8010                 method = ctorbuilder_to_mono_method (klass, (MonoReflectionCtorBuilder *) obj);
8011         else if (!strcmp (obj->vtable->klass->name, "MonoMethod") || !strcmp (obj->vtable->klass->name, "MonoCMethod"))
8012                 method = ((MonoReflectionMethod *) obj)->method;
8013         else {
8014                 method = NULL; /* prevent compiler warning */
8015                 g_assert_not_reached ();
8016         }
8017
8018         return inflate_mono_method (type, method, obj);
8019 }
8020
8021 void
8022 mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, MonoArray *methods,
8023         MonoArray *ctors, MonoArray *fields, MonoArray *properties, MonoArray *events)
8024 {
8025         MonoGenericInst *ginst;
8026         MonoDynamicGenericInst *dginst;
8027         MonoClass *klass, *gklass, *pklass;
8028         int i;
8029
8030         MONO_ARCH_SAVE_REGS;
8031
8032         klass = mono_class_from_mono_type (type->type.type);
8033         ginst = type->type.type->data.generic_inst;
8034
8035         if (ginst->initialized)
8036                 return;
8037
8038         dginst = ginst->dynamic_info = g_new0 (MonoDynamicGenericInst, 1);
8039
8040         gklass = mono_class_from_mono_type (ginst->generic_type);
8041         mono_class_init (gklass);
8042
8043         if (ginst->parent)
8044                 pklass = mono_class_from_mono_type (ginst->parent);
8045         else
8046                 pklass = gklass->parent;
8047
8048         mono_class_setup_parent (klass, pklass);
8049
8050         dginst->count_methods = methods ? mono_array_length (methods) : 0;
8051         dginst->count_ctors = ctors ? mono_array_length (ctors) : 0;
8052         dginst->count_fields = fields ? mono_array_length (fields) : 0;
8053         dginst->count_properties = properties ? mono_array_length (properties) : 0;
8054         dginst->count_events = events ? mono_array_length (events) : 0;
8055
8056         dginst->methods = g_new0 (MonoMethod *, dginst->count_methods);
8057         dginst->ctors = g_new0 (MonoMethod *, dginst->count_ctors);
8058         dginst->fields = g_new0 (MonoClassField, dginst->count_fields);
8059         dginst->properties = g_new0 (MonoProperty, dginst->count_properties);
8060         dginst->events = g_new0 (MonoEvent, dginst->count_events);
8061
8062         for (i = 0; i < dginst->count_methods; i++) {
8063                 MonoObject *obj = mono_array_get (methods, gpointer, i);
8064
8065                 dginst->methods [i] = inflate_method (type, obj);
8066         }
8067
8068         for (i = 0; i < dginst->count_ctors; i++) {
8069                 MonoObject *obj = mono_array_get (ctors, gpointer, i);
8070
8071                 dginst->ctors [i] = inflate_method (type, obj);
8072         }
8073
8074         for (i = 0; i < dginst->count_fields; i++) {
8075                 MonoObject *obj = mono_array_get (fields, gpointer, i);
8076                 MonoClassField *field;
8077                 MonoInflatedField *ifield;
8078
8079                 if (!strcmp (obj->vtable->klass->name, "FieldBuilder"))
8080                         field = fieldbuilder_to_mono_class_field (klass, (MonoReflectionFieldBuilder *) obj);
8081                 else if (!strcmp (obj->vtable->klass->name, "MonoField"))
8082                         field = ((MonoReflectionField *) obj)->field;
8083                 else {
8084                         field = NULL; /* prevent compiler warning */
8085                         g_assert_not_reached ();
8086                 }
8087
8088                 ifield = g_new0 (MonoInflatedField, 1);
8089                 ifield->generic_type = field->type;
8090                 ifield->reflection_info = obj;
8091
8092                 dginst->fields [i] = *field;
8093                 dginst->fields [i].generic_info = ifield;
8094                 dginst->fields [i].type = mono_class_inflate_generic_type (field->type, ginst->context);
8095         }
8096
8097         for (i = 0; i < dginst->count_properties; i++) {
8098                 MonoObject *obj = mono_array_get (properties, gpointer, i);
8099                 MonoProperty *property = &dginst->properties [i];
8100
8101                 if (!strcmp (obj->vtable->klass->name, "PropertyBuilder")) {
8102                         MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *) obj;
8103
8104                         property->parent = klass;
8105                         property->attrs = pb->attrs;
8106                         property->name = mono_string_to_utf8 (pb->name);
8107                         if (pb->get_method)
8108                                 property->get = inflate_method (type, (MonoObject *) pb->get_method);
8109                         if (pb->set_method)
8110                                 property->set = inflate_method (type, (MonoObject *) pb->set_method);
8111                 } else if (!strcmp (obj->vtable->klass->name, "MonoProperty")) {
8112                         *property = *((MonoReflectionProperty *) obj)->property;
8113
8114                         if (property->get)
8115                                 property->get = inflate_mono_method (type, property->get, NULL);
8116                         if (property->set)
8117                                 property->set = inflate_mono_method (type, property->set, NULL);
8118                 } else
8119                         g_assert_not_reached ();
8120         }
8121
8122         for (i = 0; i < dginst->count_events; i++) {
8123                 MonoObject *obj = mono_array_get (events, gpointer, i);
8124                 MonoEvent *event = &dginst->events [i];
8125
8126                 if (!strcmp (obj->vtable->klass->name, "EventBuilder")) {
8127                         MonoReflectionEventBuilder *eb = (MonoReflectionEventBuilder *) obj;
8128
8129                         event->parent = klass;
8130                         event->attrs = eb->attrs;
8131                         event->name = mono_string_to_utf8 (eb->name);
8132                         if (eb->add_method)
8133                                 event->add = inflate_method (type, (MonoObject *) eb->add_method);
8134                         if (eb->remove_method)
8135                                 event->remove = inflate_method (type, (MonoObject *) eb->remove_method);
8136                 } else if (!strcmp (obj->vtable->klass->name, "MonoEvent")) {
8137                         *event = *((MonoReflectionEvent *) obj)->event;
8138
8139                         if (event->add)
8140                                 event->add = inflate_mono_method (type, event->add, NULL);
8141                         if (event->remove)
8142                                 event->remove = inflate_mono_method (type, event->remove, NULL);
8143                 } else
8144                         g_assert_not_reached ();
8145         }
8146
8147         ginst->initialized = TRUE;
8148 }
8149
8150 static void
8151 ensure_runtime_vtable (MonoClass *klass)
8152 {
8153         MonoReflectionTypeBuilder *tb = klass->reflection_info;
8154         int i, num, j, onum;
8155         MonoMethod **overrides;
8156
8157         if (!tb || klass->wastypebuilder)
8158                 return;
8159         if (klass->parent)
8160                 ensure_runtime_vtable (klass->parent);
8161
8162         num = tb->ctors? mono_array_length (tb->ctors): 0;
8163         num += tb->num_methods;
8164         klass->method.count = num;
8165         klass->methods = g_new (MonoMethod*, num);
8166         num = tb->ctors? mono_array_length (tb->ctors): 0;
8167         for (i = 0; i < num; ++i)
8168                 klass->methods [i] = ctorbuilder_to_mono_method (klass, mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i));
8169         num = tb->num_methods;
8170         j = i;
8171         for (i = 0; i < num; ++i)
8172                 klass->methods [j++] = methodbuilder_to_mono_method (klass, mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i));
8173
8174         if (tb->interfaces) {
8175                 klass->interface_count = mono_array_length (tb->interfaces);
8176                 klass->interfaces = g_new (MonoClass*, klass->interface_count);
8177                 for (i = 0; i < klass->interface_count; ++i) {
8178                         MonoReflectionType *iface = mono_array_get (tb->interfaces, gpointer, i);
8179                         klass->interfaces [i] = mono_class_from_mono_type (iface->type);
8180                 }
8181         }
8182
8183         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE)
8184                 for (i = 0; i < klass->method.count; ++i)
8185                         klass->methods [i]->slot = i;
8186
8187         /* Overrides */
8188         onum = 0;
8189         if (tb->methods) {
8190                 for (i = 0; i < tb->num_methods; ++i) {
8191                         MonoReflectionMethodBuilder *mb =
8192                                 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
8193                         if (mb->override_method)
8194                                 onum ++;
8195                 }
8196         }
8197
8198         overrides = g_new0 (MonoMethod*, onum * 2);
8199
8200         if (tb->methods) {
8201                 onum = 0;
8202                 for (i = 0; i < tb->num_methods; ++i) {
8203                         MonoReflectionMethodBuilder *mb =
8204                                 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
8205                         if (mb->override_method) {
8206                                 /* FIXME: What if 'override_method' is a MethodBuilder ? */
8207                                 overrides [onum * 2] =
8208                                         mb->override_method->method;
8209                                 overrides [onum * 2 + 1] =
8210                                         mb->mhandle;
8211
8212                                 g_assert (mb->mhandle);
8213
8214                                 onum ++;
8215                         }
8216                 }
8217         }
8218
8219         mono_class_setup_vtable (klass, overrides, onum);
8220         g_free (overrides);
8221 }
8222
8223 static void
8224 typebuilder_setup_fields (MonoClass *klass)
8225 {
8226         MonoReflectionTypeBuilder *tb = klass->reflection_info;
8227         MonoReflectionFieldBuilder *fb;
8228         MonoClassField *field;
8229         const char *p, *p2;
8230         int i;
8231         guint32 len, idx;
8232
8233         klass->field.count = tb->num_fields;
8234         klass->field.first = 0;
8235         klass->field.last = klass->field.count;
8236
8237         if (!klass->field.count)
8238                 return;
8239
8240         klass->fields = g_new0 (MonoClassField, klass->field.count);
8241
8242         for (i = 0; i < klass->field.count; ++i) {
8243                 fb = mono_array_get (tb->fields, gpointer, i);
8244                 field = &klass->fields [i];
8245                 field->name = mono_string_to_utf8 (fb->name);
8246                 if (fb->attrs) {
8247                         /* FIXME: handle type modifiers */
8248                         field->type = g_memdup (fb->type->type, sizeof (MonoType));
8249                         field->type->attrs = fb->attrs;
8250                 } else {
8251                         field->type = fb->type->type;
8252                 }
8253                 if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && fb->rva_data)
8254                         field->data = mono_array_addr (fb->rva_data, char, 0);
8255                 if (fb->offset != -1)
8256                         field->offset = fb->offset;
8257                 field->parent = klass;
8258                 fb->handle = field;
8259                 mono_save_custom_attrs (klass->image, field, fb->cattrs);
8260
8261                 if (fb->def_value) {
8262                         MonoDynamicImage *assembly = (MonoDynamicImage*)klass->image;
8263                         field->type->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
8264                         idx = encode_constant (assembly, fb->def_value, &field->def_type);
8265                         /* Copy the data from the blob since it might get realloc-ed */
8266                         p = assembly->blob.data + idx;
8267                         len = mono_metadata_decode_blob_size (p, &p2);
8268                         len += p2 - p;
8269                         field->data = g_malloc (len);
8270                         memcpy ((gpointer)field->data, p, len);
8271                 }
8272         }
8273         mono_class_layout_fields (klass);
8274 }
8275
8276 static void
8277 typebuilder_setup_properties (MonoClass *klass)
8278 {
8279         MonoReflectionTypeBuilder *tb = klass->reflection_info;
8280         MonoReflectionPropertyBuilder *pb;
8281         int i;
8282
8283         klass->property.count = tb->properties ? mono_array_length (tb->properties) : 0;
8284         klass->property.first = 0;
8285         klass->property.last = klass->property.count;
8286
8287         klass->properties = g_new0 (MonoProperty, klass->property.count);
8288         for (i = 0; i < klass->property.count; ++i) {
8289                 pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
8290                 klass->properties [i].parent = klass;
8291                 klass->properties [i].attrs = pb->attrs;
8292                 klass->properties [i].name = mono_string_to_utf8 (pb->name);
8293                 if (pb->get_method)
8294                         klass->properties [i].get = pb->get_method->mhandle;
8295                 if (pb->set_method)
8296                         klass->properties [i].set = pb->set_method->mhandle;
8297         }
8298 }
8299
8300 MonoReflectionEvent *
8301 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb)
8302 {
8303         MonoEvent *event = g_new0 (MonoEvent, 1);
8304         MonoClass *klass;
8305         int j;
8306
8307         klass = my_mono_class_from_mono_type (tb->type.type);
8308
8309         event->parent = klass;
8310         event->attrs = eb->attrs;
8311         event->name = mono_string_to_utf8 (eb->name);
8312         if (eb->add_method)
8313                 event->add = eb->add_method->mhandle;
8314         if (eb->remove_method)
8315                 event->remove = eb->remove_method->mhandle;
8316         if (eb->raise_method)
8317                 event->raise = eb->raise_method->mhandle;
8318
8319         if (eb->other_methods) {
8320                 event->other = g_new0 (MonoMethod*, mono_array_length (eb->other_methods) + 1);
8321                 for (j = 0; j < mono_array_length (eb->other_methods); ++j) {
8322                         MonoReflectionMethodBuilder *mb =
8323                                 mono_array_get (eb->other_methods,
8324                                                 MonoReflectionMethodBuilder*, j);
8325                         event->other [j] = mb->mhandle;
8326                 }
8327         }
8328
8329         return mono_event_get_object (mono_object_domain (tb), klass, event);
8330 }
8331
8332 static void
8333 typebuilder_setup_events (MonoClass *klass)
8334 {
8335         MonoReflectionTypeBuilder *tb = klass->reflection_info;
8336         MonoReflectionEventBuilder *eb;
8337         int i, j;
8338
8339         klass->event.count = tb->events ? mono_array_length (tb->events) : 0;
8340         klass->event.first = 0;
8341         klass->event.last = klass->event.count;
8342
8343         klass->events = g_new0 (MonoEvent, klass->event.count);
8344         for (i = 0; i < klass->event.count; ++i) {
8345                 eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
8346                 klass->events [i].parent = klass;
8347                 klass->events [i].attrs = eb->attrs;
8348                 klass->events [i].name = mono_string_to_utf8 (eb->name);
8349                 if (eb->add_method)
8350                         klass->events [i].add = eb->add_method->mhandle;
8351                 if (eb->remove_method)
8352                         klass->events [i].remove = eb->remove_method->mhandle;
8353                 if (eb->raise_method)
8354                         klass->events [i].raise = eb->raise_method->mhandle;
8355
8356                 if (eb->other_methods) {
8357                         klass->events [i].other = g_new0 (MonoMethod*, mono_array_length (eb->other_methods) + 1);
8358                         for (j = 0; j < mono_array_length (eb->other_methods); ++j) {
8359                                 MonoReflectionMethodBuilder *mb =
8360                                         mono_array_get (eb->other_methods,
8361                                                                         MonoReflectionMethodBuilder*, j);
8362                                 klass->events [i].other [j] = mb->mhandle;
8363                         }
8364                 }
8365         }
8366 }
8367
8368 MonoReflectionType*
8369 mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
8370 {
8371         MonoClass *klass;
8372         MonoReflectionType* res;
8373         int i;
8374
8375         MONO_ARCH_SAVE_REGS;
8376
8377         klass = my_mono_class_from_mono_type (tb->type.type);
8378
8379         mono_save_custom_attrs (klass->image, klass, tb->cattrs);
8380
8381         /*
8382          * Fields to set in klass:
8383          * the various flags: delegate/unicode/contextbound etc.
8384          */
8385         klass->flags = tb->attrs;
8386
8387         if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->run)
8388                 /* No need to fully construct the type */
8389                 return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
8390
8391         /* enums are done right away */
8392         if (!klass->enumtype)
8393                 ensure_runtime_vtable (klass);
8394
8395         if (tb->subtypes) {
8396                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
8397                         MonoReflectionTypeBuilder *subtb = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
8398                         klass->nested_classes = g_list_prepend (klass->nested_classes, my_mono_class_from_mono_type (subtb->type.type));
8399                 }
8400         }
8401
8402         /* fields and object layout */
8403         if (klass->parent) {
8404                 if (!klass->parent->size_inited)
8405                         mono_class_init (klass->parent);
8406                 klass->instance_size += klass->parent->instance_size;
8407                 klass->class_size += klass->parent->class_size;
8408                 klass->min_align = klass->parent->min_align;
8409         } else {
8410                 klass->instance_size = sizeof (MonoObject);
8411                 klass->min_align = 1;
8412         }
8413
8414         /* FIXME: handle packing_size and instance_size */
8415         typebuilder_setup_fields (klass);
8416
8417         typebuilder_setup_properties (klass);
8418
8419         typebuilder_setup_events (klass);
8420
8421         klass->wastypebuilder = TRUE;
8422
8423         res = mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
8424         g_assert (res != (MonoReflectionType*)tb);
8425         return res;
8426 }
8427
8428 void
8429 mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam)
8430 {
8431         MonoGenericParam *param;
8432         MonoImage *image;
8433
8434         MONO_ARCH_SAVE_REGS;
8435
8436         param = g_new0 (MonoGenericParam, 1);
8437
8438         if (gparam->mbuilder) {
8439                 if (!gparam->mbuilder->generic_container)
8440                         gparam->mbuilder->generic_container = g_new0 (MonoGenericContainer, 1);
8441                 param->owner = gparam->mbuilder->generic_container;
8442         } else if (gparam->tbuilder) {
8443                 MonoReflectionTypeBuilder *nesting = (MonoReflectionTypeBuilder*) gparam->tbuilder->nesting_type;
8444                 MonoGenericContainer *container = gparam->tbuilder->generic_container;
8445
8446                 while (nesting) {
8447                         int count;
8448
8449                         count = nesting->generic_params ? mono_array_length (nesting->generic_params) : 0;
8450                         if (gparam->index >= count)
8451                                 break;
8452
8453                         container = nesting->generic_container;
8454                         nesting = (MonoReflectionTypeBuilder*) nesting->nesting_type;
8455                 }
8456
8457                 g_assert (container);
8458                 param->owner = container;
8459         }
8460
8461         param->method = NULL;
8462         param->name = mono_string_to_utf8 (gparam->name);
8463         param->num = gparam->index;
8464
8465         image = &gparam->tbuilder->module->dynamic_image->image;
8466         mono_class_from_generic_parameter (param, image, gparam->mbuilder != NULL);
8467
8468         param->pklass->reflection_info = gparam;
8469
8470         gparam->type.type = g_new0 (MonoType, 1);
8471         gparam->type.type->type = gparam->mbuilder ? MONO_TYPE_MVAR : MONO_TYPE_VAR;
8472         gparam->type.type->attrs = TYPE_ATTRIBUTE_PUBLIC;
8473         gparam->type.type->data.generic_param = param;
8474 }
8475
8476 MonoArray *
8477 mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
8478 {
8479         MonoDynamicImage *assembly = sig->module->dynamic_image;
8480         guint32 na = mono_array_length (sig->arguments);
8481         guint32 buflen, i;
8482         MonoArray *result;
8483         char *buf, *p;
8484
8485         MONO_ARCH_SAVE_REGS;
8486
8487         p = buf = g_malloc (10 + na * 10);
8488
8489         mono_metadata_encode_value (0x07, p, &p);
8490         mono_metadata_encode_value (na, p, &p);
8491         for (i = 0; i < na; ++i) {
8492                 MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType *, i);
8493                 encode_reflection_type (assembly, type, p, &p);
8494         }
8495
8496         buflen = p - buf;
8497         result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
8498         p = mono_array_addr (result, char, 0);
8499         memcpy (p, buf, buflen);
8500         g_free (buf);
8501
8502         return result;
8503 }
8504
8505 MonoArray *
8506 mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
8507 {
8508         MonoDynamicImage *assembly = sig->module->dynamic_image;
8509         guint32 na = mono_array_length (sig->arguments);
8510         guint32 buflen, i;
8511         MonoArray *result;
8512         char *buf, *p;
8513
8514         MONO_ARCH_SAVE_REGS;
8515
8516         p = buf = g_malloc (10 + na * 10);
8517
8518         mono_metadata_encode_value (0x06, p, &p);
8519         for (i = 0; i < na; ++i) {
8520                 MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType *, i);
8521                 encode_reflection_type (assembly, type, p, &p);
8522         }
8523
8524         buflen = p - buf;
8525         result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
8526         p = mono_array_addr (result, char, 0);
8527         memcpy (p, buf, buflen);
8528         g_free (buf);
8529
8530         return result;
8531 }
8532
8533 void
8534 mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *mb)
8535 {
8536         ReflectionMethodBuilder rmb;
8537         MonoMethodSignature *sig;
8538         int i;
8539
8540         sig = dynamic_method_to_signature (mb);
8541
8542         reflection_methodbuilder_from_dynamic_method (&rmb, mb);
8543
8544         /*
8545          * Resolve references.
8546          */
8547         rmb.nrefs = mb->nrefs;
8548         rmb.refs = g_new0 (gpointer, mb->nrefs + 1);
8549         for (i = 0; i < mb->nrefs; ++i) {
8550                 gpointer ref = resolve_object (mb->module->image,
8551                                                mono_array_get (mb->refs, MonoObject*, i));
8552                 if (!ref) {
8553                         g_free (rmb.refs);
8554                         mono_raise_exception (mono_get_exception_type_load (NULL));
8555                         return;
8556                 }
8557                 rmb.refs [i] = ref;
8558         }
8559
8560         /* FIXME: class */
8561         mb->mhandle = reflection_methodbuilder_to_mono_method (mono_defaults.object_class, &rmb, sig);
8562
8563         g_free (rmb.refs);
8564
8565         /* ilgen is no longer needed */
8566         mb->ilgen = NULL;
8567 }
8568
8569 /**
8570  * mono_reflection_lookup_dynamic_token:
8571  *
8572  *  Finish the Builder object pointed to by TOKEN and return the corresponding
8573  * runtime structure.
8574  */
8575 gpointer
8576 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token)
8577 {
8578         MonoDynamicImage *assembly = (MonoDynamicImage*)image;
8579         MonoObject *obj;
8580
8581         obj = mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
8582         g_assert (obj);
8583
8584         return resolve_object (image, obj);
8585 }
8586
8587 static gpointer
8588 resolve_object (MonoImage *image, MonoObject *obj)
8589 {
8590         gpointer result = NULL;
8591
8592         if (strcmp (obj->vtable->klass->name, "String") == 0) {
8593                 result = mono_string_intern ((MonoString*)obj);
8594                 g_assert (result);
8595         } else if (strcmp (obj->vtable->klass->name, "MonoType") == 0) {
8596                 MonoReflectionType *tb = (MonoReflectionType*)obj;
8597                 result = mono_class_from_mono_type (tb->type);
8598                 g_assert (result);
8599         } else if (strcmp (obj->vtable->klass->name, "MonoMethod") == 0) {
8600                 result = ((MonoReflectionMethod*)obj)->method;
8601                 g_assert (result);
8602         } else if (strcmp (obj->vtable->klass->name, "MonoCMethod") == 0) {
8603                 result = ((MonoReflectionMethod*)obj)->method;
8604                 g_assert (result);
8605         } else if (strcmp (obj->vtable->klass->name, "MethodBuilder") == 0) {
8606                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)obj;
8607                 result = mb->mhandle;
8608                 if (!result) {
8609                         /* Type is not yet created */
8610                         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type;
8611
8612                         mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
8613
8614                         /*
8615                          * Hopefully this has been filled in by calling CreateType() on the
8616                          * TypeBuilder.
8617                          */
8618                         /**
8619                          * TODO: This won't work if the application finishes another
8620                          * TypeBuilder instance instead of this one.
8621                          */
8622                         result = mb->mhandle;
8623                 }
8624         } else if (strcmp (obj->vtable->klass->name, "ConstructorBuilder") == 0) {
8625                 MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder*)obj;
8626
8627                 result = cb->mhandle;
8628                 if (!result) {
8629                         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)cb->type;
8630
8631                         mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
8632                         result = cb->mhandle;
8633                 }
8634         } else if (strcmp (obj->vtable->klass->name, "MonoField") == 0) {
8635                 result = ((MonoReflectionField*)obj)->field;
8636                 g_assert (result);
8637         } else if (strcmp (obj->vtable->klass->name, "FieldBuilder") == 0) {
8638                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder*)obj;
8639                 result = fb->handle;
8640
8641                 if (!result) {
8642                         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)fb->typeb;
8643
8644                         mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
8645                         result = fb->handle;
8646                 }
8647         } else if (strcmp (obj->vtable->klass->name, "TypeBuilder") == 0) {
8648                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)obj;
8649                 MonoClass *klass;
8650
8651                 klass = tb->type.type->data.klass;
8652                 if (klass->wastypebuilder) {
8653                         /* Already created */
8654                         result = klass;
8655                 }
8656                 else {
8657                         mono_domain_try_type_resolve (mono_domain_get (), NULL, (MonoObject*)tb);
8658                         result = tb->type.type->data.klass;
8659                         g_assert (result);
8660                 }
8661         } else if (strcmp (obj->vtable->klass->name, "SignatureHelper") == 0) {
8662                 MonoReflectionSigHelper *helper = (MonoReflectionSigHelper*)obj;
8663                 MonoMethodSignature *sig;
8664                 int nargs, i;
8665
8666                 if (helper->arguments)
8667                         nargs = mono_array_length (helper->arguments);
8668                 else
8669                         nargs = 0;
8670
8671                 sig = mono_metadata_signature_alloc (image, nargs);
8672                 sig->explicit_this = helper->call_conv & 64;
8673                 sig->hasthis = helper->call_conv & 32;
8674
8675                 if (helper->call_conv == 0) /* unmanaged */
8676                         sig->call_convention = helper->unmanaged_call_conv - 1;
8677                 else
8678                         if (helper->call_conv & 0x02)
8679                                 sig->call_convention = MONO_CALL_VARARG;
8680                 else
8681                         sig->call_convention = MONO_CALL_DEFAULT;
8682
8683                 sig->param_count = nargs;
8684                 /* TODO: Copy type ? */
8685                 sig->ret = helper->return_type->type;
8686                 for (i = 0; i < nargs; ++i) {
8687                         MonoReflectionType *rt = mono_array_get (helper->arguments, MonoReflectionType*, i);
8688                         sig->params [i] = rt->type;
8689                 }
8690
8691                 result = sig;
8692         } else {
8693                 g_print (obj->vtable->klass->name);
8694                 g_assert_not_reached ();
8695         }
8696         return result;
8697 }
8698