mono/metadata/sre-save.c

   1 /*
   2  * sre-save.c: Routine for saving an image to a file.
   3  *
   4  *
   5  * Author:
   6  *   Paolo Molaro (lupus@ximian.com)
   7  *
   8  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   9  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  10  * Copyright 2011 Rodrigo Kumpera
  11  * Copyright 2016 Microsoft
  12  *
  13  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  14  */
  15
  16 #include <config.h>
  17 #include <glib.h>
  18
  19 #include "mono/metadata/dynamic-image-internals.h"
  20 #include "mono/metadata/dynamic-stream-internals.h"
  21 #include "mono/metadata/mono-ptr-array.h"
  22 #include "mono/metadata/object-internals.h"
  23 #include "mono/metadata/sre-internals.h"
  24 #include "mono/metadata/security-manager.h"
  25 #include "mono/metadata/tabledefs.h"
  26 #include "mono/metadata/tokentype.h"
  27 #include "mono/metadata/w32file.h"
  28
  29 #include "mono/utils/checked-build.h"
  30 #include "mono/utils/mono-digest.h"
  31 #include "mono/utils/mono-error-internals.h"
  32
  33 #include "mono/io-layer/io-layer.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 static void    mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly);
  42
  43 static void
  44 alloc_table (MonoDynamicTable *table, guint nrows)
  45 {
  46         mono_dynimage_alloc_table (table, nrows);
  47 }
  48
  49 static guint32
  50 string_heap_insert (MonoDynamicStream *sh, const char *str)
  51 {
  52         return mono_dynstream_insert_string (sh, str);
  53 }
  54
  55 static guint32
  56 string_heap_insert_mstring (MonoDynamicStream *sh, MonoString *str, MonoError *error)
  57 {
  58         return mono_dynstream_insert_mstring (sh, str, error);
  59 }
  60
  61 static guint32
  62 mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
  63 {
  64         return mono_dynstream_add_data (stream, data, len);
  65 }
  66
  67 static guint32
  68 mono_image_add_stream_zero (MonoDynamicStream *stream, guint32 len)
  69 {
  70         return mono_dynstream_add_zero (stream, len);
  71 }
  72
  73 static void
  74 stream_data_align (MonoDynamicStream *stream)
  75 {
  76         mono_dynstream_data_align (stream);
  77 }
  78
  79 static guint32
  80 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type)
  81 {
  82         return mono_dynimage_encode_typedef_or_ref_full (assembly, type, TRUE);
  83 }
  84
  85 static guint32
  86 find_index_in_table (MonoDynamicImage *assembly, int table_idx, int col, guint32 token)
  87 {
  88         MONO_REQ_GC_NEUTRAL_MODE;
  89
  90         int i;
  91         MonoDynamicTable *table;
  92         guint32 *values;
  93
  94         table = &assembly->tables [table_idx];
  95
  96         g_assert (col < table->columns);
  97
  98         values = table->values + table->columns;
  99         for (i = 1; i <= table->rows; ++i) {
 100                 if (values [col] == token)
 101                         return i;
 102                 values += table->columns;
 103         }
 104         return 0;
 105 }
 106
 107 /*
 108  * Copy len * nelem bytes from val to dest, swapping bytes to LE if necessary.
 109  * dest may be misaligned.
 110  */
 111 static void
 112 swap_with_size (char *dest, const char* val, int len, int nelem) {
 113         MONO_REQ_GC_NEUTRAL_MODE;
 114 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 115         int elem;
 116
 117         for (elem = 0; elem < nelem; ++elem) {
 118                 switch (len) {
 119                 case 1:
 120                         *dest = *val;
 121                         break;
 122                 case 2:
 123                         dest [0] = val [1];
 124                         dest [1] = val [0];
 125                         break;
 126                 case 4:
 127                         dest [0] = val [3];
 128                         dest [1] = val [2];
 129                         dest [2] = val [1];
 130                         dest [3] = val [0];
 131                         break;
 132                 case 8:
 133                         dest [0] = val [7];
 134                         dest [1] = val [6];
 135                         dest [2] = val [5];
 136                         dest [3] = val [4];
 137                         dest [4] = val [3];
 138                         dest [5] = val [2];
 139                         dest [6] = val [1];
 140                         dest [7] = val [0];
 141                         break;
 142                 default:
 143                         g_assert_not_reached ();
 144                 }
 145                 dest += len;
 146                 val += len;
 147         }
 148 #else
 149         memcpy (dest, val, len * nelem);
 150 #endif
 151 }
 152
 153 static guint32
 154 add_mono_string_to_blob_cached (MonoDynamicImage *assembly, MonoString *str)
 155 {
 156         MONO_REQ_GC_UNSAFE_MODE;
 157
 158         char blob_size [64];
 159         char *b = blob_size;
 160         guint32 idx = 0, len;
 161
 162         len = str->length * 2;
 163         mono_metadata_encode_value (len, b, &b);
 164 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 165         {
 166                 char *swapped = g_malloc (2 * mono_string_length (str));
 167                 const char *p = (const char*)mono_string_chars (str);
 168
 169                 swap_with_size (swapped, p, 2, mono_string_length (str));
 170                 idx = mono_dynamic_image_add_to_blob_cached (assembly, blob_size, b-blob_size, swapped, len);
 171                 g_free (swapped);
 172         }
 173 #else
 174         idx = mono_dynamic_image_add_to_blob_cached (assembly, blob_size, b-blob_size, (char*)mono_string_chars (str), len);
 175 #endif
 176         return idx;
 177 }
 178
 179 static guint32
 180 image_create_token_raw  (MonoDynamicImage *assembly, MonoObject* obj_raw, gboolean create_methodspec, gboolean register_token, MonoError *error)
 181 {
 182         HANDLE_FUNCTION_ENTER (); /* FIXME callers of image_create_token_raw should use handles */
 183         mono_error_init (error);
 184         MONO_HANDLE_DCL (MonoObject, obj);
 185         guint32 result = mono_image_create_token (assembly, obj, create_methodspec, register_token, error);
 186         HANDLE_FUNCTION_RETURN_VAL (result);
 187 }
 188
 189
 190 /*
 191  * idx is the table index of the object
 192  * type is one of MONO_CUSTOM_ATTR_*
 193  */
 194 static gboolean
 195 mono_image_add_cattrs (MonoDynamicImage *assembly, guint32 idx, guint32 type, MonoArray *cattrs, MonoError *error)
 196 {
 197         MONO_REQ_GC_UNSAFE_MODE;
 198
 199         MonoDynamicTable *table;
 200         MonoReflectionCustomAttr *cattr;
 201         guint32 *values;
 202         guint32 count, i, token;
 203         char blob_size [6];
 204         char *p = blob_size;
 205
 206         mono_error_init (error);
 207
 208         /* it is legal to pass a NULL cattrs: we avoid to use the if in a lot of places */
 209         if (!cattrs)
 210                 return TRUE;
 211         count = mono_array_length (cattrs);
 212         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
 213         table->rows += count;
 214         alloc_table (table, table->rows);
 215         values = table->values + table->next_idx * MONO_CUSTOM_ATTR_SIZE;
 216         idx <<= MONO_CUSTOM_ATTR_BITS;
 217         idx |= type;
 218         for (i = 0; i < count; ++i) {
 219                 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
 220                 values [MONO_CUSTOM_ATTR_PARENT] = idx;
 221                 token = image_create_token_raw (assembly, (MonoObject*)cattr->ctor, FALSE, FALSE, error); /* FIXME use handles */
 222                 if (!mono_error_ok (error)) goto fail;
 223                 type = mono_metadata_token_index (token);
 224                 type <<= MONO_CUSTOM_ATTR_TYPE_BITS;
 225                 switch (mono_metadata_token_table (token)) {
 226                 case MONO_TABLE_METHOD:
 227                         type |= MONO_CUSTOM_ATTR_TYPE_METHODDEF;
 228                         /*
 229                          * fixup_cattrs () needs to fix this up. We can't use image->tokens, since it contains the old token for the
 230                          * method, not the one returned by mono_image_create_token ().
 231                          */
 232                         mono_g_hash_table_insert (assembly->remapped_tokens, GUINT_TO_POINTER (token), cattr->ctor);
 233                         break;
 234                 case MONO_TABLE_MEMBERREF:
 235                         type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
 236                         break;
 237                 default:
 238                         g_warning ("got wrong token in custom attr");
 239                         continue;
 240                 }
 241                 values [MONO_CUSTOM_ATTR_TYPE] = type;
 242                 p = blob_size;
 243                 mono_metadata_encode_value (mono_array_length (cattr->data), p, &p);
 244                 values [MONO_CUSTOM_ATTR_VALUE] = mono_dynamic_image_add_to_blob_cached (assembly, blob_size, p - blob_size,
 245                         mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
 246                 values += MONO_CUSTOM_ATTR_SIZE;
 247                 ++table->next_idx;
 248         }
 249
 250         return TRUE;
 251
 252 fail:
 253         return FALSE;
 254 }
 255
 256 static void
 257 mono_image_add_decl_security (MonoDynamicImage *assembly, guint32 parent_token, MonoArray *permissions)
 258 {
 259         MONO_REQ_GC_UNSAFE_MODE;
 260
 261         MonoDynamicTable *table;
 262         guint32 *values;
 263         guint32 count, i, idx;
 264         MonoReflectionPermissionSet *perm;
 265
 266         if (!permissions)
 267                 return;
 268
 269         count = mono_array_length (permissions);
 270         table = &assembly->tables [MONO_TABLE_DECLSECURITY];
 271         table->rows += count;
 272         alloc_table (table, table->rows);
 273
 274         for (i = 0; i < mono_array_length (permissions); ++i) {
 275                 perm = (MonoReflectionPermissionSet*)mono_array_addr (permissions, MonoReflectionPermissionSet, i);
 276
 277                 values = table->values + table->next_idx * MONO_DECL_SECURITY_SIZE;
 278
 279                 idx = mono_metadata_token_index (parent_token);
 280                 idx <<= MONO_HAS_DECL_SECURITY_BITS;
 281                 switch (mono_metadata_token_table (parent_token)) {
 282                 case MONO_TABLE_TYPEDEF:
 283                         idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
 284                         break;
 285                 case MONO_TABLE_METHOD:
 286                         idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
 287                         break;
 288                 case MONO_TABLE_ASSEMBLY:
 289                         idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
 290                         break;
 291                 default:
 292                         g_assert_not_reached ();
 293                 }
 294
 295                 values [MONO_DECL_SECURITY_ACTION] = perm->action;
 296                 values [MONO_DECL_SECURITY_PARENT] = idx;
 297                 values [MONO_DECL_SECURITY_PERMISSIONSET] = add_mono_string_to_blob_cached (assembly, perm->pset);
 298
 299                 ++table->next_idx;
 300         }
 301 }
 302
 303 /**
 304  * method_encode_code:
 305  *
 306  * @assembly the assembly
 307  * @mb the managed MethodBuilder
 308  * @error set on error
 309  *
 310  * Note that the return value is not sensible if @error is set.
 311  */
 312 static guint32
 313 method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb, MonoError *error)
 314 {
 315         MONO_REQ_GC_UNSAFE_MODE;
 316
 317         char flags = 0;
 318         guint32 idx;
 319         guint32 code_size;
 320         gint32 max_stack, i;
 321         gint32 num_locals = 0;
 322         gint32 num_exception = 0;
 323         gint maybe_small;
 324         guint32 fat_flags;
 325         char fat_header [12];
 326         guint32 int_value;
 327         guint16 short_value;
 328         guint32 local_sig = 0;
 329         guint32 header_size = 12;
 330         MonoArray *code;
 331
 332         mono_error_init (error);
 333
 334         if ((mb->attrs & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT)) ||
 335                         (mb->iattrs & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)))
 336                 return 0;
 337
 338         /*if (mb->name)
 339                 g_print ("Encode method %s\n", mono_string_to_utf8 (mb->name));*/
 340         if (mb->ilgen) {
 341                 code = mb->ilgen->code;
 342                 code_size = mb->ilgen->code_len;
 343                 max_stack = mb->ilgen->max_stack;
 344                 num_locals = mb->ilgen->locals ? mono_array_length (mb->ilgen->locals) : 0;
 345                 if (mb->ilgen->ex_handlers)
 346                         num_exception = mono_reflection_method_count_clauses (mb->ilgen);
 347         } else {
 348                 code = mb->code;
 349                 if (code == NULL){
 350                         MonoError inner_error;
 351                         char *name = mono_string_to_utf8_checked (mb->name, &inner_error);
 352                         if (!is_ok (&inner_error)) {
 353                                 name = g_strdup ("");
 354                                 mono_error_cleanup (&inner_error);
 355                         }
 356                         char *str = g_strdup_printf ("Method %s does not have any IL associated", name);
 357                         mono_error_set_argument (error, NULL, "a method does not have any IL associated");
 358                         g_free (str);
 359                         g_free (name);
 360                         return 0;
 361                 }
 362
 363                 code_size = mono_array_length (code);
 364                 max_stack = 8; /* we probably need to run a verifier on the code... */
 365         }
 366
 367         stream_data_align (&assembly->code);
 368
 369         /* check for exceptions, maxstack, locals */
 370         maybe_small = (max_stack <= 8) && (!num_locals) && (!num_exception);
 371         if (maybe_small) {
 372                 if (code_size < 64 && !(code_size & 1)) {
 373                         flags = (code_size << 2) | 0x2;
 374                 } else if (code_size < 32 && (code_size & 1)) {
 375                         flags = (code_size << 2) | 0x6; /* LAMESPEC: see metadata.c */
 376                 } else {
 377                         goto fat_header;
 378                 }
 379                 idx = mono_image_add_stream_data (&assembly->code, &flags, 1);
 380                 /* add to the fixup todo list */
 381                 if (mb->ilgen && mb->ilgen->num_token_fixups)
 382                         mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 1));
 383                 mono_image_add_stream_data (&assembly->code, mono_array_addr (code, char, 0), code_size);
 384                 return assembly->text_rva + idx;
 385         }
 386 fat_header:
 387         if (num_locals) {
 388                 local_sig = MONO_TOKEN_SIGNATURE | mono_dynimage_encode_locals (assembly, mb->ilgen, error);
 389                 return_val_if_nok (error, 0);
 390         }
 391         /*
 392          * FIXME: need to set also the header size in fat_flags.
 393          * (and more sects and init locals flags)
 394          */
 395         fat_flags =  0x03;
 396         if (num_exception)
 397                 fat_flags |= METHOD_HEADER_MORE_SECTS;
 398         if (mb->init_locals)
 399                 fat_flags |= METHOD_HEADER_INIT_LOCALS;
 400         fat_header [0] = fat_flags;
 401         fat_header [1] = (header_size / 4 ) << 4;
 402         short_value = GUINT16_TO_LE (max_stack);
 403         memcpy (fat_header + 2, &short_value, 2);
 404         int_value = GUINT32_TO_LE (code_size);
 405         memcpy (fat_header + 4, &int_value, 4);
 406         int_value = GUINT32_TO_LE (local_sig);
 407         memcpy (fat_header + 8, &int_value, 4);
 408         idx = mono_image_add_stream_data (&assembly->code, fat_header, 12);
 409         /* add to the fixup todo list */
 410         if (mb->ilgen && mb->ilgen->num_token_fixups)
 411                 mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 12));
 412
 413         mono_image_add_stream_data (&assembly->code, mono_array_addr (code, char, 0), code_size);
 414         if (num_exception) {
 415                 unsigned char sheader [4];
 416                 MonoILExceptionInfo * ex_info;
 417                 MonoILExceptionBlock * ex_block;
 418                 int j;
 419
 420                 stream_data_align (&assembly->code);
 421                 /* always use fat format for now */
 422                 sheader [0] = METHOD_HEADER_SECTION_FAT_FORMAT | METHOD_HEADER_SECTION_EHTABLE;
 423                 num_exception *= 6 * sizeof (guint32);
 424                 num_exception += 4; /* include the size of the header */
 425                 sheader [1] = num_exception & 0xff;
 426                 sheader [2] = (num_exception >> 8) & 0xff;
 427                 sheader [3] = (num_exception >> 16) & 0xff;
 428                 mono_image_add_stream_data (&assembly->code, (char*)sheader, 4);
 429                 /* fat header, so we are already aligned */
 430                 /* reverse order */
 431                 for (i = mono_array_length (mb->ilgen->ex_handlers) - 1; i >= 0; --i) {
 432                         ex_info = (MonoILExceptionInfo *)mono_array_addr (mb->ilgen->ex_handlers, MonoILExceptionInfo, i);
 433                         if (ex_info->handlers) {
 434                                 int finally_start = ex_info->start + ex_info->len;
 435                                 for (j = 0; j < mono_array_length (ex_info->handlers); ++j) {
 436                                         guint32 val;
 437                                         ex_block = (MonoILExceptionBlock*)mono_array_addr (ex_info->handlers, MonoILExceptionBlock, j);
 438                                         /* the flags */
 439                                         val = GUINT32_TO_LE (ex_block->type);
 440                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
 441                                         /* try offset */
 442                                         val = GUINT32_TO_LE (ex_info->start);
 443                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
 444                                         /* need fault, too, probably */
 445                                         if (ex_block->type == MONO_EXCEPTION_CLAUSE_FINALLY)
 446                                                 val = GUINT32_TO_LE (finally_start - ex_info->start);
 447                                         else
 448                                                 val = GUINT32_TO_LE (ex_info->len);
 449                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
 450                                         /* handler offset */
 451                                         val = GUINT32_TO_LE (ex_block->start);
 452                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
 453                                         /* handler len */
 454                                         val = GUINT32_TO_LE (ex_block->len);
 455                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
 456                                         finally_start = ex_block->start + ex_block->len;
 457                                         if (ex_block->extype) {
 458                                                 MonoType *extype = mono_reflection_type_get_handle ((MonoReflectionType*)ex_block->extype, error);
 459                                                 return_val_if_nok (error, 0);
 460
 461                                                 val = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, extype));
 462                                         } else {
 463                                                 if (ex_block->type == MONO_EXCEPTION_CLAUSE_FILTER)
 464                                                         val = ex_block->filter_offset;
 465                                                 else
 466                                                         val = 0;
 467                                         }
 468                                         val = GUINT32_TO_LE (val);
 469                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
 470                                         /*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",
 471                                                         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);*/
 472                                 }
 473                         } else {
 474                                 g_error ("No clauses for ex info block %d", i);
 475                         }
 476                 }
 477         }
 478         return assembly->text_rva + idx;
 479 }
 480
 481 /*
 482  * Fill in the MethodDef and ParamDef tables for a method.
 483  * This is used for both normal methods and constructors.
 484  */
 485 static gboolean
 486 mono_image_basic_method (ReflectionMethodBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
 487 {
 488         MONO_REQ_GC_UNSAFE_MODE;
 489
 490         MonoDynamicTable *table;
 491         guint32 *values;
 492         guint i, count;
 493
 494         mono_error_init (error);
 495
 496         /* room in this table is already allocated */
 497         table = &assembly->tables [MONO_TABLE_METHOD];
 498         *mb->table_idx = table->next_idx ++;
 499         g_hash_table_insert (assembly->method_to_table_idx, mb->mhandle, GUINT_TO_POINTER ((*mb->table_idx)));
 500         values = table->values + *mb->table_idx * MONO_METHOD_SIZE;
 501         values [MONO_METHOD_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name, error);
 502         return_val_if_nok (error, FALSE);
 503         values [MONO_METHOD_FLAGS] = mb->attrs;
 504         values [MONO_METHOD_IMPLFLAGS] = mb->iattrs;
 505         values [MONO_METHOD_SIGNATURE] = mono_dynimage_encode_method_builder_signature (assembly, mb, error);
 506         return_val_if_nok (error, FALSE);
 507         values [MONO_METHOD_RVA] = method_encode_code (assembly, mb, error);
 508         return_val_if_nok (error, FALSE);
 509
 510         table = &assembly->tables [MONO_TABLE_PARAM];
 511         values [MONO_METHOD_PARAMLIST] = table->next_idx;
 512
 513         mono_image_add_decl_security (assembly,
 514                 mono_metadata_make_token (MONO_TABLE_METHOD, *mb->table_idx), mb->permissions);
 515
 516         if (mb->pinfo) {
 517                 MonoDynamicTable *mtable;
 518                 guint32 *mvalues;
 519
 520                 mtable = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
 521                 mvalues = mtable->values + mtable->next_idx * MONO_FIELD_MARSHAL_SIZE;
 522
 523                 count = 0;
 524                 for (i = 0; i < mono_array_length (mb->pinfo); ++i) {
 525                         if (mono_array_get (mb->pinfo, gpointer, i))
 526                                 count++;
 527                 }
 528                 table->rows += count;
 529                 alloc_table (table, table->rows);
 530                 values = table->values + table->next_idx * MONO_PARAM_SIZE;
 531                 for (i = 0; i < mono_array_length (mb->pinfo); ++i) {
 532                         MonoReflectionParamBuilder *pb;
 533                         if ((pb = mono_array_get (mb->pinfo, MonoReflectionParamBuilder*, i))) {
 534                                 values [MONO_PARAM_FLAGS] = pb->attrs;
 535                                 values [MONO_PARAM_SEQUENCE] = i;
 536                                 if (pb->name != NULL) {
 537                                         values [MONO_PARAM_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name, error);
 538                                         return_val_if_nok (error, FALSE);
 539                                 } else {
 540                                         values [MONO_PARAM_NAME] = 0;
 541                                 }
 542                                 values += MONO_PARAM_SIZE;
 543                                 if (pb->marshal_info) {
 544                                         mtable->rows++;
 545                                         alloc_table (mtable, mtable->rows);
 546                                         mvalues = mtable->values + mtable->rows * MONO_FIELD_MARSHAL_SIZE;
 547                                         mvalues [MONO_FIELD_MARSHAL_PARENT] = (table->next_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_PARAMDEF;
 548                                         mvalues [MONO_FIELD_MARSHAL_NATIVE_TYPE] = mono_dynimage_save_encode_marshal_blob (assembly, pb->marshal_info, error);
 549                                         return_val_if_nok (error, FALSE);
 550                                 }
 551                                 pb->table_idx = table->next_idx++;
 552                                 if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
 553                                         guint32 field_type = 0;
 554                                         mtable = &assembly->tables [MONO_TABLE_CONSTANT];
 555                                         mtable->rows ++;
 556                                         alloc_table (mtable, mtable->rows);
 557                                         mvalues = mtable->values + mtable->rows * MONO_CONSTANT_SIZE;
 558                                         mvalues [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_PARAM | (pb->table_idx << MONO_HASCONSTANT_BITS);
 559                                         mvalues [MONO_CONSTANT_VALUE] = mono_dynimage_encode_constant (assembly, pb->def_value, &field_type);
 560                                         mvalues [MONO_CONSTANT_TYPE] = field_type;
 561                                         mvalues [MONO_CONSTANT_PADDING] = 0;
 562                                 }
 563                         }
 564                 }
 565         }
 566
 567         return TRUE;
 568 }
 569
 570 static gboolean
 571 mono_image_add_methodimpl (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, MonoError *error)
 572 {
 573         MONO_REQ_GC_UNSAFE_MODE;
 574
 575         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mb->type;
 576         MonoDynamicTable *table;
 577         guint32 *values;
 578         guint32 tok;
 579         MonoReflectionMethod *m;
 580         int i;
 581
 582         mono_error_init (error);
 583
 584         if (!mb->override_methods)
 585                 return TRUE;
 586
 587         for (i = 0; i < mono_array_length (mb->override_methods); ++i) {
 588                 m = mono_array_get (mb->override_methods, MonoReflectionMethod*, i);
 589
 590                 table = &assembly->tables [MONO_TABLE_METHODIMPL];
 591                 table->rows ++;
 592                 alloc_table (table, table->rows);
 593                 values = table->values + table->rows * MONO_METHODIMPL_SIZE;
 594                 values [MONO_METHODIMPL_CLASS] = tb->table_idx;
 595                 values [MONO_METHODIMPL_BODY] = MONO_METHODDEFORREF_METHODDEF | (mb->table_idx << MONO_METHODDEFORREF_BITS);
 596
 597                 tok = image_create_token_raw (assembly, (MonoObject*)m, FALSE, FALSE, error); /* FIXME use handles */
 598                 return_val_if_nok (error, FALSE);
 599
 600                 switch (mono_metadata_token_table (tok)) {
 601                 case MONO_TABLE_MEMBERREF:
 602                         tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODREF;
 603                         break;
 604                 case MONO_TABLE_METHOD:
 605                         tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODDEF;
 606                         break;
 607                 default:
 608                         g_assert_not_reached ();
 609                 }
 610                 values [MONO_METHODIMPL_DECLARATION] = tok;
 611         }
 612
 613         return TRUE;
 614 }
 615
 616 #ifndef DISABLE_REFLECTION_EMIT
 617 static gboolean
 618 mono_image_get_method_info (MonoReflectionMethodBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
 619 {
 620         MONO_REQ_GC_UNSAFE_MODE;
 621
 622         MonoDynamicTable *table;
 623         guint32 *values;
 624         ReflectionMethodBuilder rmb;
 625         int i;
 626
 627         mono_error_init (error);
 628
 629         if (!mono_reflection_methodbuilder_from_method_builder (&rmb, mb, error) ||
 630             !mono_image_basic_method (&rmb, assembly, error))
 631                 return FALSE;
 632
 633         mb->table_idx = *rmb.table_idx;
 634
 635         if (mb->dll) { /* It's a P/Invoke method */
 636                 guint32 moduleref;
 637                 /* map CharSet values to on-disk values */
 638                 int ncharset = (mb->charset ? (mb->charset - 1) * 2 : 0);
 639                 int extra_flags = mb->extra_flags;
 640                 table = &assembly->tables [MONO_TABLE_IMPLMAP];
 641                 table->rows ++;
 642                 alloc_table (table, table->rows);
 643                 values = table->values + table->rows * MONO_IMPLMAP_SIZE;
 644
 645                 values [MONO_IMPLMAP_FLAGS] = (mb->native_cc << 8) | ncharset | extra_flags;
 646                 values [MONO_IMPLMAP_MEMBER] = (mb->table_idx << 1) | 1; /* memberforwarded: method */
 647                 if (mb->dllentry) {
 648                         values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->dllentry, error);
 649                         return_val_if_nok (error, FALSE);
 650                 } else {
 651                         values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name, error);
 652                         return_val_if_nok (error, FALSE);
 653                 }
 654                 moduleref = string_heap_insert_mstring (&assembly->sheap, mb->dll, error);
 655                 return_val_if_nok (error, FALSE);
 656                 if (!(values [MONO_IMPLMAP_SCOPE] = find_index_in_table (assembly, MONO_TABLE_MODULEREF, MONO_MODULEREF_NAME, moduleref))) {
 657                         table = &assembly->tables [MONO_TABLE_MODULEREF];
 658                         table->rows ++;
 659                         alloc_table (table, table->rows);
 660                         table->values [table->rows * MONO_MODULEREF_SIZE + MONO_MODULEREF_NAME] = moduleref;
 661                         values [MONO_IMPLMAP_SCOPE] = table->rows;
 662                 }
 663         }
 664
 665         if (mb->generic_params) {
 666                 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
 667                 table->rows += mono_array_length (mb->generic_params);
 668                 alloc_table (table, table->rows);
 669                 for (i = 0; i < mono_array_length (mb->generic_params); ++i) {
 670                         guint32 owner = MONO_TYPEORMETHOD_METHOD | (mb->table_idx << MONO_TYPEORMETHOD_BITS);
 671
 672                         mono_image_get_generic_param_info (
 673                                 (MonoReflectionGenericParam *)mono_array_get (mb->generic_params, gpointer, i), owner, assembly);
 674                 }
 675         }
 676
 677         return TRUE;
 678 }
 679
 680 static gboolean
 681 mono_image_get_ctor_info (MonoDomain *domain, MonoReflectionCtorBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
 682 {
 683         MONO_REQ_GC_UNSAFE_MODE;
 684
 685         ReflectionMethodBuilder rmb;
 686
 687         if (!mono_reflection_methodbuilder_from_ctor_builder (&rmb, mb, error))
 688                 return FALSE;
 689
 690         if (!mono_image_basic_method (&rmb, assembly, error))
 691                 return FALSE;
 692
 693         mb->table_idx = *rmb.table_idx;
 694
 695         return TRUE;
 696 }
 697 #endif
 698
 699 static void
 700 mono_image_get_field_info (MonoReflectionFieldBuilder *fb, MonoDynamicImage *assembly, MonoError *error)
 701 {
 702         MONO_REQ_GC_UNSAFE_MODE;
 703
 704         mono_error_init (error);
 705
 706         MonoDynamicTable *table;
 707         guint32 *values;
 708
 709         /* maybe this fixup should be done in the C# code */
 710         if (fb->attrs & FIELD_ATTRIBUTE_LITERAL)
 711                 fb->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
 712         table = &assembly->tables [MONO_TABLE_FIELD];
 713         fb->table_idx = table->next_idx ++;
 714         g_hash_table_insert (assembly->field_to_table_idx, fb->handle, GUINT_TO_POINTER (fb->table_idx));
 715         values = table->values + fb->table_idx * MONO_FIELD_SIZE;
 716         values [MONO_FIELD_NAME] = string_heap_insert_mstring (&assembly->sheap, fb->name, error);
 717         return_if_nok (error);
 718         values [MONO_FIELD_FLAGS] = fb->attrs;
 719         values [MONO_FIELD_SIGNATURE] = mono_dynimage_encode_field_signature (assembly, fb, error);
 720         return_if_nok (error);
 721
 722         if (fb->offset != -1) {
 723                 table = &assembly->tables [MONO_TABLE_FIELDLAYOUT];
 724                 table->rows ++;
 725                 alloc_table (table, table->rows);
 726                 values = table->values + table->rows * MONO_FIELD_LAYOUT_SIZE;
 727                 values [MONO_FIELD_LAYOUT_FIELD] = fb->table_idx;
 728                 values [MONO_FIELD_LAYOUT_OFFSET] = fb->offset;
 729         }
 730         if (fb->attrs & FIELD_ATTRIBUTE_LITERAL) {
 731                 MonoTypeEnum field_type = (MonoTypeEnum)0;
 732                 table = &assembly->tables [MONO_TABLE_CONSTANT];
 733                 table->rows ++;
 734                 alloc_table (table, table->rows);
 735                 values = table->values + table->rows * MONO_CONSTANT_SIZE;
 736                 values [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_FIEDDEF | (fb->table_idx << MONO_HASCONSTANT_BITS);
 737                 values [MONO_CONSTANT_VALUE] = mono_dynimage_encode_constant (assembly, fb->def_value, &field_type);
 738                 values [MONO_CONSTANT_TYPE] = field_type;
 739                 values [MONO_CONSTANT_PADDING] = 0;
 740         }
 741         if (fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) {
 742                 guint32 rva_idx;
 743                 table = &assembly->tables [MONO_TABLE_FIELDRVA];
 744                 table->rows ++;
 745                 alloc_table (table, table->rows);
 746                 values = table->values + table->rows * MONO_FIELD_RVA_SIZE;
 747                 values [MONO_FIELD_RVA_FIELD] = fb->table_idx;
 748                 /*
 749                  * We store it in the code section because it's simpler for now.
 750                  */
 751                 if (fb->rva_data) {
 752                         if (mono_array_length (fb->rva_data) >= 10)
 753                                 stream_data_align (&assembly->code);
 754                         rva_idx = mono_image_add_stream_data (&assembly->code, mono_array_addr (fb->rva_data, char, 0), mono_array_length (fb->rva_data));
 755                 } else
 756                         rva_idx = mono_image_add_stream_zero (&assembly->code, mono_class_value_size (fb->handle->parent, NULL));
 757                 values [MONO_FIELD_RVA_RVA] = rva_idx + assembly->text_rva;
 758         }
 759         if (fb->marshal_info) {
 760                 table = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
 761                 table->rows ++;
 762                 alloc_table (table, table->rows);
 763                 values = table->values + table->rows * MONO_FIELD_MARSHAL_SIZE;
 764                 values [MONO_FIELD_MARSHAL_PARENT] = (fb->table_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_FIELDSREF;
 765                 values [MONO_FIELD_MARSHAL_NATIVE_TYPE] = mono_dynimage_save_encode_marshal_blob (assembly, fb->marshal_info, error);
 766                 return_if_nok (error);
 767         }
 768 }
 769
 770 static void
 771 mono_image_get_property_info (MonoReflectionPropertyBuilder *pb, MonoDynamicImage *assembly, MonoError *error)
 772 {
 773         MONO_REQ_GC_UNSAFE_MODE;
 774
 775         mono_error_init (error);
 776
 777         MonoDynamicTable *table;
 778         guint32 *values;
 779         guint num_methods = 0;
 780         guint32 semaidx;
 781
 782         /*
 783          * we need to set things in the following tables:
 784          * PROPERTYMAP (info already filled in _get_type_info ())
 785          * PROPERTY    (rows already preallocated in _get_type_info ())
 786          * METHOD      (method info already done with the generic method code)
 787          * METHODSEMANTICS
 788          * CONSTANT
 789          */
 790         table = &assembly->tables [MONO_TABLE_PROPERTY];
 791         pb->table_idx = table->next_idx ++;
 792         values = table->values + pb->table_idx * MONO_PROPERTY_SIZE;
 793         values [MONO_PROPERTY_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name, error);
 794         return_if_nok (error);
 795         values [MONO_PROPERTY_FLAGS] = pb->attrs;
 796         values [MONO_PROPERTY_TYPE] = mono_dynimage_save_encode_property_signature (assembly, pb, error);
 797         return_if_nok (error);
 798
 799
 800         /* FIXME: we still don't handle 'other' methods */
 801         if (pb->get_method) num_methods ++;
 802         if (pb->set_method) num_methods ++;
 803
 804         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
 805         table->rows += num_methods;
 806         alloc_table (table, table->rows);
 807
 808         if (pb->get_method) {
 809                 semaidx = table->next_idx ++;
 810                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
 811                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_GETTER;
 812                 values [MONO_METHOD_SEMA_METHOD] = pb->get_method->table_idx;
 813                 values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
 814         }
 815         if (pb->set_method) {
 816                 semaidx = table->next_idx ++;
 817                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
 818                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_SETTER;
 819                 values [MONO_METHOD_SEMA_METHOD] = pb->set_method->table_idx;
 820                 values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
 821         }
 822         if (pb->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT) {
 823                 MonoTypeEnum field_type = (MonoTypeEnum)0;
 824                 table = &assembly->tables [MONO_TABLE_CONSTANT];
 825                 table->rows ++;
 826                 alloc_table (table, table->rows);
 827                 values = table->values + table->rows * MONO_CONSTANT_SIZE;
 828                 values [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_PROPERTY | (pb->table_idx << MONO_HASCONSTANT_BITS);
 829                 values [MONO_CONSTANT_VALUE] = mono_dynimage_encode_constant (assembly, pb->def_value, &field_type);
 830                 values [MONO_CONSTANT_TYPE] = field_type;
 831                 values [MONO_CONSTANT_PADDING] = 0;
 832         }
 833 }
 834
 835 static void
 836 mono_image_get_event_info (MonoReflectionEventBuilder *eb, MonoDynamicImage *assembly, MonoError *error)
 837 {
 838         MONO_REQ_GC_UNSAFE_MODE;
 839
 840         MonoDynamicTable *table;
 841         guint32 *values;
 842         guint num_methods = 0;
 843         guint32 semaidx;
 844
 845         /*
 846          * we need to set things in the following tables:
 847          * EVENTMAP (info already filled in _get_type_info ())
 848          * EVENT    (rows already preallocated in _get_type_info ())
 849          * METHOD      (method info already done with the generic method code)
 850          * METHODSEMANTICS
 851          */
 852         table = &assembly->tables [MONO_TABLE_EVENT];
 853         eb->table_idx = table->next_idx ++;
 854         values = table->values + eb->table_idx * MONO_EVENT_SIZE;
 855         values [MONO_EVENT_NAME] = string_heap_insert_mstring (&assembly->sheap, eb->name, error);
 856         return_if_nok (error);
 857         values [MONO_EVENT_FLAGS] = eb->attrs;
 858         MonoType *ebtype = mono_reflection_type_get_handle (eb->type, error);
 859         return_if_nok (error);
 860         values [MONO_EVENT_TYPE] = mono_image_typedef_or_ref (assembly, ebtype);
 861
 862         /*
 863          * FIXME: we still don't handle 'other' methods
 864          */
 865         if (eb->add_method) num_methods ++;
 866         if (eb->remove_method) num_methods ++;
 867         if (eb->raise_method) num_methods ++;
 868
 869         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
 870         table->rows += num_methods;
 871         alloc_table (table, table->rows);
 872
 873         if (eb->add_method) {
 874                 semaidx = table->next_idx ++;
 875                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
 876                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_ADD_ON;
 877                 values [MONO_METHOD_SEMA_METHOD] = eb->add_method->table_idx;
 878                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
 879         }
 880         if (eb->remove_method) {
 881                 semaidx = table->next_idx ++;
 882                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
 883                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_REMOVE_ON;
 884                 values [MONO_METHOD_SEMA_METHOD] = eb->remove_method->table_idx;
 885                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
 886         }
 887         if (eb->raise_method) {
 888                 semaidx = table->next_idx ++;
 889                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
 890                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_FIRE;
 891                 values [MONO_METHOD_SEMA_METHOD] = eb->raise_method->table_idx;
 892                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
 893         }
 894 }
 895
 896 static void
 897 encode_constraints (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly, MonoError *error)
 898 {
 899         MONO_REQ_GC_UNSAFE_MODE;
 900
 901         mono_error_init (error);
 902
 903         MonoDynamicTable *table;
 904         guint32 num_constraints, i;
 905         guint32 *values;
 906         guint32 table_idx;
 907
 908         table = &assembly->tables [MONO_TABLE_GENERICPARAMCONSTRAINT];
 909         num_constraints = gparam->iface_constraints ?
 910                 mono_array_length (gparam->iface_constraints) : 0;
 911         table->rows += num_constraints;
 912         if (gparam->base_type)
 913                 table->rows++;
 914         alloc_table (table, table->rows);
 915
 916         if (gparam->base_type) {
 917                 table_idx = table->next_idx ++;
 918                 values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE;
 919
 920                 MonoType *gpbasetype = mono_reflection_type_get_handle (gparam->base_type, error);
 921                 return_if_nok (error);
 922                 values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner;
 923                 values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (assembly, gpbasetype);
 924         }
 925
 926         for (i = 0; i < num_constraints; i++) {
 927                 MonoReflectionType *constraint = (MonoReflectionType *)mono_array_get (
 928                         gparam->iface_constraints, gpointer, i);
 929
 930                 table_idx = table->next_idx ++;
 931                 values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE;
 932
 933                 MonoType *constraint_type = mono_reflection_type_get_handle (constraint, error);
 934                 return_if_nok (error);
 935
 936                 values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner;
 937                 values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (assembly, constraint_type);
 938         }
 939 }
 940
 941 static void
 942 mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly)
 943 {
 944         MONO_REQ_GC_UNSAFE_MODE;
 945
 946         GenericParamTableEntry *entry;
 947
 948         /*
 949          * The GenericParam table must be sorted according to the `owner' field.
 950          * We need to do this sorting prior to writing the GenericParamConstraint
 951          * table, since we have to use the final GenericParam table indices there
 952          * and they must also be sorted.
 953          */
 954
 955         entry = g_new0 (GenericParamTableEntry, 1);
 956         entry->owner = owner;
 957         /* FIXME: track where gen_params should be freed and remove the GC root as well */
 958         MONO_GC_REGISTER_ROOT_IF_MOVING (entry->gparam, MONO_ROOT_SOURCE_REFLECTION, "reflection generic parameter");
 959         entry->gparam = gparam;
 960
 961         g_ptr_array_add (assembly->gen_params, entry);
 962 }
 963
 964 static gboolean
 965 write_generic_param_entry (MonoDynamicImage *assembly, GenericParamTableEntry *entry, MonoError *error)
 966 {
 967         MONO_REQ_GC_UNSAFE_MODE;
 968
 969         MonoDynamicTable *table;
 970         MonoGenericParam *param;
 971         guint32 *values;
 972         guint32 table_idx;
 973
 974         mono_error_init (error);
 975
 976         table = &assembly->tables [MONO_TABLE_GENERICPARAM];
 977         table_idx = table->next_idx ++;
 978         values = table->values + table_idx * MONO_GENERICPARAM_SIZE;
 979
 980         MonoType *gparam_type = mono_reflection_type_get_handle ((MonoReflectionType*)entry->gparam, error);
 981         return_val_if_nok (error, FALSE);
 982
 983         param = gparam_type->data.generic_param;
 984
 985         values [MONO_GENERICPARAM_OWNER] = entry->owner;
 986         values [MONO_GENERICPARAM_FLAGS] = entry->gparam->attrs;
 987         values [MONO_GENERICPARAM_NUMBER] = mono_generic_param_num (param);
 988         values [MONO_GENERICPARAM_NAME] = string_heap_insert (&assembly->sheap, mono_generic_param_info (param)->name);
 989
 990         if (!mono_image_add_cattrs (assembly, table_idx, MONO_CUSTOM_ATTR_GENERICPAR, entry->gparam->cattrs, error))
 991                 return FALSE;
 992
 993         encode_constraints (entry->gparam, table_idx, assembly, error);
 994         return_val_if_nok (error, FALSE);
 995
 996         return TRUE;
 997 }
 998
 999 static void
1000 collect_types (MonoPtrArray *types, MonoReflectionTypeBuilder *type)
1001 {
1002         int i;
1003
1004         mono_ptr_array_append (*types, type);
1005
1006         if (!type->subtypes)
1007                 return;
1008
1009         for (i = 0; i < mono_array_length (type->subtypes); ++i) {
1010                 MonoReflectionTypeBuilder *subtype = mono_array_get (type->subtypes, MonoReflectionTypeBuilder*, i);
1011                 collect_types (types, subtype);
1012         }
1013 }
1014
1015 static gint
1016 compare_types_by_table_idx (MonoReflectionTypeBuilder **type1, MonoReflectionTypeBuilder **type2)
1017 {
1018         if ((*type1)->table_idx < (*type2)->table_idx)
1019                 return -1;
1020         else
1021                 if ((*type1)->table_idx > (*type2)->table_idx)
1022                         return 1;
1023         else
1024                 return 0;
1025 }
1026
1027 static gboolean
1028 params_add_cattrs (MonoDynamicImage *assembly, MonoArray *pinfo, MonoError *error) {
1029         int i;
1030
1031         mono_error_init (error);
1032         if (!pinfo)
1033                 return TRUE;
1034         for (i = 0; i < mono_array_length (pinfo); ++i) {
1035                 MonoReflectionParamBuilder *pb;
1036                 pb = mono_array_get (pinfo, MonoReflectionParamBuilder *, i);
1037                 if (!pb)
1038                         continue;
1039                 if (!mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PARAMDEF, pb->cattrs, error))
1040                         return FALSE;
1041         }
1042
1043         return TRUE;
1044 }
1045
1046 static gboolean
1047 type_add_cattrs (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb, MonoError *error) {
1048         int i;
1049
1050         mono_error_init (error);
1051
1052         if (!mono_image_add_cattrs (assembly, tb->table_idx, MONO_CUSTOM_ATTR_TYPEDEF, tb->cattrs, error))
1053                 return FALSE;
1054         if (tb->fields) {
1055                 for (i = 0; i < tb->num_fields; ++i) {
1056                         MonoReflectionFieldBuilder* fb;
1057                         fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i);
1058                         if (!mono_image_add_cattrs (assembly, fb->table_idx, MONO_CUSTOM_ATTR_FIELDDEF, fb->cattrs, error))
1059                                 return FALSE;
1060                 }
1061         }
1062         if (tb->events) {
1063                 for (i = 0; i < mono_array_length (tb->events); ++i) {
1064                         MonoReflectionEventBuilder* eb;
1065                         eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
1066                         if (!mono_image_add_cattrs (assembly, eb->table_idx, MONO_CUSTOM_ATTR_EVENT, eb->cattrs, error))
1067                                 return FALSE;
1068                 }
1069         }
1070         if (tb->properties) {
1071                 for (i = 0; i < mono_array_length (tb->properties); ++i) {
1072                         MonoReflectionPropertyBuilder* pb;
1073                         pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
1074                         if (!mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PROPERTY, pb->cattrs, error))
1075                                 return FALSE;
1076                 }
1077         }
1078         if (tb->ctors) {
1079                 for (i = 0; i < mono_array_length (tb->ctors); ++i) {
1080                         MonoReflectionCtorBuilder* cb;
1081                         cb = mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i);
1082                         if (!mono_image_add_cattrs (assembly, cb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, cb->cattrs, error) ||
1083                             !params_add_cattrs (assembly, cb->pinfo, error))
1084                                 return FALSE;
1085                 }
1086         }
1087
1088         if (tb->methods) {
1089                 for (i = 0; i < tb->num_methods; ++i) {
1090                         MonoReflectionMethodBuilder* mb;
1091                         mb = mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
1092                         if (!mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, mb->cattrs, error) ||
1093                             !params_add_cattrs (assembly, mb->pinfo, error))
1094                                 return FALSE;
1095                 }
1096         }
1097
1098         if (tb->subtypes) {
1099                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
1100                         if (!type_add_cattrs (assembly, mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i), error))
1101                                 return FALSE;
1102                 }
1103         }
1104
1105         return TRUE;
1106 }
1107
1108 static gboolean
1109 module_add_cattrs (MonoDynamicImage *assembly, MonoReflectionModuleBuilder *moduleb, MonoError *error)
1110 {
1111         int i;
1112
1113         mono_error_init (error);
1114
1115         if (!mono_image_add_cattrs (assembly, moduleb->table_idx, MONO_CUSTOM_ATTR_MODULE, moduleb->cattrs, error))
1116                 return FALSE;
1117
1118         if (moduleb->global_methods) {
1119                 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
1120                         MonoReflectionMethodBuilder* mb = mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i);
1121                         if (!mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, mb->cattrs, error) ||
1122                             !params_add_cattrs (assembly, mb->pinfo, error))
1123                                 return FALSE;
1124                 }
1125         }
1126
1127         if (moduleb->global_fields) {
1128                 for (i = 0; i < mono_array_length (moduleb->global_fields); ++i) {
1129                         MonoReflectionFieldBuilder *fb = mono_array_get (moduleb->global_fields, MonoReflectionFieldBuilder*, i);
1130                         if (!mono_image_add_cattrs (assembly, fb->table_idx, MONO_CUSTOM_ATTR_FIELDDEF, fb->cattrs, error))
1131                                 return FALSE;
1132                 }
1133         }
1134
1135         if (moduleb->types) {
1136                 for (i = 0; i < moduleb->num_types; ++i) {
1137                         if (!type_add_cattrs (assembly, mono_array_get (moduleb->types, MonoReflectionTypeBuilder*, i), error))
1138                                 return FALSE;
1139                 }
1140         }
1141
1142         return TRUE;
1143 }
1144
1145 static gboolean
1146 mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, MonoDynamicImage *assembly, MonoError *error)
1147 {
1148         MonoDynamicTable *table;
1149         guint32 *values;
1150         char blob_size [6];
1151         guchar hash [20];
1152         char *b = blob_size;
1153         char *dir, *path;
1154
1155         mono_error_init (error);
1156
1157         table = &assembly->tables [MONO_TABLE_FILE];
1158         table->rows++;
1159         alloc_table (table, table->rows);
1160         values = table->values + table->next_idx * MONO_FILE_SIZE;
1161         values [MONO_FILE_FLAGS] = FILE_CONTAINS_METADATA;
1162         values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, module->image->module_name);
1163         if (image_is_dynamic (module->image)) {
1164                 /* This depends on the fact that the main module is emitted last */
1165                 dir = mono_string_to_utf8_checked (((MonoReflectionModuleBuilder*)module)->assemblyb->dir, error);
1166                 return_val_if_nok (error, FALSE);
1167                 path = g_strdup_printf ("%s%c%s", dir, G_DIR_SEPARATOR, module->image->module_name);
1168         } else {
1169                 dir = NULL;
1170                 path = g_strdup (module->image->name);
1171         }
1172         mono_sha1_get_digest_from_file (path, hash);
1173         g_free (dir);
1174         g_free (path);
1175         mono_metadata_encode_value (20, b, &b);
1176         values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
1177         mono_image_add_stream_data (&assembly->blob, (char*)hash, 20);
1178         table->next_idx ++;
1179         return TRUE;
1180 }
1181
1182 static void
1183 mono_image_fill_module_table (MonoDomain *domain, MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
1184 {
1185         MonoDynamicTable *table;
1186         int i;
1187
1188         mono_error_init (error);
1189
1190         table = &assembly->tables [MONO_TABLE_MODULE];
1191         mb->table_idx = table->next_idx ++;
1192         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->module.name, error);
1193         return_if_nok (error);
1194         i = mono_image_add_stream_data (&assembly->guid, mono_array_addr (mb->guid, char, 0), 16);
1195         i /= 16;
1196         ++i;
1197         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_GENERATION] = 0;
1198         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_MVID] = i;
1199         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_ENC] = 0;
1200         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_ENCBASE] = 0;
1201 }
1202
1203 static guint32
1204 mono_image_fill_export_table_from_class (MonoDomain *domain, MonoClass *klass,
1205         guint32 module_index, guint32 parent_index, MonoDynamicImage *assembly)
1206 {
1207         MonoDynamicTable *table;
1208         guint32 *values;
1209         guint32 visib, res;
1210
1211         visib = mono_class_get_flags (klass) & TYPE_ATTRIBUTE_VISIBILITY_MASK;
1212         if (! ((visib & TYPE_ATTRIBUTE_PUBLIC) || (visib & TYPE_ATTRIBUTE_NESTED_PUBLIC)))
1213                 return 0;
1214
1215         table = &assembly->tables [MONO_TABLE_EXPORTEDTYPE];
1216         table->rows++;
1217         alloc_table (table, table->rows);
1218         values = table->values + table->next_idx * MONO_EXP_TYPE_SIZE;
1219
1220         values [MONO_EXP_TYPE_FLAGS] = mono_class_get_flags (klass);
1221         values [MONO_EXP_TYPE_TYPEDEF] = klass->type_token;
1222         if (klass->nested_in)
1223                 values [MONO_EXP_TYPE_IMPLEMENTATION] = (parent_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_EXP_TYPE;
1224         else
1225                 values [MONO_EXP_TYPE_IMPLEMENTATION] = (module_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_FILE;
1226         values [MONO_EXP_TYPE_NAME] = string_heap_insert (&assembly->sheap, klass->name);
1227         values [MONO_EXP_TYPE_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
1228
1229         res = table->next_idx;
1230
1231         table->next_idx ++;
1232
1233         /* Emit nested types */
1234         GList *nested_classes = mono_class_get_nested_classes_property (klass);
1235         GList *tmp;
1236         for (tmp = nested_classes; tmp; tmp = tmp->next)
1237                 mono_image_fill_export_table_from_class (domain, (MonoClass *)tmp->data, module_index, table->next_idx - 1, assembly);
1238
1239         return res;
1240 }
1241
1242 static void
1243 mono_image_fill_export_table (MonoDomain *domain, MonoReflectionTypeBuilder *tb,
1244                               guint32 module_index, guint32 parent_index, MonoDynamicImage *assembly,
1245                               MonoError *error)
1246 {
1247         MonoClass *klass;
1248         guint32 idx, i;
1249
1250         mono_error_init (error);
1251
1252         MonoType *t = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error);
1253         return_if_nok (error);
1254
1255         klass = mono_class_from_mono_type (t);
1256
1257         klass->type_token = mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx);
1258
1259         idx = mono_image_fill_export_table_from_class (domain, klass, module_index,
1260                                                                                                    parent_index, assembly);
1261
1262         /*
1263          * Emit nested types
1264          * We need to do this ourselves since klass->nested_classes is not set up.
1265          */
1266         if (tb->subtypes) {
1267                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
1268                         mono_image_fill_export_table (domain, mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i), module_index, idx, assembly, error);
1269                         return_if_nok (error);
1270                 }
1271         }
1272 }
1273
1274 static void
1275 mono_image_fill_export_table_from_module (MonoDomain *domain, MonoReflectionModule *module,
1276         guint32 module_index, MonoDynamicImage *assembly)
1277 {
1278         MonoImage *image = module->image;
1279         MonoTableInfo  *t;
1280         guint32 i;
1281
1282         t = &image->tables [MONO_TABLE_TYPEDEF];
1283
1284         for (i = 0; i < t->rows; ++i) {
1285                 MonoError error;
1286                 MonoClass *klass = mono_class_get_checked (image, mono_metadata_make_token (MONO_TABLE_TYPEDEF, i + 1), &error);
1287                 g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
1288
1289                 if (mono_class_is_public (klass))
1290                         mono_image_fill_export_table_from_class (domain, klass, module_index, 0, assembly);
1291         }
1292 }
1293
1294 static void
1295 add_exported_type (MonoReflectionAssemblyBuilder *assemblyb, MonoDynamicImage *assembly, MonoClass *klass, guint32 parent_index)
1296 {
1297         MonoDynamicTable *table;
1298         guint32 *values;
1299         guint32 scope, scope_idx, impl, current_idx;
1300         gboolean forwarder = TRUE;
1301         gpointer iter = NULL;
1302         MonoClass *nested;
1303
1304         if (klass->nested_in) {
1305                 impl = (parent_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_EXP_TYPE;
1306                 forwarder = FALSE;
1307         } else {
1308                 scope = mono_reflection_resolution_scope_from_image (assembly, klass->image);
1309                 g_assert ((scope & MONO_RESOLUTION_SCOPE_MASK) == MONO_RESOLUTION_SCOPE_ASSEMBLYREF);
1310                 scope_idx = scope >> MONO_RESOLUTION_SCOPE_BITS;
1311                 impl = (scope_idx << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_ASSEMBLYREF;
1312         }
1313
1314         table = &assembly->tables [MONO_TABLE_EXPORTEDTYPE];
1315
1316         table->rows++;
1317         alloc_table (table, table->rows);
1318         current_idx = table->next_idx;
1319         values = table->values + current_idx * MONO_EXP_TYPE_SIZE;
1320
1321         values [MONO_EXP_TYPE_FLAGS] = forwarder ? TYPE_ATTRIBUTE_FORWARDER : 0;
1322         values [MONO_EXP_TYPE_TYPEDEF] = 0;
1323         values [MONO_EXP_TYPE_IMPLEMENTATION] = impl;
1324         values [MONO_EXP_TYPE_NAME] = string_heap_insert (&assembly->sheap, klass->name);
1325         values [MONO_EXP_TYPE_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
1326
1327         table->next_idx++;
1328
1329         while ((nested = mono_class_get_nested_types (klass, &iter)))
1330                 add_exported_type (assemblyb, assembly, nested, current_idx);
1331 }
1332
1333 static void
1334 mono_image_fill_export_table_from_type_forwarders (MonoReflectionAssemblyBuilder *assemblyb, MonoDynamicImage *assembly)
1335 {
1336         MonoError error;
1337         MonoClass *klass;
1338         int i;
1339
1340         if (!assemblyb->type_forwarders)
1341                 return;
1342
1343         for (i = 0; i < mono_array_length (assemblyb->type_forwarders); ++i) {
1344                 MonoReflectionType *t = mono_array_get (assemblyb->type_forwarders, MonoReflectionType *, i);
1345                 MonoType *type;
1346                 if (!t)
1347                         continue;
1348
1349                 type = mono_reflection_type_get_handle (t, &error);
1350                 mono_error_assert_ok (&error);
1351                 g_assert (type);
1352
1353                 klass = mono_class_from_mono_type (type);
1354
1355                 add_exported_type (assemblyb, assembly, klass, 0);
1356         }
1357 }
1358
1359 #define align_pointer(base,p)\
1360         do {\
1361                 guint32 __diff = (unsigned char*)(p)-(unsigned char*)(base);\
1362                 if (__diff & 3)\
1363                         (p) += 4 - (__diff & 3);\
1364         } while (0)
1365
1366 static int
1367 compare_constants (const void *a, const void *b)
1368 {
1369         const guint32 *a_values = (const guint32 *)a;
1370         const guint32 *b_values = (const guint32 *)b;
1371         return a_values [MONO_CONSTANT_PARENT] - b_values [MONO_CONSTANT_PARENT];
1372 }
1373
1374 static int
1375 compare_semantics (const void *a, const void *b)
1376 {
1377         const guint32 *a_values = (const guint32 *)a;
1378         const guint32 *b_values = (const guint32 *)b;
1379         int assoc = a_values [MONO_METHOD_SEMA_ASSOCIATION] - b_values [MONO_METHOD_SEMA_ASSOCIATION];
1380         if (assoc)
1381                 return assoc;
1382         return a_values [MONO_METHOD_SEMA_SEMANTICS] - b_values [MONO_METHOD_SEMA_SEMANTICS];
1383 }
1384
1385 static int
1386 compare_custom_attrs (const void *a, const void *b)
1387 {
1388         const guint32 *a_values = (const guint32 *)a;
1389         const guint32 *b_values = (const guint32 *)b;
1390
1391         return a_values [MONO_CUSTOM_ATTR_PARENT] - b_values [MONO_CUSTOM_ATTR_PARENT];
1392 }
1393
1394 static int
1395 compare_field_marshal (const void *a, const void *b)
1396 {
1397         const guint32 *a_values = (const guint32 *)a;
1398         const guint32 *b_values = (const guint32 *)b;
1399
1400         return a_values [MONO_FIELD_MARSHAL_PARENT] - b_values [MONO_FIELD_MARSHAL_PARENT];
1401 }
1402
1403 static int
1404 compare_nested (const void *a, const void *b)
1405 {
1406         const guint32 *a_values = (const guint32 *)a;
1407         const guint32 *b_values = (const guint32 *)b;
1408
1409         return a_values [MONO_NESTED_CLASS_NESTED] - b_values [MONO_NESTED_CLASS_NESTED];
1410 }
1411
1412 static int
1413 compare_genericparam (const void *a, const void *b)
1414 {
1415         MonoError error;
1416         const GenericParamTableEntry **a_entry = (const GenericParamTableEntry **) a;
1417         const GenericParamTableEntry **b_entry = (const GenericParamTableEntry **) b;
1418
1419         if ((*b_entry)->owner == (*a_entry)->owner) {
1420                 MonoType *a_type = mono_reflection_type_get_handle ((MonoReflectionType*)(*a_entry)->gparam, &error);
1421                 mono_error_assert_ok (&error);
1422                 MonoType *b_type = mono_reflection_type_get_handle ((MonoReflectionType*)(*b_entry)->gparam, &error);
1423                 mono_error_assert_ok (&error);
1424                 return
1425                         mono_type_get_generic_param_num (a_type) -
1426                         mono_type_get_generic_param_num (b_type);
1427         } else
1428                 return (*a_entry)->owner - (*b_entry)->owner;
1429 }
1430
1431 static int
1432 compare_declsecurity_attrs (const void *a, const void *b)
1433 {
1434         const guint32 *a_values = (const guint32 *)a;
1435         const guint32 *b_values = (const guint32 *)b;
1436
1437         return a_values [MONO_DECL_SECURITY_PARENT] - b_values [MONO_DECL_SECURITY_PARENT];
1438 }
1439
1440 static int
1441 compare_interface_impl (const void *a, const void *b)
1442 {
1443         const guint32 *a_values = (const guint32 *)a;
1444         const guint32 *b_values = (const guint32 *)b;
1445
1446         int klass = a_values [MONO_INTERFACEIMPL_CLASS] - b_values [MONO_INTERFACEIMPL_CLASS];
1447         if (klass)
1448                 return klass;
1449
1450         return a_values [MONO_INTERFACEIMPL_INTERFACE] - b_values [MONO_INTERFACEIMPL_INTERFACE];
1451 }
1452
1453 struct StreamDesc {
1454         const char *name;
1455         MonoDynamicStream *stream;
1456 };
1457
1458 /*
1459  * build_compressed_metadata() fills in the blob of data that represents the
1460  * raw metadata as it will be saved in the PE file. The five streams are output
1461  * and the metadata tables are comnpressed from the guint32 array representation,
1462  * to the compressed on-disk format.
1463  */
1464 static gboolean
1465 build_compressed_metadata (MonoDynamicImage *assembly, MonoError *error)
1466 {
1467         MonoDynamicTable *table;
1468         int i;
1469         guint64 valid_mask = 0;
1470         guint64 sorted_mask;
1471         guint32 heapt_size = 0;
1472         guint32 meta_size = 256; /* allow for header and other stuff */
1473         guint32 table_offset;
1474         guint32 ntables = 0;
1475         guint64 *int64val;
1476         guint32 *int32val;
1477         guint16 *int16val;
1478         MonoImage *meta;
1479         unsigned char *p;
1480         struct StreamDesc stream_desc [5];
1481
1482         mono_error_init (error);
1483
1484         qsort (assembly->gen_params->pdata, assembly->gen_params->len, sizeof (gpointer), compare_genericparam);
1485         for (i = 0; i < assembly->gen_params->len; i++) {
1486                 GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (assembly->gen_params, i);
1487                 if (!write_generic_param_entry (assembly, entry, error))
1488                         return FALSE;
1489         }
1490
1491         stream_desc [0].name  = "#~";
1492         stream_desc [0].stream = &assembly->tstream;
1493         stream_desc [1].name  = "#Strings";
1494         stream_desc [1].stream = &assembly->sheap;
1495         stream_desc [2].name  = "#US";
1496         stream_desc [2].stream = &assembly->us;
1497         stream_desc [3].name  = "#Blob";
1498         stream_desc [3].stream = &assembly->blob;
1499         stream_desc [4].name  = "#GUID";
1500         stream_desc [4].stream = &assembly->guid;
1501
1502         /* tables that are sorted */
1503         sorted_mask = ((guint64)1 << MONO_TABLE_CONSTANT) | ((guint64)1 << MONO_TABLE_FIELDMARSHAL)
1504                 | ((guint64)1 << MONO_TABLE_METHODSEMANTICS) | ((guint64)1 << MONO_TABLE_CLASSLAYOUT)
1505                 | ((guint64)1 << MONO_TABLE_FIELDLAYOUT) | ((guint64)1 << MONO_TABLE_FIELDRVA)
1506                 | ((guint64)1 << MONO_TABLE_IMPLMAP) | ((guint64)1 << MONO_TABLE_NESTEDCLASS)
1507                 | ((guint64)1 << MONO_TABLE_METHODIMPL) | ((guint64)1 << MONO_TABLE_CUSTOMATTRIBUTE)
1508                 | ((guint64)1 << MONO_TABLE_DECLSECURITY) | ((guint64)1 << MONO_TABLE_GENERICPARAM)
1509                 | ((guint64)1 << MONO_TABLE_INTERFACEIMPL);
1510
1511         /* Compute table sizes */
1512         /* the MonoImage has already been created in mono_reflection_dynimage_basic_init() */
1513         meta = &assembly->image;
1514
1515         /* sizes should be multiple of 4 */
1516         mono_dynstream_data_align (&assembly->blob);
1517         mono_dynstream_data_align (&assembly->guid);
1518         mono_dynstream_data_align (&assembly->sheap);
1519         mono_dynstream_data_align (&assembly->us);
1520
1521         /* Setup the info used by compute_sizes () */
1522         meta->idx_blob_wide = assembly->blob.index >= 65536 ? 1 : 0;
1523         meta->idx_guid_wide = assembly->guid.index >= 65536 ? 1 : 0;
1524         meta->idx_string_wide = assembly->sheap.index >= 65536 ? 1 : 0;
1525
1526         meta_size += assembly->blob.index;
1527         meta_size += assembly->guid.index;
1528         meta_size += assembly->sheap.index;
1529         meta_size += assembly->us.index;
1530
1531         for (i=0; i < MONO_TABLE_NUM; ++i)
1532                 meta->tables [i].rows = assembly->tables [i].rows;
1533
1534         for (i = 0; i < MONO_TABLE_NUM; i++){
1535                 if (meta->tables [i].rows == 0)
1536                         continue;
1537                 valid_mask |= (guint64)1 << i;
1538                 ntables ++;
1539                 meta->tables [i].row_size = mono_metadata_compute_size (
1540                         meta, i, &meta->tables [i].size_bitfield);
1541                 heapt_size += meta->tables [i].row_size * meta->tables [i].rows;
1542         }
1543         heapt_size += 24; /* #~ header size */
1544         heapt_size += ntables * 4;
1545         /* make multiple of 4 */
1546         heapt_size += 3;
1547         heapt_size &= ~3;
1548         meta_size += heapt_size;
1549         meta->raw_metadata = (char *)g_malloc0 (meta_size);
1550         p = (unsigned char*)meta->raw_metadata;
1551         /* the metadata signature */
1552         *p++ = 'B'; *p++ = 'S'; *p++ = 'J'; *p++ = 'B';
1553         /* version numbers and 4 bytes reserved */
1554         int16val = (guint16*)p;
1555         *int16val++ = GUINT16_TO_LE (meta->md_version_major);
1556         *int16val = GUINT16_TO_LE (meta->md_version_minor);
1557         p += 8;
1558         /* version string */
1559         int32val = (guint32*)p;
1560         *int32val = GUINT32_TO_LE ((strlen (meta->version) + 3) & (~3)); /* needs to be multiple of 4 */
1561         p += 4;
1562         memcpy (p, meta->version, strlen (meta->version));
1563         p += GUINT32_FROM_LE (*int32val);
1564         align_pointer (meta->raw_metadata, p);
1565         int16val = (guint16*)p;
1566         *int16val++ = GUINT16_TO_LE (0); /* flags must be 0 */
1567         *int16val = GUINT16_TO_LE (5); /* number of streams */
1568         p += 4;
1569
1570         /*
1571          * write the stream info.
1572          */
1573         table_offset = (p - (unsigned char*)meta->raw_metadata) + 5 * 8 + 40; /* room needed for stream headers */
1574         table_offset += 3; table_offset &= ~3;
1575
1576         assembly->tstream.index = heapt_size;
1577         for (i = 0; i < 5; ++i) {
1578                 int32val = (guint32*)p;
1579                 stream_desc [i].stream->offset = table_offset;
1580                 *int32val++ = GUINT32_TO_LE (table_offset);
1581                 *int32val = GUINT32_TO_LE (stream_desc [i].stream->index);
1582                 table_offset += GUINT32_FROM_LE (*int32val);
1583                 table_offset += 3; table_offset &= ~3;
1584                 p += 8;
1585                 strcpy ((char*)p, stream_desc [i].name);
1586                 p += strlen (stream_desc [i].name) + 1;
1587                 align_pointer (meta->raw_metadata, p);
1588         }
1589         /*
1590          * now copy the data, the table stream header and contents goes first.
1591          */
1592         g_assert ((p - (unsigned char*)meta->raw_metadata) < assembly->tstream.offset);
1593         p = (guchar*)meta->raw_metadata + assembly->tstream.offset;
1594         int32val = (guint32*)p;
1595         *int32val = GUINT32_TO_LE (0); /* reserved */
1596         p += 4;
1597
1598         *p++ = 2; /* version */
1599         *p++ = 0;
1600
1601         if (meta->idx_string_wide)
1602                 *p |= 0x01;
1603         if (meta->idx_guid_wide)
1604                 *p |= 0x02;
1605         if (meta->idx_blob_wide)
1606                 *p |= 0x04;
1607         ++p;
1608         *p++ = 1; /* reserved */
1609         int64val = (guint64*)p;
1610         *int64val++ = GUINT64_TO_LE (valid_mask);
1611         *int64val++ = GUINT64_TO_LE (valid_mask & sorted_mask); /* bitvector of sorted tables  */
1612         p += 16;
1613         int32val = (guint32*)p;
1614         for (i = 0; i < MONO_TABLE_NUM; i++){
1615                 if (meta->tables [i].rows == 0)
1616                         continue;
1617                 *int32val++ = GUINT32_TO_LE (meta->tables [i].rows);
1618         }
1619         p = (unsigned char*)int32val;
1620
1621         /* sort the tables that still need sorting */
1622         table = &assembly->tables [MONO_TABLE_CONSTANT];
1623         if (table->rows)
1624                 qsort (table->values + MONO_CONSTANT_SIZE, table->rows, sizeof (guint32) * MONO_CONSTANT_SIZE, compare_constants);
1625         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
1626         if (table->rows)
1627                 qsort (table->values + MONO_METHOD_SEMA_SIZE, table->rows, sizeof (guint32) * MONO_METHOD_SEMA_SIZE, compare_semantics);
1628         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1629         if (table->rows)
1630                 qsort (table->values + MONO_CUSTOM_ATTR_SIZE, table->rows, sizeof (guint32) * MONO_CUSTOM_ATTR_SIZE, compare_custom_attrs);
1631         table = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
1632         if (table->rows)
1633                 qsort (table->values + MONO_FIELD_MARSHAL_SIZE, table->rows, sizeof (guint32) * MONO_FIELD_MARSHAL_SIZE, compare_field_marshal);
1634         table = &assembly->tables [MONO_TABLE_NESTEDCLASS];
1635         if (table->rows)
1636                 qsort (table->values + MONO_NESTED_CLASS_SIZE, table->rows, sizeof (guint32) * MONO_NESTED_CLASS_SIZE, compare_nested);
1637         /* Section 21.11 DeclSecurity in Partition II doesn't specify this to be sorted by MS implementation requires it */
1638         table = &assembly->tables [MONO_TABLE_DECLSECURITY];
1639         if (table->rows)
1640                 qsort (table->values + MONO_DECL_SECURITY_SIZE, table->rows, sizeof (guint32) * MONO_DECL_SECURITY_SIZE, compare_declsecurity_attrs);
1641         table = &assembly->tables [MONO_TABLE_INTERFACEIMPL];
1642         if (table->rows)
1643                 qsort (table->values + MONO_INTERFACEIMPL_SIZE, table->rows, sizeof (guint32) * MONO_INTERFACEIMPL_SIZE, compare_interface_impl);
1644
1645         /* compress the tables */
1646         for (i = 0; i < MONO_TABLE_NUM; i++){
1647                 int row, col;
1648                 guint32 *values;
1649                 guint32 bitfield = meta->tables [i].size_bitfield;
1650                 if (!meta->tables [i].rows)
1651                         continue;
1652                 if (assembly->tables [i].columns != mono_metadata_table_count (bitfield))
1653                         g_error ("col count mismatch in %d: %d %d", i, assembly->tables [i].columns, mono_metadata_table_count (bitfield));
1654                 meta->tables [i].base = (char*)p;
1655                 for (row = 1; row <= meta->tables [i].rows; ++row) {
1656                         values = assembly->tables [i].values + row * assembly->tables [i].columns;
1657                         for (col = 0; col < assembly->tables [i].columns; ++col) {
1658                                 switch (mono_metadata_table_size (bitfield, col)) {
1659                                 case 1:
1660                                         *p++ = values [col];
1661                                         break;
1662                                 case 2:
1663                                         *p++ = values [col] & 0xff;
1664                                         *p++ = (values [col] >> 8) & 0xff;
1665                                         break;
1666                                 case 4:
1667                                         *p++ = values [col] & 0xff;
1668                                         *p++ = (values [col] >> 8) & 0xff;
1669                                         *p++ = (values [col] >> 16) & 0xff;
1670                                         *p++ = (values [col] >> 24) & 0xff;
1671                                         break;
1672                                 default:
1673                                         g_assert_not_reached ();
1674                                 }
1675                         }
1676                 }
1677                 g_assert ((p - (const unsigned char*)meta->tables [i].base) == (meta->tables [i].rows * meta->tables [i].row_size));
1678         }
1679
1680         g_assert (assembly->guid.offset + assembly->guid.index < meta_size);
1681         memcpy (meta->raw_metadata + assembly->sheap.offset, assembly->sheap.data, assembly->sheap.index);
1682         memcpy (meta->raw_metadata + assembly->us.offset, assembly->us.data, assembly->us.index);
1683         memcpy (meta->raw_metadata + assembly->blob.offset, assembly->blob.data, assembly->blob.index);
1684         memcpy (meta->raw_metadata + assembly->guid.offset, assembly->guid.data, assembly->guid.index);
1685
1686         assembly->meta_size = assembly->guid.offset + assembly->guid.index;
1687
1688         return TRUE;
1689 }
1690
1691 /*
1692  * Some tables in metadata need to be sorted according to some criteria, but
1693  * when methods and fields are first created with reflection, they may be assigned a token
1694  * that doesn't correspond to the final token they will get assigned after the sorting.
1695  * ILGenerator.cs keeps a fixup table that maps the position of tokens in the IL code stream
1696  * with the reflection objects that represent them. Once all the tables are set up, the
1697  * reflection objects will contains the correct table index. fixup_method() will fixup the
1698  * tokens for the method with ILGenerator @ilgen.
1699  */
1700 static void
1701 fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *assembly)
1702 {
1703         guint32 code_idx = GPOINTER_TO_UINT (value);
1704         MonoReflectionILTokenInfo *iltoken;
1705         MonoReflectionTypeBuilder *tb;
1706         MonoReflectionArrayMethod *am;
1707         guint32 i, idx = 0;
1708         unsigned char *target;
1709
1710         for (i = 0; i < ilgen->num_token_fixups; ++i) {
1711                 iltoken = (MonoReflectionILTokenInfo *)mono_array_addr_with_size (ilgen->token_fixups, sizeof (MonoReflectionILTokenInfo), i);
1712                 target = (guchar*)assembly->code.data + code_idx + iltoken->code_pos;
1713                 switch (target [3]) {
1714                 case MONO_TABLE_FIELD:
1715                         if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
1716                                 g_assert_not_reached ();
1717                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) {
1718                                 MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field;
1719                                 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->field_to_table_idx, f));
1720                         } else {
1721                                 g_assert_not_reached ();
1722                         }
1723                         break;
1724                 case MONO_TABLE_METHOD:
1725                         if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) {
1726                                 g_assert_not_reached ();
1727                         } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) {
1728                                 g_assert_not_reached ();
1729                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
1730                                            !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) {
1731                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
1732                                 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
1733                         } else {
1734                                 g_assert_not_reached ();
1735                         }
1736                         break;
1737                 case MONO_TABLE_TYPEDEF:
1738                         if (!strcmp (iltoken->member->vtable->klass->name, "TypeBuilder")) {
1739                                 g_assert_not_reached ();
1740                         } else if (!strcmp (iltoken->member->vtable->klass->name, "RuntimeType")) {
1741                                 MonoClass *k = mono_class_from_mono_type (((MonoReflectionType*)iltoken->member)->type);
1742                                 MonoObject *obj = mono_class_get_ref_info_raw (k); /* FIXME use handles */
1743                                 g_assert (obj);
1744                                 g_assert (!strcmp (mono_object_class (obj)->name, "TypeBuilder"));
1745                                 tb = (MonoReflectionTypeBuilder*)obj;
1746                                 idx = tb->table_idx;
1747                         } else {
1748                                 g_assert_not_reached ();
1749                         }
1750                         break;
1751                 case MONO_TABLE_MEMBERREF:
1752                         if (!strcmp (iltoken->member->vtable->klass->name, "MonoArrayMethod")) {
1753                                 am = (MonoReflectionArrayMethod*)iltoken->member;
1754                                 idx = am->table_idx;
1755                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
1756                                            !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) {
1757                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
1758                                 g_assert (mono_class_is_ginst (m->klass) || mono_class_is_gtd (m->klass));
1759                                 continue;
1760                         } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
1761                                 g_assert_not_reached ();
1762                                 continue;
1763                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) {
1764                                 continue;
1765                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder") ||
1766                                         !strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) {
1767                                 g_assert_not_reached ();
1768                                 continue;
1769                         } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldOnTypeBuilderInst")) {
1770                                 g_assert_not_reached ();
1771                                 continue;
1772                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodOnTypeBuilderInst")) {
1773                                 g_assert_not_reached ();
1774                                 continue;
1775                         } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorOnTypeBuilderInst")) {
1776                                 g_assert_not_reached ();
1777                                 continue;
1778                         } else {
1779                                 g_assert_not_reached ();
1780                         }
1781                         break;
1782                 case MONO_TABLE_METHODSPEC:
1783                         if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod")) {
1784                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
1785                                 g_assert (mono_method_signature (m)->generic_param_count);
1786                                 continue;
1787                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) {
1788                                 g_assert_not_reached ();
1789                                 continue;
1790                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodOnTypeBuilderInst")) {
1791                                 g_assert_not_reached ();
1792                                 continue;
1793                         } else {
1794                                 g_assert_not_reached ();
1795                         }
1796                         break;
1797                 case MONO_TABLE_TYPESPEC:
1798                         if (!strcmp (iltoken->member->vtable->klass->name, "RuntimeType")) {
1799                                 continue;
1800                         } else {
1801                                 g_assert_not_reached ();
1802                         }
1803                         break;
1804                 default:
1805                         g_error ("got unexpected table 0x%02x in fixup", target [3]);
1806                 }
1807                 target [0] = idx & 0xff;
1808                 target [1] = (idx >> 8) & 0xff;
1809                 target [2] = (idx >> 16) & 0xff;
1810         }
1811 }
1812
1813 /*
1814  * fixup_cattrs:
1815  *
1816  *   The CUSTOM_ATTRIBUTE table might contain METHODDEF tokens whose final
1817  * value is not known when the table is emitted.
1818  */
1819 static void
1820 fixup_cattrs (MonoDynamicImage *assembly)
1821 {
1822         MonoDynamicTable *table;
1823         guint32 *values;
1824         guint32 type, i, idx, token;
1825         MonoObject *ctor;
1826
1827         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1828
1829         for (i = 0; i < table->rows; ++i) {
1830                 values = table->values + ((i + 1) * MONO_CUSTOM_ATTR_SIZE);
1831
1832                 type = values [MONO_CUSTOM_ATTR_TYPE];
1833                 if ((type & MONO_CUSTOM_ATTR_TYPE_MASK) == MONO_CUSTOM_ATTR_TYPE_METHODDEF) {
1834                         idx = type >> MONO_CUSTOM_ATTR_TYPE_BITS;
1835                         token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
1836                         ctor = (MonoObject *)mono_g_hash_table_lookup (assembly->remapped_tokens, GUINT_TO_POINTER (token));
1837                         g_assert (ctor);
1838
1839                         if (!strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
1840                                 MonoMethod *m = ((MonoReflectionMethod*)ctor)->method;
1841                                 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
1842                                 values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
1843                         } else if (!strcmp (ctor->vtable->klass->name, "ConstructorBuilder")) {
1844                                 MonoMethod *m = ((MonoReflectionCtorBuilder*)ctor)->mhandle;
1845                                 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
1846                                 values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
1847                         }
1848                 }
1849         }
1850 }
1851
1852 static gboolean
1853 assembly_add_resource_manifest (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc, guint32 implementation, MonoError *error)
1854 {
1855         MonoDynamicTable *table;
1856         guint32 *values;
1857
1858         mono_error_init (error);
1859
1860         table = &assembly->tables [MONO_TABLE_MANIFESTRESOURCE];
1861         table->rows++;
1862         alloc_table (table, table->rows);
1863         values = table->values + table->next_idx * MONO_MANIFEST_SIZE;
1864         values [MONO_MANIFEST_OFFSET] = rsrc->offset;
1865         values [MONO_MANIFEST_FLAGS] = rsrc->attrs;
1866         values [MONO_MANIFEST_NAME] = string_heap_insert_mstring (&assembly->sheap, rsrc->name, error);
1867         return_val_if_nok (error, FALSE);
1868         values [MONO_MANIFEST_IMPLEMENTATION] = implementation;
1869         table->next_idx++;
1870         return TRUE;
1871 }
1872
1873 static gboolean
1874 assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc, MonoError *error)
1875 {
1876         MonoDynamicTable *table;
1877         guint32 *values;
1878         char blob_size [6];
1879         guchar hash [20];
1880         char *b = blob_size;
1881         char *name, *sname;
1882         guint32 idx, offset;
1883
1884         mono_error_init (error);
1885
1886         if (rsrc->filename) {
1887                 name = mono_string_to_utf8_checked (rsrc->filename, error);
1888                 return_val_if_nok (error, FALSE);
1889                 sname = g_path_get_basename (name);
1890
1891                 table = &assembly->tables [MONO_TABLE_FILE];
1892                 table->rows++;
1893                 alloc_table (table, table->rows);
1894                 values = table->values + table->next_idx * MONO_FILE_SIZE;
1895                 values [MONO_FILE_FLAGS] = FILE_CONTAINS_NO_METADATA;
1896                 values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, sname);
1897                 g_free (sname);
1898
1899                 mono_sha1_get_digest_from_file (name, hash);
1900                 mono_metadata_encode_value (20, b, &b);
1901                 values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
1902                 mono_image_add_stream_data (&assembly->blob, (char*)hash, 20);
1903                 g_free (name);
1904                 idx = table->next_idx++;
1905                 rsrc->offset = 0;
1906                 idx = MONO_IMPLEMENTATION_FILE | (idx << MONO_IMPLEMENTATION_BITS);
1907         } else {
1908                 char sizebuf [4];
1909                 char *data;
1910                 guint len;
1911                 if (rsrc->data) {
1912                         data = mono_array_addr (rsrc->data, char, 0);
1913                         len = mono_array_length (rsrc->data);
1914                 } else {
1915                         data = NULL;
1916                         len = 0;
1917                 }
1918                 offset = len;
1919                 sizebuf [0] = offset; sizebuf [1] = offset >> 8;
1920                 sizebuf [2] = offset >> 16; sizebuf [3] = offset >> 24;
1921                 rsrc->offset = mono_image_add_stream_data (&assembly->resources, sizebuf, 4);
1922                 mono_image_add_stream_data (&assembly->resources, data, len);
1923
1924                 if (!mb->is_main)
1925                         /*
1926                          * The entry should be emitted into the MANIFESTRESOURCE table of
1927                          * the main module, but that needs to reference the FILE table
1928                          * which isn't emitted yet.
1929                          */
1930                         return TRUE;
1931                 else
1932                         idx = 0;
1933         }
1934
1935         return assembly_add_resource_manifest (mb, assembly, rsrc, idx, error);
1936 }
1937
1938 static gboolean
1939 set_version_from_string (MonoString *version, guint32 *values, MonoError *error)
1940 {
1941         gchar *ver, *p, *str;
1942         guint32 i;
1943
1944         mono_error_init (error);
1945
1946         values [MONO_ASSEMBLY_MAJOR_VERSION] = 0;
1947         values [MONO_ASSEMBLY_MINOR_VERSION] = 0;
1948         values [MONO_ASSEMBLY_REV_NUMBER] = 0;
1949         values [MONO_ASSEMBLY_BUILD_NUMBER] = 0;
1950         if (!version)
1951                 return TRUE;
1952         ver = str = mono_string_to_utf8_checked (version, error);
1953         return_val_if_nok (error, FALSE);
1954         for (i = 0; i < 4; ++i) {
1955                 values [MONO_ASSEMBLY_MAJOR_VERSION + i] = strtol (ver, &p, 10);
1956                 switch (*p) {
1957                 case '.':
1958                         p++;
1959                         break;
1960                 case '*':
1961                         /* handle Revision and Build */
1962                         p++;
1963                         break;
1964                 }
1965                 ver = p;
1966         }
1967         g_free (str);
1968         return TRUE;
1969 }
1970
1971 static guint32
1972 load_public_key (MonoArray *pkey, MonoDynamicImage *assembly) {
1973         gsize len;
1974         guint32 token = 0;
1975         char blob_size [6];
1976         char *b = blob_size;
1977
1978         if (!pkey)
1979                 return token;
1980
1981         len = mono_array_length (pkey);
1982         mono_metadata_encode_value (len, b, &b);
1983         token = mono_image_add_stream_data (&assembly->blob, blob_size, b - blob_size);
1984         mono_image_add_stream_data (&assembly->blob, mono_array_addr (pkey, char, 0), len);
1985
1986         assembly->public_key = (guint8 *)g_malloc (len);
1987         memcpy (assembly->public_key, mono_array_addr (pkey, char, 0), len);
1988         assembly->public_key_len = len;
1989
1990         /* Special case: check for ECMA key (16 bytes) */
1991         if ((len == MONO_ECMA_KEY_LENGTH) && mono_is_ecma_key (mono_array_addr (pkey, char, 0), len)) {
1992                 /* In this case we must reserve 128 bytes (1024 bits) for the signature */
1993                 assembly->strong_name_size = MONO_DEFAULT_PUBLIC_KEY_LENGTH;
1994         } else if (len >= MONO_PUBLIC_KEY_HEADER_LENGTH + MONO_MINIMUM_PUBLIC_KEY_LENGTH) {
1995                 /* minimum key size (in 2.0) is 384 bits */
1996                 assembly->strong_name_size = len - MONO_PUBLIC_KEY_HEADER_LENGTH;
1997         } else {
1998                 /* FIXME - verifier */
1999                 g_warning ("Invalid public key length: %d bits (total: %d)", (int)MONO_PUBLIC_KEY_BIT_SIZE (len), (int)len);
2000                 assembly->strong_name_size = MONO_DEFAULT_PUBLIC_KEY_LENGTH; /* to be safe */
2001         }
2002         assembly->strong_name = (char *)g_malloc0 (assembly->strong_name_size);
2003
2004         return token;
2005 }
2006
2007 static gboolean
2008 mono_image_emit_manifest (MonoReflectionModuleBuilder *moduleb, MonoError *error)
2009 {
2010         MonoDynamicTable *table;
2011         MonoDynamicImage *assembly;
2012         MonoReflectionAssemblyBuilder *assemblyb;
2013         MonoDomain *domain;
2014         guint32 *values;
2015         int i;
2016         guint32 module_index;
2017
2018         mono_error_init (error);
2019
2020         assemblyb = moduleb->assemblyb;
2021         assembly = moduleb->dynamic_image;
2022         domain = mono_object_domain (assemblyb);
2023
2024         /* Emit ASSEMBLY table */
2025         table = &assembly->tables [MONO_TABLE_ASSEMBLY];
2026         alloc_table (table, 1);
2027         values = table->values + MONO_ASSEMBLY_SIZE;
2028         values [MONO_ASSEMBLY_HASH_ALG] = assemblyb->algid? assemblyb->algid: ASSEMBLY_HASH_SHA1;
2029         values [MONO_ASSEMBLY_NAME] = string_heap_insert_mstring (&assembly->sheap, assemblyb->name, error);
2030         return_val_if_nok (error, FALSE);
2031         if (assemblyb->culture) {
2032                 values [MONO_ASSEMBLY_CULTURE] = string_heap_insert_mstring (&assembly->sheap, assemblyb->culture, error);
2033                 return_val_if_nok (error, FALSE);
2034         } else {
2035                 values [MONO_ASSEMBLY_CULTURE] = string_heap_insert (&assembly->sheap, "");
2036         }
2037         values [MONO_ASSEMBLY_PUBLIC_KEY] = load_public_key (assemblyb->public_key, assembly);
2038         values [MONO_ASSEMBLY_FLAGS] = assemblyb->flags;
2039         if (!set_version_from_string (assemblyb->version, values, error))
2040                 return FALSE;
2041
2042         /* Emit FILE + EXPORTED_TYPE table */
2043         module_index = 0;
2044         for (i = 0; i < mono_array_length (assemblyb->modules); ++i) {
2045                 int j;
2046                 MonoReflectionModuleBuilder *file_module =
2047                         mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
2048                 if (file_module != moduleb) {
2049                         if (!mono_image_fill_file_table (domain, (MonoReflectionModule*)file_module, assembly, error))
2050                                 return FALSE;
2051                         module_index ++;
2052                         if (file_module->types) {
2053                                 for (j = 0; j < file_module->num_types; ++j) {
2054                                         MonoReflectionTypeBuilder *tb = mono_array_get (file_module->types, MonoReflectionTypeBuilder*, j);
2055                                         mono_image_fill_export_table (domain, tb, module_index, 0, assembly, error);
2056                                         return_val_if_nok (error, FALSE);
2057                                 }
2058                         }
2059                 }
2060         }
2061         if (assemblyb->loaded_modules) {
2062                 for (i = 0; i < mono_array_length (assemblyb->loaded_modules); ++i) {
2063                         MonoReflectionModule *file_module =
2064                                 mono_array_get (assemblyb->loaded_modules, MonoReflectionModule*, i);
2065                         if (!mono_image_fill_file_table (domain, file_module, assembly, error))
2066                                 return FALSE;
2067                         module_index ++;
2068                         mono_image_fill_export_table_from_module (domain, file_module, module_index, assembly);
2069                 }
2070         }
2071         if (assemblyb->type_forwarders)
2072                 mono_image_fill_export_table_from_type_forwarders (assemblyb, assembly);
2073
2074         /* Emit MANIFESTRESOURCE table */
2075         module_index = 0;
2076         for (i = 0; i < mono_array_length (assemblyb->modules); ++i) {
2077                 int j;
2078                 MonoReflectionModuleBuilder *file_module =
2079                         mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
2080                 /* The table for the main module is emitted later */
2081                 if (file_module != moduleb) {
2082                         module_index ++;
2083                         if (file_module->resources) {
2084                                 int len = mono_array_length (file_module->resources);
2085                                 for (j = 0; j < len; ++j) {
2086                                         MonoReflectionResource* res = (MonoReflectionResource*)mono_array_addr (file_module->resources, MonoReflectionResource, j);
2087                                         if (!assembly_add_resource_manifest (file_module, assembly, res, MONO_IMPLEMENTATION_FILE | (module_index << MONO_IMPLEMENTATION_BITS), error))
2088                                                 return FALSE;
2089                                 }
2090                         }
2091                 }
2092         }
2093         return TRUE;
2094 }
2095
2096 #ifndef DISABLE_REFLECTION_EMIT_SAVE
2097
2098 /*
2099  * Insert into the metadata tables all the info about the TypeBuilder tb.
2100  * Data in the tables is inserted in a predefined order, since some tables need to be sorted.
2101  */
2102 static gboolean
2103 mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, MonoDynamicImage *assembly, MonoError *error)
2104 {
2105         MonoDynamicTable *table;
2106         guint *values;
2107         int i, is_object = 0, is_system = 0;
2108         char *n;
2109
2110         mono_error_init (error);
2111
2112         table = &assembly->tables [MONO_TABLE_TYPEDEF];
2113         values = table->values + tb->table_idx * MONO_TYPEDEF_SIZE;
2114         values [MONO_TYPEDEF_FLAGS] = tb->attrs;
2115         n = mono_string_to_utf8_checked (tb->name, error);
2116         return_val_if_nok (error, FALSE);
2117         if (strcmp (n, "Object") == 0)
2118                 is_object++;
2119         values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, n);
2120         g_free (n);
2121         n = mono_string_to_utf8_checked (tb->nspace, error);
2122         return_val_if_nok (error, FALSE);
2123         if (strcmp (n, "System") == 0)
2124                 is_system++;
2125         values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, n);
2126         g_free (n);
2127         if (tb->parent && !(is_system && is_object) &&
2128                         !(tb->attrs & TYPE_ATTRIBUTE_INTERFACE)) { /* interfaces don't have a parent */
2129                 MonoType *parent_type = mono_reflection_type_get_handle ((MonoReflectionType*)tb->parent, error);
2130                 return_val_if_nok (error, FALSE);
2131                 values [MONO_TYPEDEF_EXTENDS] = mono_image_typedef_or_ref (assembly, parent_type);
2132         } else {
2133                 values [MONO_TYPEDEF_EXTENDS] = 0;
2134         }
2135         values [MONO_TYPEDEF_FIELD_LIST] = assembly->tables [MONO_TABLE_FIELD].next_idx;
2136         values [MONO_TYPEDEF_METHOD_LIST] = assembly->tables [MONO_TABLE_METHOD].next_idx;
2137
2138         /*
2139          * if we have explicitlayout or sequentiallayouts, output data in the
2140          * ClassLayout table.
2141          */
2142         if (((tb->attrs & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT) &&
2143                         ((tb->class_size > 0) || (tb->packing_size > 0))) {
2144                 table = &assembly->tables [MONO_TABLE_CLASSLAYOUT];
2145                 table->rows++;
2146                 alloc_table (table, table->rows);
2147                 values = table->values + table->rows * MONO_CLASS_LAYOUT_SIZE;
2148                 values [MONO_CLASS_LAYOUT_PARENT] = tb->table_idx;
2149                 values [MONO_CLASS_LAYOUT_CLASS_SIZE] = tb->class_size;
2150                 values [MONO_CLASS_LAYOUT_PACKING_SIZE] = tb->packing_size;
2151         }
2152
2153         /* handle interfaces */
2154         if (tb->interfaces) {
2155                 table = &assembly->tables [MONO_TABLE_INTERFACEIMPL];
2156                 i = table->rows;
2157                 table->rows += mono_array_length (tb->interfaces);
2158                 alloc_table (table, table->rows);
2159                 values = table->values + (i + 1) * MONO_INTERFACEIMPL_SIZE;
2160                 for (i = 0; i < mono_array_length (tb->interfaces); ++i) {
2161                         MonoReflectionType* iface = (MonoReflectionType*) mono_array_get (tb->interfaces, gpointer, i);
2162                         MonoType *iface_type = mono_reflection_type_get_handle (iface, error);
2163                         return_val_if_nok (error, FALSE);
2164                         values [MONO_INTERFACEIMPL_CLASS] = tb->table_idx;
2165                         values [MONO_INTERFACEIMPL_INTERFACE] = mono_image_typedef_or_ref (assembly, iface_type);
2166                         values += MONO_INTERFACEIMPL_SIZE;
2167                 }
2168         }
2169
2170         /* handle fields */
2171         if (tb->fields) {
2172                 table = &assembly->tables [MONO_TABLE_FIELD];
2173                 table->rows += tb->num_fields;
2174                 alloc_table (table, table->rows);
2175                 for (i = 0; i < tb->num_fields; ++i) {
2176                         mono_image_get_field_info (
2177                                 mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i), assembly, error);
2178                         return_val_if_nok (error, FALSE);
2179                 }
2180         }
2181
2182         /* handle constructors */
2183         if (tb->ctors) {
2184                 table = &assembly->tables [MONO_TABLE_METHOD];
2185                 table->rows += mono_array_length (tb->ctors);
2186                 alloc_table (table, table->rows);
2187                 for (i = 0; i < mono_array_length (tb->ctors); ++i) {
2188                         if (!mono_image_get_ctor_info (domain,
2189                                                        mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i),
2190                                                        assembly, error))
2191                                 return FALSE;
2192                 }
2193         }
2194
2195         /* handle methods */
2196         if (tb->methods) {
2197                 table = &assembly->tables [MONO_TABLE_METHOD];
2198                 table->rows += tb->num_methods;
2199                 alloc_table (table, table->rows);
2200                 for (i = 0; i < tb->num_methods; ++i) {
2201                         if (!mono_image_get_method_info (
2202                                     mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i), assembly, error))
2203                                 return FALSE;
2204                 }
2205         }
2206
2207         /* Do the same with properties etc.. */
2208         if (tb->events && mono_array_length (tb->events)) {
2209                 table = &assembly->tables [MONO_TABLE_EVENT];
2210                 table->rows += mono_array_length (tb->events);
2211                 alloc_table (table, table->rows);
2212                 table = &assembly->tables [MONO_TABLE_EVENTMAP];
2213                 table->rows ++;
2214                 alloc_table (table, table->rows);
2215                 values = table->values + table->rows * MONO_EVENT_MAP_SIZE;
2216                 values [MONO_EVENT_MAP_PARENT] = tb->table_idx;
2217                 values [MONO_EVENT_MAP_EVENTLIST] = assembly->tables [MONO_TABLE_EVENT].next_idx;
2218                 for (i = 0; i < mono_array_length (tb->events); ++i) {
2219                         mono_image_get_event_info (
2220                                 mono_array_get (tb->events, MonoReflectionEventBuilder*, i), assembly, error);
2221                         return_val_if_nok (error, FALSE);
2222                 }
2223         }
2224         if (tb->properties && mono_array_length (tb->properties)) {
2225                 table = &assembly->tables [MONO_TABLE_PROPERTY];
2226                 table->rows += mono_array_length (tb->properties);
2227                 alloc_table (table, table->rows);
2228                 table = &assembly->tables [MONO_TABLE_PROPERTYMAP];
2229                 table->rows ++;
2230                 alloc_table (table, table->rows);
2231                 values = table->values + table->rows * MONO_PROPERTY_MAP_SIZE;
2232                 values [MONO_PROPERTY_MAP_PARENT] = tb->table_idx;
2233                 values [MONO_PROPERTY_MAP_PROPERTY_LIST] = assembly->tables [MONO_TABLE_PROPERTY].next_idx;
2234                 for (i = 0; i < mono_array_length (tb->properties); ++i) {
2235                         mono_image_get_property_info (
2236                                 mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i), assembly, error);
2237                         return_val_if_nok (error, FALSE);
2238                 }
2239         }
2240
2241         /* handle generic parameters */
2242         if (tb->generic_params) {
2243                 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
2244                 table->rows += mono_array_length (tb->generic_params);
2245                 alloc_table (table, table->rows);
2246                 for (i = 0; i < mono_array_length (tb->generic_params); ++i) {
2247                         guint32 owner = MONO_TYPEORMETHOD_TYPE | (tb->table_idx << MONO_TYPEORMETHOD_BITS);
2248
2249                         mono_image_get_generic_param_info (
2250                                 mono_array_get (tb->generic_params, MonoReflectionGenericParam*, i), owner, assembly);
2251                 }
2252         }
2253
2254         mono_image_add_decl_security (assembly,
2255                 mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx), tb->permissions);
2256
2257         if (tb->subtypes) {
2258                 MonoDynamicTable *ntable;
2259
2260                 ntable = &assembly->tables [MONO_TABLE_NESTEDCLASS];
2261                 ntable->rows += mono_array_length (tb->subtypes);
2262                 alloc_table (ntable, ntable->rows);
2263                 values = ntable->values + ntable->next_idx * MONO_NESTED_CLASS_SIZE;
2264
2265                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
2266                         MonoReflectionTypeBuilder *subtype = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
2267
2268                         values [MONO_NESTED_CLASS_NESTED] = subtype->table_idx;
2269                         values [MONO_NESTED_CLASS_ENCLOSING] = tb->table_idx;
2270                         /*g_print ("nesting %s (%d) in %s (%d) (rows %d/%d)\n",
2271                                 mono_string_to_utf8 (subtype->name), subtype->table_idx,
2272                                 mono_string_to_utf8 (tb->name), tb->table_idx,
2273                                 ntable->next_idx, ntable->rows);*/
2274                         values += MONO_NESTED_CLASS_SIZE;
2275                         ntable->next_idx++;
2276                 }
2277         }
2278
2279         return TRUE;
2280 }
2281
2282
2283 /*
2284  * mono_image_build_metadata() will fill the info in all the needed metadata tables
2285  * for the modulebuilder @moduleb.
2286  * At the end of the process, method and field tokens are fixed up and the
2287  * on-disk compressed metadata representation is created.
2288  * Return TRUE on success, or FALSE on failure and sets @error
2289  */
2290 gboolean
2291 mono_image_build_metadata (MonoReflectionModuleBuilder *moduleb, MonoError *error)
2292 {
2293         MonoDynamicTable *table;
2294         MonoDynamicImage *assembly;
2295         MonoReflectionAssemblyBuilder *assemblyb;
2296         MonoDomain *domain;
2297         MonoPtrArray types;
2298         guint32 *values;
2299         int i, j;
2300
2301         mono_error_init (error);
2302
2303         assemblyb = moduleb->assemblyb;
2304         assembly = moduleb->dynamic_image;
2305         domain = mono_object_domain (assemblyb);
2306
2307         if (assembly->text_rva)
2308                 return TRUE;
2309
2310         assembly->text_rva = START_TEXT_RVA;
2311
2312         if (moduleb->is_main) {
2313                 mono_image_emit_manifest (moduleb, error);
2314                 return_val_if_nok (error, FALSE);
2315         }
2316
2317         table = &assembly->tables [MONO_TABLE_TYPEDEF];
2318         table->rows = 1; /* .<Module> */
2319         table->next_idx++;
2320         alloc_table (table, table->rows);
2321         /*
2322          * Set the first entry.
2323          */
2324         values = table->values + table->columns;
2325         values [MONO_TYPEDEF_FLAGS] = 0;
2326         values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, "<Module>") ;
2327         values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, "") ;
2328         values [MONO_TYPEDEF_EXTENDS] = 0;
2329         values [MONO_TYPEDEF_FIELD_LIST] = 1;
2330         values [MONO_TYPEDEF_METHOD_LIST] = 1;
2331
2332         /*
2333          * handle global methods
2334          * FIXME: test what to do when global methods are defined in multiple modules.
2335          */
2336         if (moduleb->global_methods) {
2337                 table = &assembly->tables [MONO_TABLE_METHOD];
2338                 table->rows += mono_array_length (moduleb->global_methods);
2339                 alloc_table (table, table->rows);
2340                 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
2341                         if (!mono_image_get_method_info (
2342                                     mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i), assembly, error))
2343                                 goto leave;
2344                 }
2345         }
2346         if (moduleb->global_fields) {
2347                 table = &assembly->tables [MONO_TABLE_FIELD];
2348                 table->rows += mono_array_length (moduleb->global_fields);
2349                 alloc_table (table, table->rows);
2350                 for (i = 0; i < mono_array_length (moduleb->global_fields); ++i) {
2351                         mono_image_get_field_info (
2352                                 mono_array_get (moduleb->global_fields, MonoReflectionFieldBuilder*, i), assembly,
2353                                 error);
2354                         if (!is_ok (error))
2355                                 goto leave;
2356                 }
2357         }
2358
2359         table = &assembly->tables [MONO_TABLE_MODULE];
2360         alloc_table (table, 1);
2361         mono_image_fill_module_table (domain, moduleb, assembly, error);
2362         if (!is_ok (error))
2363                 goto leave;
2364
2365         /* Collect all types into a list sorted by their table_idx */
2366         mono_ptr_array_init (types, moduleb->num_types, MONO_ROOT_SOURCE_REFLECTION, "dynamic module types list");
2367
2368         if (moduleb->types)
2369                 for (i = 0; i < moduleb->num_types; ++i) {
2370                         MonoReflectionTypeBuilder *type = mono_array_get (moduleb->types, MonoReflectionTypeBuilder*, i);
2371                         collect_types (&types, type);
2372                 }
2373
2374         mono_ptr_array_sort (types, (int (*)(const void *, const void *))compare_types_by_table_idx);
2375         table = &assembly->tables [MONO_TABLE_TYPEDEF];
2376         table->rows += mono_ptr_array_size (types);
2377         alloc_table (table, table->rows);
2378
2379         /*
2380          * Emit type names + namespaces at one place inside the string heap,
2381          * so load_class_names () needs to touch fewer pages.
2382          */
2383         for (i = 0; i < mono_ptr_array_size (types); ++i) {
2384                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
2385                 string_heap_insert_mstring (&assembly->sheap, tb->nspace, error);
2386                 if (!is_ok (error))
2387                         goto leave_types;
2388         }
2389         for (i = 0; i < mono_ptr_array_size (types); ++i) {
2390                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
2391                 string_heap_insert_mstring (&assembly->sheap, tb->name, error);
2392                 if (!is_ok (error))
2393                         goto leave_types;
2394         }
2395
2396         for (i = 0; i < mono_ptr_array_size (types); ++i) {
2397                 MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
2398                 if (!mono_image_get_type_info (domain, type, assembly, error))
2399                         goto leave_types;
2400         }
2401
2402         /*
2403          * table->rows is already set above and in mono_image_fill_module_table.
2404          */
2405         /* add all the custom attributes at the end, once all the indexes are stable */
2406         if (!mono_image_add_cattrs (assembly, 1, MONO_CUSTOM_ATTR_ASSEMBLY, assemblyb->cattrs, error))
2407                 goto leave_types;
2408
2409         /* CAS assembly permissions */
2410         if (assemblyb->permissions_minimum)
2411                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_minimum);
2412         if (assemblyb->permissions_optional)
2413                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_optional);
2414         if (assemblyb->permissions_refused)
2415                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_refused);
2416
2417         if (!module_add_cattrs (assembly, moduleb, error))
2418                 goto leave_types;
2419
2420         /* fixup tokens */
2421         mono_g_hash_table_foreach (assembly->token_fixups, (GHFunc)fixup_method, assembly);
2422
2423         /* Create the MethodImpl table.  We do this after emitting all methods so we already know
2424          * the final tokens and don't need another fixup pass. */
2425
2426         if (moduleb->global_methods) {
2427                 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
2428                         MonoReflectionMethodBuilder *mb = mono_array_get (
2429                                 moduleb->global_methods, MonoReflectionMethodBuilder*, i);
2430                         if (!mono_image_add_methodimpl (assembly, mb, error))
2431                                 goto leave_types;
2432                 }
2433         }
2434
2435         for (i = 0; i < mono_ptr_array_size (types); ++i) {
2436                 MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
2437                 if (type->methods) {
2438                         for (j = 0; j < type->num_methods; ++j) {
2439                                 MonoReflectionMethodBuilder *mb = mono_array_get (
2440                                         type->methods, MonoReflectionMethodBuilder*, j);
2441
2442                                 if (!mono_image_add_methodimpl (assembly, mb, error))
2443                                         goto leave_types;
2444                         }
2445                 }
2446         }
2447
2448         fixup_cattrs (assembly);
2449
2450 leave_types:
2451         mono_ptr_array_destroy (types);
2452 leave:
2453
2454         return mono_error_ok (error);
2455 }
2456
2457 #else /* DISABLE_REFLECTION_EMIT_SAVE */
2458
2459 gboolean
2460 mono_image_build_metadata (MonoReflectionModuleBuilder *moduleb, MonoError *error)
2461 {
2462         g_error ("This mono runtime was configured with --enable-minimal=reflection_emit_save, so saving of dynamic assemblies is not supported.");
2463 }
2464
2465 #endif /* DISABLE_REFLECTION_EMIT_SAVE */
2466
2467 #ifndef DISABLE_REFLECTION_EMIT_SAVE
2468
2469 static int
2470 calc_section_size (MonoDynamicImage *assembly)
2471 {
2472         int nsections = 0;
2473
2474         /* alignment constraints */
2475         mono_image_add_stream_zero (&assembly->code, 4 - (assembly->code.index % 4));
2476         g_assert ((assembly->code.index % 4) == 0);
2477         assembly->meta_size += 3;
2478         assembly->meta_size &= ~3;
2479         mono_image_add_stream_zero (&assembly->resources, 4 - (assembly->resources.index % 4));
2480         g_assert ((assembly->resources.index % 4) == 0);
2481
2482         assembly->sections [MONO_SECTION_TEXT].size = assembly->meta_size + assembly->code.index + assembly->resources.index + assembly->strong_name_size;
2483         assembly->sections [MONO_SECTION_TEXT].attrs = SECT_FLAGS_HAS_CODE | SECT_FLAGS_MEM_EXECUTE | SECT_FLAGS_MEM_READ;
2484         nsections++;
2485
2486         if (assembly->win32_res) {
2487                 guint32 res_size = (assembly->win32_res_size + 3) & ~3;
2488
2489                 assembly->sections [MONO_SECTION_RSRC].size = res_size;
2490                 assembly->sections [MONO_SECTION_RSRC].attrs = SECT_FLAGS_HAS_INITIALIZED_DATA | SECT_FLAGS_MEM_READ;
2491                 nsections++;
2492         }
2493
2494         assembly->sections [MONO_SECTION_RELOC].size = 12;
2495         assembly->sections [MONO_SECTION_RELOC].attrs = SECT_FLAGS_MEM_READ | SECT_FLAGS_MEM_DISCARDABLE | SECT_FLAGS_HAS_INITIALIZED_DATA;
2496         nsections++;
2497
2498         return nsections;
2499 }
2500
2501 typedef struct {
2502         guint32 id;
2503         guint32 offset;
2504         GSList *children;
2505         MonoReflectionWin32Resource *win32_res; /* Only for leaf nodes */
2506 } ResTreeNode;
2507
2508 static int
2509 resource_tree_compare_by_id (gconstpointer a, gconstpointer b)
2510 {
2511         ResTreeNode *t1 = (ResTreeNode*)a;
2512         ResTreeNode *t2 = (ResTreeNode*)b;
2513
2514         return t1->id - t2->id;
2515 }
2516
2517 /*
2518  * resource_tree_create:
2519  *
2520  *  Organize the resources into a resource tree.
2521  */
2522 static ResTreeNode *
2523 resource_tree_create (MonoArray *win32_resources)
2524 {
2525         ResTreeNode *tree, *res_node, *type_node, *lang_node;
2526         GSList *l;
2527         int i;
2528
2529         tree = g_new0 (ResTreeNode, 1);
2530
2531         for (i = 0; i < mono_array_length (win32_resources); ++i) {
2532                 MonoReflectionWin32Resource *win32_res =
2533                         (MonoReflectionWin32Resource*)mono_array_addr (win32_resources, MonoReflectionWin32Resource, i);
2534
2535                 /* Create node */
2536
2537                 /* FIXME: BUG: this stores managed references in unmanaged memory */
2538                 lang_node = g_new0 (ResTreeNode, 1);
2539                 lang_node->id = win32_res->lang_id;
2540                 lang_node->win32_res = win32_res;
2541
2542                 /* Create type node if neccesary */
2543                 type_node = NULL;
2544                 for (l = tree->children; l; l = l->next)
2545                         if (((ResTreeNode*)(l->data))->id == win32_res->res_type) {
2546                                 type_node = (ResTreeNode*)l->data;
2547                                 break;
2548                         }
2549
2550                 if (!type_node) {
2551                         type_node = g_new0 (ResTreeNode, 1);
2552                         type_node->id = win32_res->res_type;
2553
2554                         /*
2555                          * The resource types have to be sorted otherwise
2556                          * Windows Explorer can't display the version information.
2557                          */
2558                         tree->children = g_slist_insert_sorted (tree->children,
2559                                 type_node, resource_tree_compare_by_id);
2560                 }
2561
2562                 /* Create res node if neccesary */
2563                 res_node = NULL;
2564                 for (l = type_node->children; l; l = l->next)
2565                         if (((ResTreeNode*)(l->data))->id == win32_res->res_id) {
2566                                 res_node = (ResTreeNode*)l->data;
2567                                 break;
2568                         }
2569
2570                 if (!res_node) {
2571                         res_node = g_new0 (ResTreeNode, 1);
2572                         res_node->id = win32_res->res_id;
2573                         type_node->children = g_slist_append (type_node->children, res_node);
2574                 }
2575
2576                 res_node->children = g_slist_append (res_node->children, lang_node);
2577         }
2578
2579         return tree;
2580 }
2581
2582 /*
2583  * resource_tree_encode:
2584  *
2585  *   Encode the resource tree into the format used in the PE file.
2586  */
2587 static void
2588 resource_tree_encode (ResTreeNode *node, char *begin, char *p, char **endbuf)
2589 {
2590         char *entries;
2591         MonoPEResourceDir dir;
2592         MonoPEResourceDirEntry dir_entry;
2593         MonoPEResourceDataEntry data_entry;
2594         GSList *l;
2595         guint32 res_id_entries;
2596
2597         /*
2598          * For the format of the resource directory, see the article
2599          * "An In-Depth Look into the Win32 Portable Executable File Format" by
2600          * Matt Pietrek
2601          */
2602
2603         memset (&dir, 0, sizeof (dir));
2604         memset (&dir_entry, 0, sizeof (dir_entry));
2605         memset (&data_entry, 0, sizeof (data_entry));
2606
2607         g_assert (sizeof (dir) == 16);
2608         g_assert (sizeof (dir_entry) == 8);
2609         g_assert (sizeof (data_entry) == 16);
2610
2611         node->offset = p - begin;
2612
2613         /* IMAGE_RESOURCE_DIRECTORY */
2614         res_id_entries = g_slist_length (node->children);
2615         dir.res_id_entries = GUINT16_TO_LE (res_id_entries);
2616
2617         memcpy (p, &dir, sizeof (dir));
2618         p += sizeof (dir);
2619
2620         /* Reserve space for entries */
2621         entries = p;
2622         p += sizeof (dir_entry) * res_id_entries;
2623
2624         /* Write children */
2625         for (l = node->children; l; l = l->next) {
2626                 ResTreeNode *child = (ResTreeNode*)l->data;
2627
2628                 if (child->win32_res) {
2629                         guint32 size;
2630
2631                         child->offset = p - begin;
2632
2633                         /* IMAGE_RESOURCE_DATA_ENTRY */
2634                         data_entry.rde_data_offset = GUINT32_TO_LE (p - begin + sizeof (data_entry));
2635                         size = mono_array_length (child->win32_res->res_data);
2636                         data_entry.rde_size = GUINT32_TO_LE (size);
2637
2638                         memcpy (p, &data_entry, sizeof (data_entry));
2639                         p += sizeof (data_entry);
2640
2641                         memcpy (p, mono_array_addr (child->win32_res->res_data, char, 0), size);
2642                         p += size;
2643                 } else {
2644                         resource_tree_encode (child, begin, p, &p);
2645                 }
2646         }
2647
2648         /* IMAGE_RESOURCE_ENTRY */
2649         for (l = node->children; l; l = l->next) {
2650                 ResTreeNode *child = (ResTreeNode*)l->data;
2651
2652                 MONO_PE_RES_DIR_ENTRY_SET_NAME (dir_entry, FALSE, child->id);
2653                 MONO_PE_RES_DIR_ENTRY_SET_DIR (dir_entry, !child->win32_res, child->offset);
2654
2655                 memcpy (entries, &dir_entry, sizeof (dir_entry));
2656                 entries += sizeof (dir_entry);
2657         }
2658
2659         *endbuf = p;
2660 }
2661
2662 static void
2663 resource_tree_free (ResTreeNode * node)
2664 {
2665         GSList * list;
2666         for (list = node->children; list; list = list->next)
2667                 resource_tree_free ((ResTreeNode*)list->data);
2668         g_slist_free(node->children);
2669         g_free (node);
2670 }
2671
2672 static void
2673 assembly_add_win32_resources (MonoDynamicImage *assembly, MonoReflectionAssemblyBuilder *assemblyb)
2674 {
2675         char *buf;
2676         char *p;
2677         guint32 size, i;
2678         MonoReflectionWin32Resource *win32_res;
2679         ResTreeNode *tree;
2680
2681         if (!assemblyb->win32_resources)
2682                 return;
2683
2684         /*
2685          * Resources are stored in a three level tree inside the PE file.
2686          * - level one contains a node for each type of resource
2687          * - level two contains a node for each resource
2688          * - level three contains a node for each instance of a resource for a
2689          *   specific language.
2690          */
2691
2692         tree = resource_tree_create (assemblyb->win32_resources);
2693
2694         /* Estimate the size of the encoded tree */
2695         size = 0;
2696         for (i = 0; i < mono_array_length (assemblyb->win32_resources); ++i) {
2697                 win32_res = (MonoReflectionWin32Resource*)mono_array_addr (assemblyb->win32_resources, MonoReflectionWin32Resource, i);
2698                 size += mono_array_length (win32_res->res_data);
2699         }
2700         /* Directory structure */
2701         size += mono_array_length (assemblyb->win32_resources) * 256;
2702         p = buf = (char *)g_malloc (size);
2703
2704         resource_tree_encode (tree, p, p, &p);
2705
2706         g_assert (p - buf <= size);
2707
2708         assembly->win32_res = (char *)g_malloc (p - buf);
2709         assembly->win32_res_size = p - buf;
2710         memcpy (assembly->win32_res, buf, p - buf);
2711
2712         g_free (buf);
2713         resource_tree_free (tree);
2714 }
2715
2716 static void
2717 fixup_resource_directory (char *res_section, char *p, guint32 rva)
2718 {
2719         MonoPEResourceDir *dir = (MonoPEResourceDir*)p;
2720         int i;
2721
2722         p += sizeof (MonoPEResourceDir);
2723         for (i = 0; i < GUINT16_FROM_LE (dir->res_named_entries) + GUINT16_FROM_LE (dir->res_id_entries); ++i) {
2724                 MonoPEResourceDirEntry *dir_entry = (MonoPEResourceDirEntry*)p;
2725                 char *child = res_section + MONO_PE_RES_DIR_ENTRY_DIR_OFFSET (*dir_entry);
2726                 if (MONO_PE_RES_DIR_ENTRY_IS_DIR (*dir_entry)) {
2727                         fixup_resource_directory (res_section, child, rva);
2728                 } else {
2729                         MonoPEResourceDataEntry *data_entry = (MonoPEResourceDataEntry*)child;
2730                         data_entry->rde_data_offset = GUINT32_TO_LE (GUINT32_FROM_LE (data_entry->rde_data_offset) + rva);
2731                 }
2732
2733                 p += sizeof (MonoPEResourceDirEntry);
2734         }
2735 }
2736
2737 static void
2738 checked_write_file (HANDLE f, gconstpointer buffer, guint32 numbytes)
2739 {
2740         guint32 dummy;
2741         if (!mono_w32file_write (f, buffer, numbytes, &dummy))
2742                 g_error ("mono_w32file_write returned %d\n", GetLastError ());
2743 }
2744
2745 /*
2746  * mono_image_create_pefile:
2747  * @mb: a module builder object
2748  *
2749  * This function creates the PE-COFF header, the image sections, the CLI header  * etc. all the data is written in
2750  * assembly->pefile where it can be easily retrieved later in chunks.
2751  */
2752 gboolean
2753 mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file, MonoError *error)
2754 {
2755         MonoMSDOSHeader *msdos;
2756         MonoDotNetHeader *header;
2757         MonoSectionTable *section;
2758         MonoCLIHeader *cli_header;
2759         guint32 size, image_size, virtual_base, text_offset;
2760         guint32 header_start, section_start, file_offset, virtual_offset;
2761         MonoDynamicImage *assembly;
2762         MonoReflectionAssemblyBuilder *assemblyb;
2763         MonoDynamicStream pefile_stream = {0};
2764         MonoDynamicStream *pefile = &pefile_stream;
2765         int i, nsections;
2766         guint32 *rva, value;
2767         guchar *p;
2768         static const unsigned char msheader[] = {
2769                 0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00,  0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
2770                 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2771                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2772                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
2773                 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd,  0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21, 0x54, 0x68,
2774                 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72,  0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f,
2775                 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6e,  0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
2776                 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a,  0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2777         };
2778
2779         mono_error_init (error);
2780
2781         assemblyb = mb->assemblyb;
2782
2783         mono_reflection_dynimage_basic_init (assemblyb);
2784         assembly = mb->dynamic_image;
2785
2786         assembly->pe_kind = assemblyb->pe_kind;
2787         assembly->machine = assemblyb->machine;
2788         ((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->pe_kind = assemblyb->pe_kind;
2789         ((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->machine = assemblyb->machine;
2790
2791         if (!mono_image_build_metadata (mb, error))
2792                 return FALSE;
2793
2794
2795         if (mb->is_main && assemblyb->resources) {
2796                 int len = mono_array_length (assemblyb->resources);
2797                 for (i = 0; i < len; ++i) {
2798                         if (!assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (assemblyb->resources, MonoReflectionResource, i), error))
2799                                 return FALSE;
2800                 }
2801         }
2802
2803         if (mb->resources) {
2804                 int len = mono_array_length (mb->resources);
2805                 for (i = 0; i < len; ++i) {
2806                         if (!assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (mb->resources, MonoReflectionResource, i), error))
2807                                 return FALSE;
2808                 }
2809         }
2810
2811         if (!build_compressed_metadata (assembly, error))
2812                 return FALSE;
2813
2814         if (mb->is_main)
2815                 assembly_add_win32_resources (assembly, assemblyb);
2816
2817         nsections = calc_section_size (assembly);
2818
2819         /* The DOS header and stub */
2820         g_assert (sizeof (MonoMSDOSHeader) == sizeof (msheader));
2821         mono_image_add_stream_data (pefile, (char*)msheader, sizeof (msheader));
2822
2823         /* the dotnet header */
2824         header_start = mono_image_add_stream_zero (pefile, sizeof (MonoDotNetHeader));
2825
2826         /* the section tables */
2827         section_start = mono_image_add_stream_zero (pefile, sizeof (MonoSectionTable) * nsections);
2828
2829         file_offset = section_start + sizeof (MonoSectionTable) * nsections;
2830         virtual_offset = VIRT_ALIGN;
2831         image_size = 0;
2832
2833         for (i = 0; i < MONO_SECTION_MAX; ++i) {
2834                 if (!assembly->sections [i].size)
2835                         continue;
2836                 /* align offsets */
2837                 file_offset += FILE_ALIGN - 1;
2838                 file_offset &= ~(FILE_ALIGN - 1);
2839                 virtual_offset += VIRT_ALIGN - 1;
2840                 virtual_offset &= ~(VIRT_ALIGN - 1);
2841
2842                 assembly->sections [i].offset = file_offset;
2843                 assembly->sections [i].rva = virtual_offset;
2844
2845                 file_offset += assembly->sections [i].size;
2846                 virtual_offset += assembly->sections [i].size;
2847                 image_size += (assembly->sections [i].size + VIRT_ALIGN - 1) & ~(VIRT_ALIGN - 1);
2848         }
2849
2850         file_offset += FILE_ALIGN - 1;
2851         file_offset &= ~(FILE_ALIGN - 1);
2852
2853         image_size += section_start + sizeof (MonoSectionTable) * nsections;
2854
2855         /* back-patch info */
2856         msdos = (MonoMSDOSHeader*)pefile->data;
2857         msdos->pe_offset = GUINT32_FROM_LE (sizeof (MonoMSDOSHeader));
2858
2859         header = (MonoDotNetHeader*)(pefile->data + header_start);
2860         header->pesig [0] = 'P';
2861         header->pesig [1] = 'E';
2862
2863         header->coff.coff_machine = GUINT16_FROM_LE (assemblyb->machine);
2864         header->coff.coff_sections = GUINT16_FROM_LE (nsections);
2865         header->coff.coff_time = GUINT32_FROM_LE (time (NULL));
2866         header->coff.coff_opt_header_size = GUINT16_FROM_LE (sizeof (MonoDotNetHeader) - sizeof (MonoCOFFHeader) - 4);
2867         if (assemblyb->pekind == 1) {
2868                 /* it's a dll */
2869                 header->coff.coff_attributes = GUINT16_FROM_LE (0x210e);
2870         } else {
2871                 /* it's an exe */
2872                 header->coff.coff_attributes = GUINT16_FROM_LE (0x010e);
2873         }
2874
2875         virtual_base = 0x400000; /* FIXME: 0x10000000 if a DLL */
2876
2877         header->pe.pe_magic = GUINT16_FROM_LE (0x10B);
2878         header->pe.pe_major = 6;
2879         header->pe.pe_minor = 0;
2880         size = assembly->sections [MONO_SECTION_TEXT].size;
2881         size += FILE_ALIGN - 1;
2882         size &= ~(FILE_ALIGN - 1);
2883         header->pe.pe_code_size = GUINT32_FROM_LE(size);
2884         size = assembly->sections [MONO_SECTION_RSRC].size;
2885         size += FILE_ALIGN - 1;
2886         size &= ~(FILE_ALIGN - 1);
2887         header->pe.pe_data_size = GUINT32_FROM_LE(size);
2888         g_assert (START_TEXT_RVA == assembly->sections [MONO_SECTION_TEXT].rva);
2889         header->pe.pe_rva_code_base = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_TEXT].rva);
2890         header->pe.pe_rva_data_base = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].rva);
2891         /* pe_rva_entry_point always at the beginning of the text section */
2892         header->pe.pe_rva_entry_point = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_TEXT].rva);
2893
2894         header->nt.pe_image_base = GUINT32_FROM_LE (virtual_base);
2895         header->nt.pe_section_align = GUINT32_FROM_LE (VIRT_ALIGN);
2896         header->nt.pe_file_alignment = GUINT32_FROM_LE (FILE_ALIGN);
2897         header->nt.pe_os_major = GUINT16_FROM_LE (4);
2898         header->nt.pe_os_minor = GUINT16_FROM_LE (0);
2899         header->nt.pe_subsys_major = GUINT16_FROM_LE (4);
2900         size = section_start;
2901         size += FILE_ALIGN - 1;
2902         size &= ~(FILE_ALIGN - 1);
2903         header->nt.pe_header_size = GUINT32_FROM_LE (size);
2904         size = image_size;
2905         size += VIRT_ALIGN - 1;
2906         size &= ~(VIRT_ALIGN - 1);
2907         header->nt.pe_image_size = GUINT32_FROM_LE (size);
2908
2909         /*
2910         // Translate the PEFileKind value to the value expected by the Windows loader
2911         */
2912         {
2913                 short kind;
2914
2915                 /*
2916                 // PEFileKinds.Dll == 1
2917                 // PEFileKinds.ConsoleApplication == 2
2918                 // PEFileKinds.WindowApplication == 3
2919                 //
2920                 // need to get:
2921                 //     IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem.
2922                 //     IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem.
2923                 */
2924                 if (assemblyb->pekind == 3)
2925                         kind = 2;
2926                 else
2927                         kind = 3;
2928
2929                 header->nt.pe_subsys_required = GUINT16_FROM_LE (kind);
2930         }
2931         header->nt.pe_stack_reserve = GUINT32_FROM_LE (0x00100000);
2932         header->nt.pe_stack_commit = GUINT32_FROM_LE (0x00001000);
2933         header->nt.pe_heap_reserve = GUINT32_FROM_LE (0x00100000);
2934         header->nt.pe_heap_commit = GUINT32_FROM_LE (0x00001000);
2935         header->nt.pe_loader_flags = GUINT32_FROM_LE (0);
2936         header->nt.pe_data_dir_count = GUINT32_FROM_LE (16);
2937
2938         /* fill data directory entries */
2939
2940         header->datadir.pe_resource_table.size = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].size);
2941         header->datadir.pe_resource_table.rva = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].rva);
2942
2943         header->datadir.pe_reloc_table.size = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RELOC].size);
2944         header->datadir.pe_reloc_table.rva = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RELOC].rva);
2945
2946         header->datadir.pe_cli_header.size = GUINT32_FROM_LE (72);
2947         header->datadir.pe_cli_header.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->cli_header_offset);
2948         header->datadir.pe_iat.size = GUINT32_FROM_LE (8);
2949         header->datadir.pe_iat.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->iat_offset);
2950         /* patch entrypoint name */
2951         if (assemblyb->pekind == 1)
2952                 memcpy (assembly->code.data + assembly->imp_names_offset + 2, "_CorDllMain", 12);
2953         else
2954                 memcpy (assembly->code.data + assembly->imp_names_offset + 2, "_CorExeMain", 12);
2955         /* patch imported function RVA name */
2956         rva = (guint32*)(assembly->code.data + assembly->iat_offset);
2957         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->imp_names_offset);
2958
2959         /* the import table */
2960         header->datadir.pe_import_table.size = GUINT32_FROM_LE (79); /* FIXME: magic number? */
2961         header->datadir.pe_import_table.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->idt_offset);
2962         /* patch imported dll RVA name and other entries in the dir */
2963         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, name_rva));
2964         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->imp_names_offset + 14); /* 14 is hint+strlen+1 of func name */
2965         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, import_address_table_rva));
2966         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->iat_offset);
2967         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, import_lookup_table));
2968         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->ilt_offset);
2969
2970         p = (guchar*)(assembly->code.data + assembly->ilt_offset);
2971         value = (assembly->text_rva + assembly->imp_names_offset);
2972         *p++ = (value) & 0xff;
2973         *p++ = (value >> 8) & (0xff);
2974         *p++ = (value >> 16) & (0xff);
2975         *p++ = (value >> 24) & (0xff);
2976
2977         /* the CLI header info */
2978         cli_header = (MonoCLIHeader*)(assembly->code.data + assembly->cli_header_offset);
2979         cli_header->ch_size = GUINT32_FROM_LE (72);
2980         cli_header->ch_runtime_major = GUINT16_FROM_LE (2);
2981         cli_header->ch_runtime_minor = GUINT16_FROM_LE (5);
2982         cli_header->ch_flags = GUINT32_FROM_LE (assemblyb->pe_kind);
2983         if (assemblyb->entry_point) {
2984                 guint32 table_idx = 0;
2985                 if (!strcmp (assemblyb->entry_point->object.vtable->klass->name, "MethodBuilder")) {
2986                         MonoReflectionMethodBuilder *methodb = (MonoReflectionMethodBuilder*)assemblyb->entry_point;
2987                         table_idx = methodb->table_idx;
2988                 } else {
2989                         table_idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, assemblyb->entry_point->method));
2990                 }
2991                 cli_header->ch_entry_point = GUINT32_FROM_LE (table_idx | MONO_TOKEN_METHOD_DEF);
2992         } else {
2993                 cli_header->ch_entry_point = GUINT32_FROM_LE (0);
2994         }
2995         /* The embedded managed resources */
2996         text_offset = assembly->text_rva + assembly->code.index;
2997         cli_header->ch_resources.rva = GUINT32_FROM_LE (text_offset);
2998         cli_header->ch_resources.size = GUINT32_FROM_LE (assembly->resources.index);
2999         text_offset += assembly->resources.index;
3000         cli_header->ch_metadata.rva = GUINT32_FROM_LE (text_offset);
3001         cli_header->ch_metadata.size = GUINT32_FROM_LE (assembly->meta_size);
3002         text_offset += assembly->meta_size;
3003         if (assembly->strong_name_size) {
3004                 cli_header->ch_strong_name.rva = GUINT32_FROM_LE (text_offset);
3005                 cli_header->ch_strong_name.size = GUINT32_FROM_LE (assembly->strong_name_size);
3006                 text_offset += assembly->strong_name_size;
3007         }
3008
3009         /* write the section tables and section content */
3010         section = (MonoSectionTable*)(pefile->data + section_start);
3011         for (i = 0; i < MONO_SECTION_MAX; ++i) {
3012                 static const char section_names [][7] = {
3013                         ".text", ".rsrc", ".reloc"
3014                 };
3015                 if (!assembly->sections [i].size)
3016                         continue;
3017                 strcpy (section->st_name, section_names [i]);
3018                 /*g_print ("output section %s (%d), size: %d\n", section->st_name, i, assembly->sections [i].size);*/
3019                 section->st_virtual_address = GUINT32_FROM_LE (assembly->sections [i].rva);
3020                 section->st_virtual_size = GUINT32_FROM_LE (assembly->sections [i].size);
3021                 section->st_raw_data_size = GUINT32_FROM_LE (GUINT32_TO_LE (section->st_virtual_size) + (FILE_ALIGN - 1));
3022                 section->st_raw_data_size &= GUINT32_FROM_LE (~(FILE_ALIGN - 1));
3023                 section->st_raw_data_ptr = GUINT32_FROM_LE (assembly->sections [i].offset);
3024                 section->st_flags = GUINT32_FROM_LE (assembly->sections [i].attrs);
3025                 section ++;
3026         }
3027
3028         checked_write_file (file, pefile->data, pefile->index);
3029
3030         mono_dynamic_stream_reset (pefile);
3031
3032         for (i = 0; i < MONO_SECTION_MAX; ++i) {
3033                 if (!assembly->sections [i].size)
3034                         continue;
3035
3036                 if (mono_w32file_seek (file, assembly->sections [i].offset, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
3037                         g_error ("mono_w32file_seek returned %d\n", GetLastError ());
3038
3039                 switch (i) {
3040                 case MONO_SECTION_TEXT:
3041                         /* patch entry point */
3042                         p = (guchar*)(assembly->code.data + 2);
3043                         value = (virtual_base + assembly->text_rva + assembly->iat_offset);
3044                         *p++ = (value) & 0xff;
3045                         *p++ = (value >> 8) & 0xff;
3046                         *p++ = (value >> 16) & 0xff;
3047                         *p++ = (value >> 24) & 0xff;
3048
3049                         checked_write_file (file, assembly->code.data, assembly->code.index);
3050                         checked_write_file (file, assembly->resources.data, assembly->resources.index);
3051                         checked_write_file (file, assembly->image.raw_metadata, assembly->meta_size);
3052                         checked_write_file (file, assembly->strong_name, assembly->strong_name_size);
3053
3054
3055                         g_free (assembly->image.raw_metadata);
3056                         break;
3057                 case MONO_SECTION_RELOC: {
3058                         struct {
3059                                 guint32 page_rva;
3060                                 guint32 block_size;
3061                                 guint16 type_and_offset;
3062                                 guint16 term;
3063                         } reloc;
3064
3065                         g_assert (sizeof (reloc) == 12);
3066
3067                         reloc.page_rva = GUINT32_FROM_LE (assembly->text_rva);
3068                         reloc.block_size = GUINT32_FROM_LE (12);
3069
3070                         /*
3071                          * the entrypoint is always at the start of the text section
3072                          * 3 is IMAGE_REL_BASED_HIGHLOW
3073                          * 2 is patch_size_rva - text_rva
3074                          */
3075                         reloc.type_and_offset = GUINT16_FROM_LE ((3 << 12) + (2));
3076                         reloc.term = 0;
3077
3078                         checked_write_file (file, &reloc, sizeof (reloc));
3079
3080                         break;
3081                 }
3082                 case MONO_SECTION_RSRC:
3083                         if (assembly->win32_res) {
3084
3085                                 /* Fixup the offsets in the IMAGE_RESOURCE_DATA_ENTRY structures */
3086                                 fixup_resource_directory (assembly->win32_res, assembly->win32_res, assembly->sections [i].rva);
3087                                 checked_write_file (file, assembly->win32_res, assembly->win32_res_size);
3088                         }
3089                         break;
3090                 default:
3091                         g_assert_not_reached ();
3092                 }
3093         }
3094
3095         /* check that the file is properly padded */
3096         if (mono_w32file_seek (file, file_offset, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
3097                 g_error ("mono_w32file_seek returned %d\n", GetLastError ());
3098         if (! mono_w32file_truncate (file))
3099                 g_error ("mono_w32file_truncate returned %d\n", GetLastError ());
3100
3101         mono_dynamic_stream_reset (&assembly->code);
3102         mono_dynamic_stream_reset (&assembly->us);
3103         mono_dynamic_stream_reset (&assembly->blob);
3104         mono_dynamic_stream_reset (&assembly->guid);
3105         mono_dynamic_stream_reset (&assembly->sheap);
3106
3107         g_hash_table_foreach (assembly->blob_cache, (GHFunc)g_free, NULL);
3108         g_hash_table_destroy (assembly->blob_cache);
3109         assembly->blob_cache = NULL;
3110
3111         return TRUE;
3112 }
3113
3114 #else /* DISABLE_REFLECTION_EMIT_SAVE */
3115
3116 gboolean
3117 mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file, MonoError *error)
3118 {
3119         g_assert_not_reached ();
3120 }
3121
3122 #endif /* DISABLE_REFLECTION_EMIT_SAVE */
3123