mono/metadata/sre.c

   1 /**
   2  * \file
   3  * Routines for creating an image at runtime
   4  * and related System.Reflection.Emit icalls
   5  *
   6  *
   7  * Author:
   8  *   Paolo Molaro (lupus@ximian.com)
   9  *
  10  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  11  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  12  * Copyright 2011 Rodrigo Kumpera
  13  * Copyright 2016 Microsoft
  14  *
  15  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  16  */
  17 #include <config.h>
  18 #include <glib.h>
  19 #include "mono/metadata/assembly.h"
  20 #include "mono/metadata/debug-helpers.h"
  21 #include "mono/metadata/dynamic-image-internals.h"
  22 #include "mono/metadata/dynamic-stream-internals.h"
  23 #include "mono/metadata/exception.h"
  24 #include "mono/metadata/gc-internals.h"
  25 #include "mono/metadata/mono-ptr-array.h"
  26 #include "mono/metadata/object-internals.h"
  27 #include "mono/metadata/profiler-private.h"
  28 #include "mono/metadata/reflection-internals.h"
  29 #include "mono/metadata/reflection-cache.h"
  30 #include "mono/metadata/sre-internals.h"
  31 #include "mono/metadata/custom-attrs-internals.h"
  32 #include "mono/metadata/security-manager.h"
  33 #include "mono/metadata/security-core-clr.h"
  34 #include "mono/metadata/tabledefs.h"
  35 #include "mono/metadata/tokentype.h"
  36 #include "mono/utils/checked-build.h"
  37 #include "mono/utils/mono-digest.h"
  38 #include "mono/utils/w32api.h"
  39
  40 static GENERATE_GET_CLASS_WITH_CACHE (marshal_as_attribute, "System.Runtime.InteropServices", "MarshalAsAttribute");
  41 static GENERATE_GET_CLASS_WITH_CACHE (module_builder, "System.Reflection.Emit", "ModuleBuilder");
  42
  43 static char* string_to_utf8_image_raw (MonoImage *image, MonoString *s, MonoError *error);
  44
  45 #ifndef DISABLE_REFLECTION_EMIT
  46 static guint32 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelperHandle helper, MonoError *error);
  47 static gboolean ensure_runtime_vtable (MonoClass *klass, MonoError  *error);
  48 static void reflection_methodbuilder_from_dynamic_method (ReflectionMethodBuilder *rmb, MonoReflectionDynamicMethod *mb);
  49 static gboolean reflection_setup_internal_class (MonoReflectionTypeBuilderHandle tb, MonoError *error);
  50 static gboolean reflection_init_generic_class (MonoReflectionTypeBuilderHandle tb, MonoError *error);
  51 static gboolean reflection_setup_class_hierarchy (GHashTable *unparented, MonoError *error);
  52
  53
  54 static gpointer register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly);
  55 #endif
  56
  57 static char*   type_get_qualified_name (MonoType *type, MonoAssembly *ass);
  58 static MonoReflectionTypeHandle mono_reflection_type_get_underlying_system_type (MonoReflectionTypeHandle t, MonoError *error);
  59 static gboolean is_sre_array (MonoClass *klass);
  60 static gboolean is_sre_byref (MonoClass *klass);
  61 static gboolean is_sre_pointer (MonoClass *klass);
  62 static gboolean is_sre_generic_instance (MonoClass *klass);
  63 static gboolean is_sre_type_builder (MonoClass *klass);
  64 static gboolean is_sre_method_builder (MonoClass *klass);
  65 static gboolean is_sre_field_builder (MonoClass *klass);
  66 static gboolean is_sre_gparam_builder (MonoClass *klass);
  67 static gboolean is_sre_enum_builder (MonoClass *klass);
  68 static gboolean is_sr_mono_method (MonoClass *klass);
  69 static gboolean is_sr_mono_field (MonoClass *klass);
  70
  71 static guint32 mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *method);
  72 static guint32 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m);
  73 static guint32 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObjectHandle obj, MonoArrayHandle opt_param_types, MonoError *error);
  74
  75
  76 #ifndef DISABLE_REFLECTION_EMIT
  77 static MonoType* mono_type_array_get_and_resolve_raw (MonoArray* array, int idx, MonoError* error);
  78 #endif
  79
  80 static gboolean mono_image_module_basic_init (MonoReflectionModuleBuilderHandle module, MonoError *error);
  81
  82 void
  83 mono_reflection_emit_init (void)
  84 {
  85         mono_dynamic_images_init ();
  86 }
  87
  88 char*
  89 string_to_utf8_image_raw (MonoImage *image, MonoString *s_raw, MonoError *error)
  90 {
  91         /* FIXME all callers to string_to_utf8_image_raw should use handles */
  92         HANDLE_FUNCTION_ENTER ();
  93         char* result = NULL;
  94         error_init (error);
  95         MONO_HANDLE_DCL (MonoString, s);
  96         result = mono_string_to_utf8_image (image, s, error);
  97         HANDLE_FUNCTION_RETURN_VAL (result);
  98 }
  99
 100 static char*
 101 type_get_fully_qualified_name (MonoType *type)
 102 {
 103         MONO_REQ_GC_NEUTRAL_MODE;
 104
 105         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
 106 }
 107
 108 static char*
 109 type_get_qualified_name (MonoType *type, MonoAssembly *ass)
 110 {
 111         MONO_REQ_GC_UNSAFE_MODE;
 112
 113         MonoClass *klass;
 114         MonoAssembly *ta;
 115
 116         klass = mono_class_from_mono_type (type);
 117         if (!klass)
 118                 return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_REFLECTION);
 119         ta = klass->image->assembly;
 120         if (assembly_is_dynamic (ta) || (ta == ass)) {
 121                 if (mono_class_is_ginst (klass) || mono_class_is_gtd (klass))
 122                         /* For generic type definitions, we want T, while REFLECTION returns T<K> */
 123                         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_FULL_NAME);
 124                 else
 125                         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_REFLECTION);
 126         }
 127
 128         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
 129 }
 130
 131 #ifndef DISABLE_REFLECTION_EMIT
 132 /**
 133  * mp_g_alloc:
 134  *
 135  * Allocate memory from the @image mempool if it is non-NULL. Otherwise, allocate memory
 136  * from the C heap.
 137  */
 138 static gpointer
 139 image_g_malloc (MonoImage *image, guint size)
 140 {
 141         MONO_REQ_GC_NEUTRAL_MODE;
 142
 143         if (image)
 144                 return mono_image_alloc (image, size);
 145         else
 146                 return g_malloc (size);
 147 }
 148 #endif /* !DISABLE_REFLECTION_EMIT */
 149
 150 /**
 151  * image_g_alloc0:
 152  *
 153  * Allocate memory from the @image mempool if it is non-NULL. Otherwise, allocate memory
 154  * from the C heap.
 155  */
 156 gpointer
 157 mono_image_g_malloc0 (MonoImage *image, guint size)
 158 {
 159         MONO_REQ_GC_NEUTRAL_MODE;
 160
 161         if (image)
 162                 return mono_image_alloc0 (image, size);
 163         else
 164                 return g_malloc0 (size);
 165 }
 166
 167 /**
 168  * image_g_free:
 169  * @image: a MonoImage
 170  * @ptr: pointer
 171  *
 172  * If @image is NULL, free @ptr, otherwise do nothing.
 173  */
 174 static void
 175 image_g_free (MonoImage *image, gpointer ptr)
 176 {
 177         if (image == NULL)
 178                 g_free (ptr);
 179 }
 180
 181 #ifndef DISABLE_REFLECTION_EMIT
 182 static char*
 183 image_strdup (MonoImage *image, const char *s)
 184 {
 185         MONO_REQ_GC_NEUTRAL_MODE;
 186
 187         if (image)
 188                 return mono_image_strdup (image, s);
 189         else
 190                 return g_strdup (s);
 191 }
 192 #endif
 193
 194 #define image_g_new(image,struct_type, n_structs)               \
 195     ((struct_type *) image_g_malloc (image, ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
 196
 197 #define image_g_new0(image,struct_type, n_structs)              \
 198     ((struct_type *) mono_image_g_malloc0 (image, ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
 199
 200
 201 static void
 202 alloc_table (MonoDynamicTable *table, guint nrows)
 203 {
 204         mono_dynimage_alloc_table (table, nrows);
 205 }
 206
 207 static guint32
 208 string_heap_insert (MonoDynamicStream *sh, const char *str)
 209 {
 210         return mono_dynstream_insert_string (sh, str);
 211 }
 212
 213 static guint32
 214 mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
 215 {
 216         return mono_dynstream_add_data (stream, data, len);
 217 }
 218
 219 /*
 220  * Despite the name, we handle also TypeSpec (with the above helper).
 221  */
 222 static guint32
 223 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type)
 224 {
 225         return mono_dynimage_encode_typedef_or_ref_full (assembly, type, TRUE);
 226 }
 227
 228 /*
 229  * Copy len * nelem bytes from val to dest, swapping bytes to LE if necessary.
 230  * dest may be misaligned.
 231  */
 232 static void
 233 swap_with_size (char *dest, const char* val, int len, int nelem) {
 234         MONO_REQ_GC_NEUTRAL_MODE;
 235 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 236         int elem;
 237
 238         for (elem = 0; elem < nelem; ++elem) {
 239                 switch (len) {
 240                 case 1:
 241                         *dest = *val;
 242                         break;
 243                 case 2:
 244                         dest [0] = val [1];
 245                         dest [1] = val [0];
 246                         break;
 247                 case 4:
 248                         dest [0] = val [3];
 249                         dest [1] = val [2];
 250                         dest [2] = val [1];
 251                         dest [3] = val [0];
 252                         break;
 253                 case 8:
 254                         dest [0] = val [7];
 255                         dest [1] = val [6];
 256                         dest [2] = val [5];
 257                         dest [3] = val [4];
 258                         dest [4] = val [3];
 259                         dest [5] = val [2];
 260                         dest [6] = val [1];
 261                         dest [7] = val [0];
 262                         break;
 263                 default:
 264                         g_assert_not_reached ();
 265                 }
 266                 dest += len;
 267                 val += len;
 268         }
 269 #else
 270         memcpy (dest, val, len * nelem);
 271 #endif
 272 }
 273
 274 guint32
 275 mono_reflection_method_count_clauses (MonoReflectionILGen *ilgen)
 276 {
 277         MONO_REQ_GC_UNSAFE_MODE;
 278
 279         guint32 num_clauses = 0;
 280         int i;
 281
 282         MonoILExceptionInfo *ex_info;
 283         for (i = 0; i < mono_array_length (ilgen->ex_handlers); ++i) {
 284                 ex_info = (MonoILExceptionInfo*)mono_array_addr (ilgen->ex_handlers, MonoILExceptionInfo, i);
 285                 if (ex_info->handlers)
 286                         num_clauses += mono_array_length (ex_info->handlers);
 287                 else
 288                         num_clauses++;
 289         }
 290
 291         return num_clauses;
 292 }
 293
 294 #ifndef DISABLE_REFLECTION_EMIT
 295 static MonoExceptionClause*
 296 method_encode_clauses (MonoImage *image, MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, guint32 num_clauses, MonoError *error)
 297 {
 298         MONO_REQ_GC_UNSAFE_MODE;
 299
 300         error_init (error);
 301
 302         MonoExceptionClause *clauses;
 303         MonoExceptionClause *clause;
 304         MonoILExceptionInfo *ex_info;
 305         MonoILExceptionBlock *ex_block;
 306         guint32 finally_start;
 307         int i, j, clause_index;;
 308
 309         clauses = image_g_new0 (image, MonoExceptionClause, num_clauses);
 310
 311         clause_index = 0;
 312         for (i = mono_array_length (ilgen->ex_handlers) - 1; i >= 0; --i) {
 313                 ex_info = (MonoILExceptionInfo*)mono_array_addr (ilgen->ex_handlers, MonoILExceptionInfo, i);
 314                 finally_start = ex_info->start + ex_info->len;
 315                 if (!ex_info->handlers)
 316                         continue;
 317                 for (j = 0; j < mono_array_length (ex_info->handlers); ++j) {
 318                         ex_block = (MonoILExceptionBlock*)mono_array_addr (ex_info->handlers, MonoILExceptionBlock, j);
 319                         clause = &(clauses [clause_index]);
 320
 321                         clause->flags = ex_block->type;
 322                         clause->try_offset = ex_info->start;
 323
 324                         if (ex_block->type == MONO_EXCEPTION_CLAUSE_FINALLY)
 325                                 clause->try_len = finally_start - ex_info->start;
 326                         else
 327                                 clause->try_len = ex_info->len;
 328                         clause->handler_offset = ex_block->start;
 329                         clause->handler_len = ex_block->len;
 330                         if (ex_block->extype) {
 331                                 MonoType *extype = mono_reflection_type_get_handle ((MonoReflectionType*)ex_block->extype, error);
 332
 333                                 if (!is_ok (error)) {
 334                                         image_g_free (image, clauses);
 335                                         return NULL;
 336                                 }
 337                                 clause->data.catch_class = mono_class_from_mono_type (extype);
 338                         } else {
 339                                 if (ex_block->type == MONO_EXCEPTION_CLAUSE_FILTER)
 340                                         clause->data.filter_offset = ex_block->filter_offset;
 341                                 else
 342                                         clause->data.filter_offset = 0;
 343                         }
 344                         finally_start = ex_block->start + ex_block->len;
 345
 346                         clause_index ++;
 347                 }
 348         }
 349
 350         return clauses;
 351 }
 352 #endif /* !DISABLE_REFLECTION_EMIT */
 353
 354 #ifndef DISABLE_REFLECTION_EMIT
 355 /*
 356  * LOCKING: Acquires the loader lock.
 357  */
 358 static void
 359 mono_save_custom_attrs (MonoImage *image, void *obj, MonoArray *cattrs)
 360 {
 361         MONO_REQ_GC_UNSAFE_MODE;
 362
 363         MonoCustomAttrInfo *ainfo, *tmp;
 364
 365         if (!cattrs || !mono_array_length (cattrs))
 366                 return;
 367
 368         ainfo = mono_custom_attrs_from_builders (image, image, cattrs);
 369
 370         mono_loader_lock ();
 371         tmp = (MonoCustomAttrInfo *)mono_image_property_lookup (image, obj, MONO_PROP_DYNAMIC_CATTR);
 372         if (tmp)
 373                 mono_custom_attrs_free (tmp);
 374         mono_image_property_insert (image, obj, MONO_PROP_DYNAMIC_CATTR, ainfo);
 375         mono_loader_unlock ();
 376
 377 }
 378 #endif
 379
 380 guint32
 381 mono_reflection_resolution_scope_from_image (MonoDynamicImage *assembly, MonoImage *image)
 382 {
 383         MONO_REQ_GC_UNSAFE_MODE;
 384
 385         MonoDynamicTable *table;
 386         guint32 token;
 387         guint32 *values;
 388         guint32 cols [MONO_ASSEMBLY_SIZE];
 389         const char *pubkey;
 390         guint32 publen;
 391
 392         if ((token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, image))))
 393                 return token;
 394
 395         if (assembly_is_dynamic (image->assembly) && (image->assembly == assembly->image.assembly)) {
 396                 table = &assembly->tables [MONO_TABLE_MODULEREF];
 397                 token = table->next_idx ++;
 398                 table->rows ++;
 399                 alloc_table (table, table->rows);
 400                 values = table->values + token * MONO_MODULEREF_SIZE;
 401                 values [MONO_MODULEREF_NAME] = string_heap_insert (&assembly->sheap, image->module_name);
 402
 403                 token <<= MONO_RESOLUTION_SCOPE_BITS;
 404                 token |= MONO_RESOLUTION_SCOPE_MODULEREF;
 405                 g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
 406
 407                 return token;
 408         }
 409
 410         if (assembly_is_dynamic (image->assembly))
 411                 /* FIXME: */
 412                 memset (cols, 0, sizeof (cols));
 413         else {
 414                 /* image->assembly->image is the manifest module */
 415                 image = image->assembly->image;
 416                 mono_metadata_decode_row (&image->tables [MONO_TABLE_ASSEMBLY], 0, cols, MONO_ASSEMBLY_SIZE);
 417         }
 418
 419         table = &assembly->tables [MONO_TABLE_ASSEMBLYREF];
 420         token = table->next_idx ++;
 421         table->rows ++;
 422         alloc_table (table, table->rows);
 423         values = table->values + token * MONO_ASSEMBLYREF_SIZE;
 424         values [MONO_ASSEMBLYREF_NAME] = string_heap_insert (&assembly->sheap, image->assembly_name);
 425         values [MONO_ASSEMBLYREF_MAJOR_VERSION] = cols [MONO_ASSEMBLY_MAJOR_VERSION];
 426         values [MONO_ASSEMBLYREF_MINOR_VERSION] = cols [MONO_ASSEMBLY_MINOR_VERSION];
 427         values [MONO_ASSEMBLYREF_BUILD_NUMBER] = cols [MONO_ASSEMBLY_BUILD_NUMBER];
 428         values [MONO_ASSEMBLYREF_REV_NUMBER] = cols [MONO_ASSEMBLY_REV_NUMBER];
 429         values [MONO_ASSEMBLYREF_FLAGS] = 0;
 430         values [MONO_ASSEMBLYREF_CULTURE] = 0;
 431         values [MONO_ASSEMBLYREF_HASH_VALUE] = 0;
 432
 433         if (strcmp ("", image->assembly->aname.culture)) {
 434                 values [MONO_ASSEMBLYREF_CULTURE] = string_heap_insert (&assembly->sheap,
 435                                 image->assembly->aname.culture);
 436         }
 437
 438         if ((pubkey = mono_image_get_public_key (image, &publen))) {
 439                 guchar pubtoken [9];
 440                 pubtoken [0] = 8;
 441                 mono_digest_get_public_token (pubtoken + 1, (guchar*)pubkey, publen);
 442                 values [MONO_ASSEMBLYREF_PUBLIC_KEY] = mono_image_add_stream_data (&assembly->blob, (char*)pubtoken, 9);
 443         } else {
 444                 values [MONO_ASSEMBLYREF_PUBLIC_KEY] = 0;
 445         }
 446         token <<= MONO_RESOLUTION_SCOPE_BITS;
 447         token |= MONO_RESOLUTION_SCOPE_ASSEMBLYREF;
 448         g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
 449         return token;
 450 }
 451
 452 #ifndef DISABLE_REFLECTION_EMIT
 453 gboolean
 454 mono_reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb, MonoError *error)
 455 {
 456         MONO_REQ_GC_UNSAFE_MODE;
 457
 458         error_init (error);
 459         memset (rmb, 0, sizeof (ReflectionMethodBuilder));
 460
 461         rmb->ilgen = mb->ilgen;
 462         rmb->rtype = (MonoReflectionType*)mb->rtype;
 463         return_val_if_nok (error, FALSE);
 464         rmb->parameters = mb->parameters;
 465         rmb->generic_params = mb->generic_params;
 466         rmb->generic_container = mb->generic_container;
 467         rmb->opt_types = NULL;
 468         rmb->pinfo = mb->pinfo;
 469         rmb->attrs = mb->attrs;
 470         rmb->iattrs = mb->iattrs;
 471         rmb->call_conv = mb->call_conv;
 472         rmb->code = mb->code;
 473         rmb->type = mb->type;
 474         rmb->name = mb->name;
 475         rmb->table_idx = &mb->table_idx;
 476         rmb->init_locals = mb->init_locals;
 477         rmb->skip_visibility = FALSE;
 478         rmb->return_modreq = mb->return_modreq;
 479         rmb->return_modopt = mb->return_modopt;
 480         rmb->param_modreq = mb->param_modreq;
 481         rmb->param_modopt = mb->param_modopt;
 482         rmb->permissions = mb->permissions;
 483         rmb->mhandle = mb->mhandle;
 484         rmb->nrefs = 0;
 485         rmb->refs = NULL;
 486
 487         if (mb->dll) {
 488                 rmb->charset = mb->charset;
 489                 rmb->extra_flags = mb->extra_flags;
 490                 rmb->native_cc = mb->native_cc;
 491                 rmb->dllentry = mb->dllentry;
 492                 rmb->dll = mb->dll;
 493         }
 494
 495         return TRUE;
 496 }
 497
 498 gboolean
 499 mono_reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb, MonoError *error)
 500 {
 501         MONO_REQ_GC_UNSAFE_MODE;
 502
 503         const char *name = mb->attrs & METHOD_ATTRIBUTE_STATIC ? ".cctor": ".ctor";
 504
 505         error_init (error);
 506
 507         memset (rmb, 0, sizeof (ReflectionMethodBuilder));
 508
 509         rmb->ilgen = mb->ilgen;
 510         rmb->rtype = mono_type_get_object_checked (mono_domain_get (), &mono_defaults.void_class->byval_arg, error);
 511         return_val_if_nok (error, FALSE);
 512         rmb->parameters = mb->parameters;
 513         rmb->generic_params = NULL;
 514         rmb->generic_container = NULL;
 515         rmb->opt_types = NULL;
 516         rmb->pinfo = mb->pinfo;
 517         rmb->attrs = mb->attrs;
 518         rmb->iattrs = mb->iattrs;
 519         rmb->call_conv = mb->call_conv;
 520         rmb->code = NULL;
 521         rmb->type = mb->type;
 522         rmb->name = mono_string_new_checked (mono_domain_get (), name, error);
 523         return_val_if_nok (error, FALSE);
 524         rmb->table_idx = &mb->table_idx;
 525         rmb->init_locals = mb->init_locals;
 526         rmb->skip_visibility = FALSE;
 527         rmb->return_modreq = NULL;
 528         rmb->return_modopt = NULL;
 529         rmb->param_modreq = mb->param_modreq;
 530         rmb->param_modopt = mb->param_modopt;
 531         rmb->permissions = mb->permissions;
 532         rmb->mhandle = mb->mhandle;
 533         rmb->nrefs = 0;
 534         rmb->refs = NULL;
 535
 536         return TRUE;
 537 }
 538
 539 static void
 540 reflection_methodbuilder_from_dynamic_method (ReflectionMethodBuilder *rmb, MonoReflectionDynamicMethod *mb)
 541 {
 542         MONO_REQ_GC_UNSAFE_MODE;
 543
 544         memset (rmb, 0, sizeof (ReflectionMethodBuilder));
 545
 546         rmb->ilgen = mb->ilgen;
 547         rmb->rtype = mb->rtype;
 548         rmb->parameters = mb->parameters;
 549         rmb->generic_params = NULL;
 550         rmb->generic_container = NULL;
 551         rmb->opt_types = NULL;
 552         rmb->pinfo = NULL;
 553         rmb->attrs = mb->attrs;
 554         rmb->iattrs = 0;
 555         rmb->call_conv = mb->call_conv;
 556         rmb->code = NULL;
 557         rmb->type = (MonoObject *) mb->owner;
 558         rmb->name = mb->name;
 559         rmb->table_idx = NULL;
 560         rmb->init_locals = mb->init_locals;
 561         rmb->skip_visibility = mb->skip_visibility;
 562         rmb->return_modreq = NULL;
 563         rmb->return_modopt = NULL;
 564         rmb->param_modreq = NULL;
 565         rmb->param_modopt = NULL;
 566         rmb->permissions = NULL;
 567         rmb->mhandle = mb->mhandle;
 568         rmb->nrefs = 0;
 569         rmb->refs = NULL;
 570 }
 571 #else /* DISABLE_REFLECTION_EMIT */
 572 gboolean
 573 mono_reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb, MonoError *error) {
 574         g_assert_not_reached ();
 575         return FALSE;
 576 }
 577 gboolean
 578 mono_reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb, MonoError *error)
 579 {
 580         g_assert_not_reached ();
 581         return FALSE;
 582 }
 583 #endif /* DISABLE_REFLECTION_EMIT */
 584
 585 #ifndef DISABLE_REFLECTION_EMIT
 586 static guint32
 587 mono_image_add_memberef_row (MonoDynamicImage *assembly, guint32 parent, const char *name, guint32 sig)
 588 {
 589         MONO_REQ_GC_NEUTRAL_MODE;
 590
 591         MonoDynamicTable *table;
 592         guint32 *values;
 593         guint32 token, pclass;
 594
 595         switch (parent & MONO_TYPEDEFORREF_MASK) {
 596         case MONO_TYPEDEFORREF_TYPEREF:
 597                 pclass = MONO_MEMBERREF_PARENT_TYPEREF;
 598                 break;
 599         case MONO_TYPEDEFORREF_TYPESPEC:
 600                 pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
 601                 break;
 602         case MONO_TYPEDEFORREF_TYPEDEF:
 603                 pclass = MONO_MEMBERREF_PARENT_TYPEDEF;
 604                 break;
 605         default:
 606                 g_warning ("unknown typeref or def token 0x%08x for %s", parent, name);
 607                 return 0;
 608         }
 609         /* extract the index */
 610         parent >>= MONO_TYPEDEFORREF_BITS;
 611
 612         table = &assembly->tables [MONO_TABLE_MEMBERREF];
 613
 614         if (assembly->save) {
 615                 alloc_table (table, table->rows + 1);
 616                 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
 617                 values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
 618                 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
 619                 values [MONO_MEMBERREF_SIGNATURE] = sig;
 620         }
 621
 622         token = MONO_TOKEN_MEMBER_REF | table->next_idx;
 623         table->next_idx ++;
 624
 625         return token;
 626 }
 627
 628 /*
 629  * Insert a memberef row into the metadata: the token that point to the memberref
 630  * is returned. Caching is done in the caller (mono_image_get_methodref_token() or
 631  * mono_image_get_fieldref_token()).
 632  * The sig param is an index to an already built signature.
 633  */
 634 static guint32
 635 mono_image_get_memberref_token (MonoDynamicImage *assembly, MonoType *type, const char *name, guint32 sig)
 636 {
 637         MONO_REQ_GC_NEUTRAL_MODE;
 638
 639         guint32 parent = mono_image_typedef_or_ref (assembly, type);
 640         return mono_image_add_memberef_row (assembly, parent, name, sig);
 641 }
 642
 643
 644 guint32
 645 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec)
 646 {
 647         MONO_REQ_GC_NEUTRAL_MODE;
 648
 649         guint32 token;
 650         MonoMethodSignature *sig;
 651
 652         create_typespec = create_typespec && method->is_generic && method->klass->image != &assembly->image;
 653
 654         if (create_typespec) {
 655                 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, GUINT_TO_POINTER (GPOINTER_TO_UINT (method) + 1)));
 656                 if (token)
 657                         return token;
 658         }
 659
 660         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
 661         if (token && !create_typespec)
 662                 return token;
 663
 664         g_assert (!method->is_inflated);
 665         if (!token) {
 666                 /*
 667                  * A methodref signature can't contain an unmanaged calling convention.
 668                  */
 669                 sig = mono_metadata_signature_dup (mono_method_signature (method));
 670                 if ((sig->call_convention != MONO_CALL_DEFAULT) && (sig->call_convention != MONO_CALL_VARARG))
 671                         sig->call_convention = MONO_CALL_DEFAULT;
 672                 token = mono_image_get_memberref_token (assembly, &method->klass->byval_arg,
 673                         method->name,  mono_dynimage_encode_method_signature (assembly, sig));
 674                 g_free (sig);
 675                 g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
 676         }
 677
 678         if (create_typespec) {
 679                 MonoDynamicTable *table = &assembly->tables [MONO_TABLE_METHODSPEC];
 680                 g_assert (mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF);
 681                 token = (mono_metadata_token_index (token) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
 682
 683                 if (assembly->save) {
 684                         guint32 *values;
 685
 686                         alloc_table (table, table->rows + 1);
 687                         values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
 688                         values [MONO_METHODSPEC_METHOD] = token;
 689                         values [MONO_METHODSPEC_SIGNATURE] = mono_dynimage_encode_generic_method_sig (assembly, &mono_method_get_generic_container (method)->context);
 690                 }
 691
 692                 token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
 693                 table->next_idx ++;
 694                 /*methodspec and memberef tokens are diferent, */
 695                 g_hash_table_insert (assembly->handleref, GUINT_TO_POINTER (GPOINTER_TO_UINT (method) + 1), GUINT_TO_POINTER (token));
 696                 return token;
 697         }
 698         return token;
 699 }
 700
 701 static guint32
 702 mono_image_get_varargs_method_token (MonoDynamicImage *assembly, guint32 original,
 703                                      const gchar *name, guint32 sig)
 704 {
 705         MonoDynamicTable *table;
 706         guint32 token;
 707         guint32 *values;
 708
 709         table = &assembly->tables [MONO_TABLE_MEMBERREF];
 710
 711         if (assembly->save) {
 712                 alloc_table (table, table->rows + 1);
 713                 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
 714                 values [MONO_MEMBERREF_CLASS] = original;
 715                 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
 716                 values [MONO_MEMBERREF_SIGNATURE] = sig;
 717         }
 718
 719         token = MONO_TOKEN_MEMBER_REF | table->next_idx;
 720         table->next_idx ++;
 721
 722         return token;
 723 }
 724
 725 #else /* DISABLE_REFLECTION_EMIT */
 726
 727 guint32
 728 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec)
 729 {
 730         g_assert_not_reached ();
 731         return -1;
 732 }
 733 #endif
 734
 735 static gboolean
 736 is_field_on_inst (MonoClassField *field)
 737 {
 738         return mono_class_is_ginst (field->parent) && mono_class_get_generic_class (field->parent)->is_dynamic;
 739 }
 740
 741 #ifndef DISABLE_REFLECTION_EMIT
 742 static guint32
 743 mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoObjectHandle f, MonoClassField *field)
 744 {
 745         MonoType *type;
 746         guint32 token;
 747
 748         g_assert (field);
 749         g_assert (field->parent);
 750
 751         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, MONO_HANDLE_RAW (f)));
 752         if (token)
 753                 return token;
 754
 755         if (mono_class_is_ginst (field->parent) && mono_class_get_generic_class (field->parent)->container_class && mono_class_get_generic_class (field->parent)->container_class->fields) {
 756                 int index = field - field->parent->fields;
 757                 type = mono_field_get_type (&mono_class_get_generic_class (field->parent)->container_class->fields [index]);
 758         } else {
 759                 type = mono_field_get_type (field);
 760         }
 761         token = mono_image_get_memberref_token (assembly, &field->parent->byval_arg,
 762                                                                                         mono_field_get_name (field),
 763                                                                                         mono_dynimage_encode_fieldref_signature (assembly, field->parent->image, type));
 764         mono_g_hash_table_insert (assembly->handleref_managed, MONO_HANDLE_RAW (f), GUINT_TO_POINTER(token));
 765         return token;
 766 }
 767
 768 static guint32
 769 method_encode_methodspec (MonoDynamicImage *assembly, MonoMethod *method)
 770 {
 771         MonoDynamicTable *table;
 772         guint32 *values;
 773         guint32 token, mtoken = 0, sig;
 774         MonoMethodInflated *imethod;
 775         MonoMethod *declaring;
 776
 777         table = &assembly->tables [MONO_TABLE_METHODSPEC];
 778
 779         g_assert (method->is_inflated);
 780         imethod = (MonoMethodInflated *) method;
 781         declaring = imethod->declaring;
 782
 783         sig = mono_dynimage_encode_method_signature (assembly, mono_method_signature (declaring));
 784         mtoken = mono_image_get_memberref_token (assembly, &method->klass->byval_arg, declaring->name, sig);
 785
 786         if (!mono_method_signature (declaring)->generic_param_count)
 787                 return mtoken;
 788
 789         switch (mono_metadata_token_table (mtoken)) {
 790         case MONO_TABLE_MEMBERREF:
 791                 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
 792                 break;
 793         case MONO_TABLE_METHOD:
 794                 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODDEF;
 795                 break;
 796         default:
 797                 g_assert_not_reached ();
 798         }
 799
 800         sig = mono_dynimage_encode_generic_method_sig (assembly, mono_method_get_context (method));
 801
 802         if (assembly->save) {
 803                 alloc_table (table, table->rows + 1);
 804                 values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
 805                 values [MONO_METHODSPEC_METHOD] = mtoken;
 806                 values [MONO_METHODSPEC_SIGNATURE] = sig;
 807         }
 808
 809         token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
 810         table->next_idx ++;
 811
 812         return token;
 813 }
 814
 815 static guint32
 816 mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *method)
 817 {
 818         MonoMethodInflated *imethod;
 819         guint32 token;
 820
 821         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
 822         if (token)
 823                 return token;
 824
 825         g_assert (method->is_inflated);
 826         imethod = (MonoMethodInflated *) method;
 827
 828         if (mono_method_signature (imethod->declaring)->generic_param_count) {
 829                 token = method_encode_methodspec (assembly, method);
 830         } else {
 831                 guint32 sig = mono_dynimage_encode_method_signature (
 832                         assembly, mono_method_signature (imethod->declaring));
 833                 token = mono_image_get_memberref_token (
 834                         assembly, &method->klass->byval_arg, method->name, sig);
 835         }
 836
 837         g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
 838         return token;
 839 }
 840
 841 static guint32
 842 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m)
 843 {
 844         MonoMethodInflated *imethod = (MonoMethodInflated *) m;
 845         guint32 sig, token;
 846
 847         sig = mono_dynimage_encode_method_signature (assembly, mono_method_signature (imethod->declaring));
 848         token = mono_image_get_memberref_token (
 849                 assembly, &m->klass->byval_arg, m->name, sig);
 850
 851         return token;
 852 }
 853
 854 static guint32
 855 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelperHandle helper, MonoError *error)
 856 {
 857         guint32 idx;
 858         MonoDynamicTable *table;
 859         guint32 *values;
 860
 861         error_init (error);
 862
 863         table = &assembly->tables [MONO_TABLE_STANDALONESIG];
 864         idx = table->next_idx ++;
 865         table->rows ++;
 866         alloc_table (table, table->rows);
 867         values = table->values + idx * MONO_STAND_ALONE_SIGNATURE_SIZE;
 868
 869         values [MONO_STAND_ALONE_SIGNATURE] =
 870                 mono_dynimage_encode_reflection_sighelper (assembly, helper, error);
 871         return_val_if_nok (error, 0);
 872
 873         return idx;
 874 }
 875
 876 static int
 877 reflection_cc_to_file (int call_conv) {
 878         switch (call_conv & 0x3) {
 879         case 0:
 880         case 1: return MONO_CALL_DEFAULT;
 881         case 2: return MONO_CALL_VARARG;
 882         default:
 883                 g_assert_not_reached ();
 884         }
 885         return 0;
 886 }
 887 #endif /* !DISABLE_REFLECTION_EMIT */
 888
 889 struct _ArrayMethod {
 890         MonoType *parent;
 891         MonoMethodSignature *sig;
 892         char *name;
 893         guint32 token;
 894 };
 895
 896 void
 897 mono_sre_array_method_free (ArrayMethod *am)
 898 {
 899         g_free (am->sig);
 900         g_free (am->name);
 901         g_free (am);
 902 }
 903
 904 #ifndef DISABLE_REFLECTION_EMIT
 905 static guint32
 906 mono_image_get_array_token (MonoDynamicImage *assembly, MonoReflectionArrayMethodHandle m, MonoError *error)
 907 {
 908         MonoMethodSignature *sig = NULL;
 909         char *name = NULL;
 910
 911         error_init (error);
 912
 913         MonoArrayHandle parameters = MONO_HANDLE_NEW_GET (MonoArray, m, parameters);
 914         guint32 nparams = mono_array_handle_length (parameters);
 915         sig = (MonoMethodSignature *)g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * nparams);
 916         sig->hasthis = 1;
 917         sig->sentinelpos = -1;
 918         sig->call_convention = reflection_cc_to_file (MONO_HANDLE_GETVAL (m, call_conv));
 919         sig->param_count = nparams;
 920         MonoReflectionTypeHandle ret = MONO_HANDLE_NEW_GET (MonoReflectionType, m, ret);
 921         if (!MONO_HANDLE_IS_NULL (ret)) {
 922                 sig->ret = mono_reflection_type_handle_mono_type (ret, error);
 923                 if (!is_ok (error))
 924                         goto fail;
 925         } else
 926                 sig->ret = &mono_defaults.void_class->byval_arg;
 927
 928         MonoReflectionTypeHandle parent = MONO_HANDLE_NEW_GET (MonoReflectionType, m, parent);
 929         MonoType *mtype = mono_reflection_type_handle_mono_type (parent, error);
 930         if (!is_ok (error))
 931                 goto fail;
 932
 933         for (int i = 0; i < nparams; ++i) {
 934                 sig->params [i] = mono_type_array_get_and_resolve (parameters, i, error);
 935                 if (!is_ok (error))
 936                         goto fail;
 937         }
 938
 939         MonoStringHandle mname = MONO_HANDLE_NEW_GET (MonoString, m, name);
 940         name = mono_string_handle_to_utf8 (mname, error);
 941         if (!is_ok (error))
 942                 goto fail;
 943
 944         ArrayMethod *am = NULL;
 945         for (GList *tmp = assembly->array_methods; tmp; tmp = tmp->next) {
 946                 am = (ArrayMethod *)tmp->data;
 947                 if (strcmp (name, am->name) == 0 &&
 948                                 mono_metadata_type_equal (am->parent, mtype) &&
 949                                 mono_metadata_signature_equal (am->sig, sig)) {
 950                         g_free (name);
 951                         g_free (sig);
 952                         MONO_HANDLE_SETVAL (m, table_idx, guint32, am->token & 0xffffff);
 953                         return am->token;
 954                 }
 955         }
 956         am = g_new0 (ArrayMethod, 1);
 957         am->name = name;
 958         am->sig = sig;
 959         am->parent = mtype;
 960         am->token = mono_image_get_memberref_token (assembly, am->parent, name,
 961                 mono_dynimage_encode_method_signature (assembly, sig));
 962         assembly->array_methods = g_list_prepend (assembly->array_methods, am);
 963         MONO_HANDLE_SETVAL (m, table_idx, guint32, am->token & 0xffffff);
 964         return am->token;
 965 fail:
 966         g_free (name);
 967         g_free (sig);
 968         return 0;
 969
 970 }
 971 #endif
 972
 973 #ifndef DISABLE_REFLECTION_EMIT
 974
 975 /*
 976  * mono_image_insert_string:
 977  * @module: module builder object
 978  * @str: a string
 979  *
 980  * Insert @str into the user string stream of @module.
 981  */
 982 guint32
 983 mono_image_insert_string (MonoReflectionModuleBuilderHandle ref_module, MonoStringHandle str, MonoError *error)
 984 {
 985         HANDLE_FUNCTION_ENTER ();
 986         guint32 idx;
 987         char buf [16];
 988         char *b = buf;
 989         guint32 token = 0;
 990
 991         MonoDynamicImage *assembly = MONO_HANDLE_GETVAL (ref_module, dynamic_image);
 992         if (!assembly) {
 993                 if (!mono_image_module_basic_init (ref_module, error))
 994                         goto leave;
 995
 996                 assembly = MONO_HANDLE_GETVAL (ref_module, dynamic_image);
 997         }
 998         g_assert (assembly != NULL);
 999
1000         if (assembly->save) {
1001                 int32_t length = mono_string_length (MONO_HANDLE_RAW (str));
1002                 mono_metadata_encode_value (1 | (length * 2), b, &b);
1003                 idx = mono_image_add_stream_data (&assembly->us, buf, b-buf);
1004                 /* pinned */
1005                 uint32_t gchandle = mono_gchandle_from_handle (MONO_HANDLE_CAST (MonoObject, str), TRUE);
1006                 const char *p = (const char*)mono_string_chars (MONO_HANDLE_RAW (str));
1007 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
1008         {
1009                 char *swapped = g_malloc (2 * length);
1010
1011                 swap_with_size (swapped, p, 2, length);
1012                 mono_image_add_stream_data (&assembly->us, swapped, length * 2);
1013                 g_free (swapped);
1014         }
1015 #else
1016                 mono_image_add_stream_data (&assembly->us, p, length * 2);
1017 #endif
1018                 mono_gchandle_free (gchandle);
1019                 mono_image_add_stream_data (&assembly->us, "", 1);
1020         } else {
1021                 idx = assembly->us.index ++;
1022         }
1023
1024         token = MONO_TOKEN_STRING | idx;
1025         mono_dynamic_image_register_token (assembly, token, MONO_HANDLE_CAST (MonoObject, str), MONO_DYN_IMAGE_TOK_NEW);
1026
1027 leave:
1028         HANDLE_FUNCTION_RETURN_VAL (token);
1029 }
1030
1031 static guint32
1032 create_method_token (MonoDynamicImage *assembly, MonoMethod *method, MonoArrayHandle opt_param_types, MonoError *error)
1033 {
1034         guint32 sig_token, parent;
1035
1036
1037         int nargs = mono_array_handle_length (opt_param_types);
1038         MonoMethodSignature *old = mono_method_signature (method);
1039         MonoMethodSignature *sig = mono_metadata_signature_alloc ( &assembly->image, old->param_count + nargs);
1040
1041         sig->hasthis = old->hasthis;
1042         sig->explicit_this = old->explicit_this;
1043         sig->call_convention = old->call_convention;
1044         sig->generic_param_count = old->generic_param_count;
1045         sig->param_count = old->param_count + nargs;
1046         sig->sentinelpos = old->param_count;
1047         sig->ret = old->ret;
1048
1049         for (int i = 0; i < old->param_count; i++)
1050                 sig->params [i] = old->params [i];
1051
1052         MonoReflectionTypeHandle rt = MONO_HANDLE_NEW (MonoReflectionType, NULL);
1053         for (int i = 0; i < nargs; i++) {
1054                 MONO_HANDLE_ARRAY_GETREF (rt, opt_param_types, i);
1055                 sig->params [old->param_count + i] = mono_reflection_type_handle_mono_type (rt, error);
1056                 if (!is_ok (error)) goto fail;
1057         }
1058
1059         parent = mono_image_typedef_or_ref (assembly, &method->klass->byval_arg);
1060         g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF);
1061         parent >>= MONO_TYPEDEFORREF_BITS;
1062
1063         parent <<= MONO_MEMBERREF_PARENT_BITS;
1064         parent |= MONO_MEMBERREF_PARENT_TYPEREF;
1065
1066         sig_token = mono_dynimage_encode_method_signature (assembly, sig);
1067         guint32 token = mono_image_get_varargs_method_token (assembly, parent, method->name, sig_token);
1068         g_hash_table_insert (assembly->vararg_aux_hash, GUINT_TO_POINTER (token), sig);
1069         return token;
1070 fail:
1071         return 0;
1072 }
1073
1074 guint32
1075 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObjectHandle obj, MonoArrayHandle opt_param_types, MonoError *error)
1076 {
1077         guint32 token = 0;
1078
1079         error_init (error);
1080
1081         MonoClass *klass = mono_handle_class (obj);
1082         if (strcmp (klass->name, "MonoMethod") == 0 || strcmp (klass->name, "MonoCMethod") == 0) {
1083                 MonoReflectionMethodHandle ref_method = MONO_HANDLE_CAST (MonoReflectionMethod, obj);
1084                 MonoMethod *method = MONO_HANDLE_GETVAL (ref_method, method);
1085                 g_assert (!MONO_HANDLE_IS_NULL (opt_param_types) && (mono_method_signature (method)->sentinelpos >= 0));
1086                 token = create_method_token (assembly, method, opt_param_types, error);
1087                 if (!is_ok (error))
1088                         goto fail;
1089         } else if (strcmp (klass->name, "MethodBuilder") == 0) {
1090                 g_assert_not_reached ();
1091         } else {
1092                 g_error ("requested method token for %s\n", klass->name);
1093         }
1094
1095         mono_dynamic_image_register_token (assembly, token, obj, MONO_DYN_IMAGE_TOK_NEW);
1096         return token;
1097 fail:
1098         g_assert (!mono_error_ok (error));
1099         return 0;
1100 }
1101
1102 /*
1103  * mono_image_create_token:
1104  * @assembly: a dynamic assembly
1105  * @obj:
1106  * @register_token: Whenever to register the token in the assembly->tokens hash.
1107  *
1108  * Get a token to insert in the IL code stream for the given MemberInfo.
1109  * The metadata emission routines need to pass FALSE as REGISTER_TOKEN, since by that time,
1110  * the table_idx-es were recomputed, so registering the token would overwrite an existing
1111  * entry.
1112  */
1113 guint32
1114 mono_image_create_token (MonoDynamicImage *assembly, MonoObjectHandle obj,
1115                          gboolean create_open_instance, gboolean register_token,
1116                          MonoError *error)
1117 {
1118         guint32 token = 0;
1119
1120         error_init (error);
1121
1122         MonoClass *klass = mono_handle_class (obj);
1123
1124         /* Check for user defined reflection objects */
1125         /* TypeDelegator is the only corlib type which doesn't look like a MonoReflectionType */
1126         if (klass->image != mono_defaults.corlib || (strcmp (klass->name, "TypeDelegator") == 0)) {
1127                 mono_error_set_not_supported (error, "User defined subclasses of System.Type are not yet supported");
1128                 return 0;
1129         }
1130
1131         /* This function is called from ModuleBuilder:getToken multiple times for the same objects */
1132         int how_collide = MONO_DYN_IMAGE_TOK_SAME_OK;
1133
1134         if (strcmp (klass->name, "RuntimeType") == 0) {
1135                 MonoType *type = mono_reflection_type_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionType, obj), error);
1136                 return_val_if_nok (error, 0);
1137                 MonoClass *mc = mono_class_from_mono_type (type);
1138                 token = mono_metadata_token_from_dor (
1139                         mono_dynimage_encode_typedef_or_ref_full (assembly, type, !mono_class_is_gtd (mc) || create_open_instance));
1140                 /* If it's a RuntimeType now, we could have registered a
1141                  * TypeBuilder for it before, so replacing is okay. */
1142                 how_collide = MONO_DYN_IMAGE_TOK_REPLACE;
1143         } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
1144                            strcmp (klass->name, "MonoMethod") == 0) {
1145                 MonoReflectionMethodHandle m = MONO_HANDLE_CAST (MonoReflectionMethod, obj);
1146                 MonoMethod *method = MONO_HANDLE_GETVAL (m, method);
1147                 if (method->is_inflated) {
1148                         if (create_open_instance)
1149                                 token = mono_image_get_methodspec_token (assembly, method);
1150                         else
1151                                 token = mono_image_get_inflated_method_token (assembly, method);
1152                 } else if ((method->klass->image == &assembly->image) &&
1153                          !mono_class_is_ginst (method->klass)) {
1154                         static guint32 method_table_idx = 0xffffff;
1155                         if (method->klass->wastypebuilder) {
1156                                 /* we use the same token as the one that was assigned
1157                                  * to the Methodbuilder.
1158                                  * FIXME: do the equivalent for Fields.
1159                                  */
1160                                 token = method->token;
1161                                 how_collide = MONO_DYN_IMAGE_TOK_REPLACE;
1162                         } else {
1163                                 /*
1164                                  * Each token should have a unique index, but the indexes are
1165                                  * assigned by managed code, so we don't know about them. An
1166                                  * easy solution is to count backwards...
1167                                  */
1168                                 method_table_idx --;
1169                                 token = MONO_TOKEN_METHOD_DEF | method_table_idx;
1170                                 how_collide = MONO_DYN_IMAGE_TOK_NEW;
1171                         }
1172                 } else {
1173                         token = mono_image_get_methodref_token (assembly, method, create_open_instance);
1174                 }
1175                 /*g_print ("got token 0x%08x for %s\n", token, m->method->name);*/
1176         } else if (strcmp (klass->name, "MonoField") == 0) {
1177                 MonoReflectionFieldHandle f = MONO_HANDLE_CAST (MonoReflectionField, obj);
1178                 MonoClassField *field = MONO_HANDLE_GETVAL (f, field);
1179                 if ((field->parent->image == &assembly->image) && !is_field_on_inst (field)) {
1180                         static guint32 field_table_idx = 0xffffff;
1181                         field_table_idx --;
1182                         token = MONO_TOKEN_FIELD_DEF | field_table_idx;
1183                         how_collide = MONO_DYN_IMAGE_TOK_NEW;
1184                 } else {
1185                         token = mono_image_get_fieldref_token (assembly, obj, field);
1186                 }
1187                 /*g_print ("got token 0x%08x for %s\n", token, f->field->name);*/
1188         } else if (strcmp (klass->name, "MonoArrayMethod") == 0) {
1189                 MonoReflectionArrayMethodHandle m = MONO_HANDLE_CAST (MonoReflectionArrayMethod, obj);
1190                 token = mono_image_get_array_token (assembly, m, error);
1191                 return_val_if_nok (error, 0);
1192         } else if (strcmp (klass->name, "SignatureHelper") == 0) {
1193                 MonoReflectionSigHelperHandle s = MONO_HANDLE_CAST (MonoReflectionSigHelper, obj);
1194                 token = MONO_TOKEN_SIGNATURE | mono_image_get_sighelper_token (assembly, s, error);
1195                 return_val_if_nok (error, 0);
1196         } else if (strcmp (klass->name, "EnumBuilder") == 0) {
1197                 MonoType *type = mono_reflection_type_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionType, obj), error);
1198                 return_val_if_nok (error, 0);
1199                 token = mono_metadata_token_from_dor (
1200                         mono_image_typedef_or_ref (assembly, type));
1201         } else {
1202                 g_error ("requested token for %s\n", klass->name);
1203         }
1204
1205         if (register_token)
1206                 mono_dynamic_image_register_token (assembly, token, obj, how_collide);
1207
1208         return token;
1209 }
1210
1211
1212 #endif
1213
1214 #ifndef DISABLE_REFLECTION_EMIT
1215
1216 static gboolean
1217 assemblybuilderaccess_can_refonlyload (guint32 access)
1218 {
1219         return (access & 0x4) != 0;
1220 }
1221
1222 static gboolean
1223 assemblybuilderaccess_can_run (guint32 access)
1224 {
1225         return (access & MonoAssemblyBuilderAccess_Run) != 0;
1226 }
1227
1228 static gboolean
1229 assemblybuilderaccess_can_save (guint32 access)
1230 {
1231         return (access & MonoAssemblyBuilderAccess_Save) != 0;
1232 }
1233
1234
1235 /*
1236  * mono_reflection_dynimage_basic_init:
1237  * @assembly: an assembly builder object
1238  *
1239  * Create the MonoImage that represents the assembly builder and setup some
1240  * of the helper hash table and the basic metadata streams.
1241  */
1242 void
1243 mono_reflection_dynimage_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
1244 {
1245         MonoError error;
1246         MonoDynamicAssembly *assembly;
1247         MonoDynamicImage *image;
1248         MonoDomain *domain = mono_object_domain (assemblyb);
1249
1250         if (assemblyb->dynamic_assembly)
1251                 return;
1252
1253         assembly = assemblyb->dynamic_assembly = g_new0 (MonoDynamicAssembly, 1);
1254
1255         MONO_PROFILER_RAISE (assembly_loading, (&assembly->assembly));
1256
1257         assembly->assembly.ref_count = 1;
1258         assembly->assembly.dynamic = TRUE;
1259         assembly->assembly.corlib_internal = assemblyb->corlib_internal;
1260         assemblyb->assembly.assembly = (MonoAssembly*)assembly;
1261         assembly->assembly.basedir = mono_string_to_utf8_checked (assemblyb->dir, &error);
1262         if (mono_error_set_pending_exception (&error))
1263                 return;
1264         if (assemblyb->culture) {
1265                 assembly->assembly.aname.culture = mono_string_to_utf8_checked (assemblyb->culture, &error);
1266                 if (mono_error_set_pending_exception (&error))
1267                         return;
1268         } else
1269                 assembly->assembly.aname.culture = g_strdup ("");
1270
1271         if (assemblyb->version) {
1272                         char *vstr = mono_string_to_utf8_checked (assemblyb->version, &error);
1273                         if (mono_error_set_pending_exception (&error))
1274                                 return;
1275                         char **version = g_strsplit (vstr, ".", 4);
1276                         char **parts = version;
1277                         assembly->assembly.aname.major = atoi (*parts++);
1278                         assembly->assembly.aname.minor = atoi (*parts++);
1279                         assembly->assembly.aname.build = *parts != NULL ? atoi (*parts++) : 0;
1280                         assembly->assembly.aname.revision = *parts != NULL ? atoi (*parts) : 0;
1281
1282                         g_strfreev (version);
1283                         g_free (vstr);
1284         } else {
1285                         assembly->assembly.aname.major = 0;
1286                         assembly->assembly.aname.minor = 0;
1287                         assembly->assembly.aname.build = 0;
1288                         assembly->assembly.aname.revision = 0;
1289         }
1290
1291         assembly->assembly.ref_only = assemblybuilderaccess_can_refonlyload (assemblyb->access);
1292         assembly->run = assemblybuilderaccess_can_run (assemblyb->access);
1293         assembly->save = assemblybuilderaccess_can_save (assemblyb->access);
1294         assembly->domain = domain;
1295
1296         char *assembly_name = mono_string_to_utf8_checked (assemblyb->name, &error);
1297         if (mono_error_set_pending_exception (&error))
1298                 return;
1299         image = mono_dynamic_image_create (assembly, assembly_name, g_strdup ("RefEmit_YouForgotToDefineAModule"));
1300         image->initial_image = TRUE;
1301         assembly->assembly.aname.name = image->image.name;
1302         assembly->assembly.image = &image->image;
1303         if (assemblyb->pktoken && assemblyb->pktoken->max_length) {
1304                 /* -1 to correct for the trailing NULL byte */
1305                 if (assemblyb->pktoken->max_length != MONO_PUBLIC_KEY_TOKEN_LENGTH - 1) {
1306                         g_error ("Public key token length invalid for assembly %s: %i", assembly->assembly.aname.name, assemblyb->pktoken->max_length);
1307                 }
1308                 memcpy (&assembly->assembly.aname.public_key_token, mono_array_addr (assemblyb->pktoken, guint8, 0), assemblyb->pktoken->max_length);
1309         }
1310
1311         mono_domain_assemblies_lock (domain);
1312         domain->domain_assemblies = g_slist_append (domain->domain_assemblies, assembly);
1313         mono_domain_assemblies_unlock (domain);
1314
1315         register_assembly (mono_object_domain (assemblyb), &assemblyb->assembly, &assembly->assembly);
1316
1317         MONO_PROFILER_RAISE (assembly_loaded, (&assembly->assembly));
1318
1319         mono_assembly_invoke_load_hook ((MonoAssembly*)assembly);
1320 }
1321
1322 #endif /* !DISABLE_REFLECTION_EMIT */
1323
1324 #ifndef DISABLE_REFLECTION_EMIT
1325 static gpointer
1326 register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly)
1327 {
1328         return CACHE_OBJECT (MonoReflectionAssembly *, assembly, &res->object, NULL);
1329 }
1330
1331 static MonoReflectionModuleBuilderHandle
1332 register_module (MonoDomain *domain, MonoReflectionModuleBuilderHandle res, MonoDynamicImage *module)
1333 {
1334         return CACHE_OBJECT_HANDLE (MonoReflectionModuleBuilderHandle, module, MONO_HANDLE_CAST (MonoObject, res), NULL);
1335 }
1336
1337 static gboolean
1338 image_module_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error)
1339 {
1340         error_init (error);
1341         MonoDomain *domain = MONO_HANDLE_DOMAIN (moduleb);
1342         MonoDynamicImage *image = MONO_HANDLE_GETVAL (moduleb, dynamic_image);
1343         MonoReflectionAssemblyBuilderHandle ab = MONO_HANDLE_NEW (MonoReflectionAssemblyBuilder, NULL);
1344         MONO_HANDLE_GET (ab, moduleb, assemblyb);
1345         if (!image) {
1346                 /*
1347                  * FIXME: we already created an image in mono_reflection_dynimage_basic_init (), but
1348                  * we don't know which module it belongs to, since that is only
1349                  * determined at assembly save time.
1350                  */
1351                 /*image = (MonoDynamicImage*)ab->dynamic_assembly->assembly.image; */
1352                 MonoStringHandle abname = MONO_HANDLE_NEW_GET (MonoString, ab, name);
1353                 char *name = mono_string_handle_to_utf8 (abname, error);
1354                 return_val_if_nok (error, FALSE);
1355                 MonoStringHandle modfqname = MONO_HANDLE_NEW_GET (MonoString, MONO_HANDLE_CAST (MonoReflectionModule, moduleb), fqname);
1356                 char *fqname = mono_string_handle_to_utf8 (modfqname, error);
1357                 if (!is_ok (error)) {
1358                         g_free (name);
1359                         return FALSE;
1360                 }
1361                 MonoDynamicAssembly *dynamic_assembly = MONO_HANDLE_GETVAL (ab, dynamic_assembly);
1362                 image = mono_dynamic_image_create (dynamic_assembly, name, fqname);
1363
1364                 MONO_HANDLE_SETVAL (MONO_HANDLE_CAST (MonoReflectionModule, moduleb), image, MonoImage*, &image->image);
1365                 MONO_HANDLE_SETVAL (moduleb, dynamic_image, MonoDynamicImage*, image);
1366                 register_module (domain, moduleb, image);
1367
1368                 /* register the module with the assembly */
1369                 MonoImage *ass = dynamic_assembly->assembly.image;
1370                 int module_count = ass->module_count;
1371                 MonoImage **new_modules = g_new0 (MonoImage *, module_count + 1);
1372
1373                 if (ass->modules)
1374                         memcpy (new_modules, ass->modules, module_count * sizeof (MonoImage *));
1375                 new_modules [module_count] = &image->image;
1376                 mono_image_addref (&image->image);
1377
1378                 g_free (ass->modules);
1379                 ass->modules = new_modules;
1380                 ass->module_count ++;
1381         }
1382         return TRUE;
1383 }
1384
1385 static gboolean
1386 mono_image_module_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error)
1387 {
1388         error_init (error);
1389         return image_module_basic_init (moduleb, error);
1390 }
1391
1392 #endif
1393
1394 static gboolean
1395 is_corlib_type (MonoClass *klass)
1396 {
1397         return klass->image == mono_defaults.corlib;
1398 }
1399
1400 #define check_corlib_type_cached(_class, _namespace, _name) do { \
1401         static MonoClass *cached_class; \
1402         if (cached_class) \
1403                 return cached_class == _class; \
1404         if (is_corlib_type (_class) && !strcmp (_name, _class->name) && !strcmp (_namespace, _class->name_space)) { \
1405                 cached_class = _class; \
1406                 return TRUE; \
1407         } \
1408         return FALSE; \
1409 } while (0) \
1410
1411
1412 MonoType*
1413 mono_type_array_get_and_resolve (MonoArrayHandle array, int idx, MonoError *error)
1414 {
1415         HANDLE_FUNCTION_ENTER();
1416         error_init (error);
1417         MonoReflectionTypeHandle t = MONO_HANDLE_NEW (MonoReflectionType, NULL);
1418         MONO_HANDLE_ARRAY_GETREF (t, array, idx);
1419         MonoType *result = mono_reflection_type_handle_mono_type (t, error);
1420         HANDLE_FUNCTION_RETURN_VAL (result);
1421 }
1422
1423
1424 #ifndef DISABLE_REFLECTION_EMIT
1425 static gboolean
1426 is_sre_array (MonoClass *klass)
1427 {
1428         check_corlib_type_cached (klass, "System.Reflection.Emit", "ArrayType");
1429 }
1430
1431 static gboolean
1432 is_sre_byref (MonoClass *klass)
1433 {
1434         check_corlib_type_cached (klass, "System.Reflection.Emit", "ByRefType");
1435 }
1436
1437 static gboolean
1438 is_sre_pointer (MonoClass *klass)
1439 {
1440         check_corlib_type_cached (klass, "System.Reflection.Emit", "PointerType");
1441 }
1442
1443 static gboolean
1444 is_sre_generic_instance (MonoClass *klass)
1445 {
1446         check_corlib_type_cached (klass, "System.Reflection.Emit", "TypeBuilderInstantiation");
1447 }
1448
1449 static gboolean
1450 is_sre_type_builder (MonoClass *klass)
1451 {
1452         check_corlib_type_cached (klass, "System.Reflection.Emit", "TypeBuilder");
1453 }
1454
1455 static gboolean
1456 is_sre_method_builder (MonoClass *klass)
1457 {
1458         check_corlib_type_cached (klass, "System.Reflection.Emit", "MethodBuilder");
1459 }
1460
1461 gboolean
1462 mono_is_sre_ctor_builder (MonoClass *klass)
1463 {
1464         check_corlib_type_cached (klass, "System.Reflection.Emit", "ConstructorBuilder");
1465 }
1466
1467 static gboolean
1468 is_sre_field_builder (MonoClass *klass)
1469 {
1470         check_corlib_type_cached (klass, "System.Reflection.Emit", "FieldBuilder");
1471 }
1472
1473 static gboolean
1474 is_sre_gparam_builder (MonoClass *klass)
1475 {
1476         check_corlib_type_cached (klass, "System.Reflection.Emit", "GenericTypeParameterBuilder");
1477 }
1478
1479 static gboolean
1480 is_sre_enum_builder (MonoClass *klass)
1481 {
1482         check_corlib_type_cached (klass, "System.Reflection.Emit", "EnumBuilder");
1483 }
1484
1485 gboolean
1486 mono_is_sre_method_on_tb_inst (MonoClass *klass)
1487 {
1488         check_corlib_type_cached (klass, "System.Reflection.Emit", "MethodOnTypeBuilderInst");
1489 }
1490
1491 gboolean
1492 mono_is_sre_ctor_on_tb_inst (MonoClass *klass)
1493 {
1494         check_corlib_type_cached (klass, "System.Reflection.Emit", "ConstructorOnTypeBuilderInst");
1495 }
1496
1497 static MonoReflectionTypeHandle
1498 mono_reflection_type_get_underlying_system_type (MonoReflectionTypeHandle t, MonoError *error)
1499 {
1500         static MonoMethod *method_get_underlying_system_type = NULL;
1501         HANDLE_FUNCTION_ENTER ();
1502
1503         error_init (error);
1504
1505         if (!method_get_underlying_system_type)
1506                 method_get_underlying_system_type = mono_class_get_method_from_name (mono_defaults.systemtype_class, "get_UnderlyingSystemType", 0);
1507
1508         MonoReflectionTypeHandle rt = MONO_HANDLE_NEW (MonoReflectionType, NULL);
1509
1510         MonoMethod *usertype_method = mono_object_handle_get_virtual_method (MONO_HANDLE_CAST (MonoObject, t), method_get_underlying_system_type, error);
1511         if (!is_ok (error))
1512                 goto leave;
1513
1514         MONO_HANDLE_ASSIGN (rt, MONO_HANDLE_NEW (MonoReflectionType, mono_runtime_invoke_checked (usertype_method, MONO_HANDLE_RAW (t), NULL, error)));
1515
1516 leave:
1517         HANDLE_FUNCTION_RETURN_REF (MonoReflectionType, rt);
1518 }
1519
1520 MonoType*
1521 mono_reflection_type_get_handle (MonoReflectionType* ref_raw, MonoError *error)
1522 {
1523         HANDLE_FUNCTION_ENTER ();
1524         error_init (error);
1525         MONO_HANDLE_DCL (MonoReflectionType, ref);
1526         MonoType *result = mono_reflection_type_handle_mono_type (ref, error);
1527         HANDLE_FUNCTION_RETURN_VAL (result);
1528 }
1529
1530 static MonoType*
1531 reflection_instance_handle_mono_type (MonoReflectionGenericClassHandle ref_gclass, MonoError *error)
1532 {
1533         HANDLE_FUNCTION_ENTER ();
1534         MonoType *result = NULL;
1535         MonoType **types = NULL;
1536
1537         MonoArrayHandle typeargs = MONO_HANDLE_NEW_GET (MonoArray, ref_gclass, type_arguments);
1538         int count = mono_array_handle_length (typeargs);
1539         types = g_new0 (MonoType*, count);
1540         MonoReflectionTypeHandle t = MONO_HANDLE_NEW (MonoReflectionType, NULL);
1541         for (int i = 0; i < count; ++i) {
1542                 MONO_HANDLE_ARRAY_GETREF (t, typeargs, i);
1543                 types [i] = mono_reflection_type_handle_mono_type (t, error);
1544                 if (!types[i] || !is_ok (error)) {
1545                         goto leave;
1546                 }
1547         }
1548         /* Need to resolve the generic_type in order for it to create its generic context. */
1549         MonoReflectionTypeHandle ref_gtd = MONO_HANDLE_NEW_GET (MonoReflectionType, ref_gclass, generic_type);
1550         MonoType *gtd = mono_reflection_type_handle_mono_type (ref_gtd, error);
1551         if (!is_ok (error)) {
1552                 goto leave;
1553         }
1554         MonoClass *gtd_klass = mono_class_from_mono_type (gtd);
1555         if (is_sre_type_builder (mono_handle_class (ref_gtd))) {
1556                 reflection_setup_internal_class (MONO_HANDLE_CAST (MonoReflectionTypeBuilder, ref_gtd), error);
1557                 if (!is_ok (error)) {
1558                         goto leave;
1559                 }
1560         }
1561         g_assert (count == 0 || mono_class_is_gtd (gtd_klass));
1562         result = mono_reflection_bind_generic_parameters (ref_gtd, count, types, error);
1563         if (!is_ok (error))
1564                 goto leave;
1565         g_assert (result);
1566         MONO_HANDLE_SETVAL (MONO_HANDLE_CAST (MonoReflectionType, ref_gclass), type, MonoType*, result);
1567 leave:
1568         g_free (types);
1569         HANDLE_FUNCTION_RETURN_VAL (result);
1570 }
1571
1572 static MonoType*
1573 reflection_param_handle_mono_type (MonoReflectionGenericParamHandle ref_gparam, MonoError *error)
1574 {
1575         HANDLE_FUNCTION_ENTER ();
1576         error_init (error);
1577         MonoType *result = NULL;
1578
1579
1580         MonoReflectionTypeBuilderHandle ref_tbuilder = MONO_HANDLE_NEW_GET (MonoReflectionTypeBuilder, ref_gparam, tbuilder);
1581         MonoReflectionModuleBuilderHandle ref_module = MONO_HANDLE_NEW_GET (MonoReflectionModuleBuilder, ref_tbuilder, module);
1582         MonoDynamicImage *dynamic_image = MONO_HANDLE_GETVAL (ref_module, dynamic_image);
1583         MonoImage *image = &dynamic_image->image;
1584
1585         MonoGenericParamFull *param = mono_image_new0 (image, MonoGenericParamFull, 1);
1586
1587         MonoStringHandle ref_name = MONO_HANDLE_NEW_GET (MonoString, ref_gparam, name);
1588         param->info.name = mono_string_to_utf8_image (image, ref_name, error);
1589         mono_error_assert_ok (error);
1590         param->param.num = MONO_HANDLE_GETVAL (ref_gparam, index);
1591
1592         MonoReflectionMethodBuilderHandle ref_mbuilder = MONO_HANDLE_NEW_GET (MonoReflectionMethodBuilder, ref_gparam, mbuilder);
1593         if (!MONO_HANDLE_IS_NULL (ref_mbuilder)) {
1594                 MonoGenericContainer *generic_container = MONO_HANDLE_GETVAL (ref_mbuilder, generic_container);
1595                 if (!generic_container) {
1596                         generic_container = (MonoGenericContainer *)mono_image_alloc0 (image, sizeof (MonoGenericContainer));
1597                         generic_container->is_method = TRUE;
1598                         /*
1599                          * Cannot set owner.method, since the MonoMethod is not created yet.
1600                          * Set the image field instead, so type_in_image () works.
1601                          */
1602                         generic_container->is_anonymous = TRUE;
1603                         generic_container->owner.image = image;
1604                         MONO_HANDLE_SETVAL (ref_mbuilder, generic_container, MonoGenericContainer*, generic_container);
1605                 }
1606                 param->param.owner = generic_container;
1607         } else {
1608                 MonoType *type = mono_reflection_type_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionType, ref_tbuilder), error);
1609                 if (!is_ok (error))
1610                         goto leave;
1611                 MonoClass *owner = mono_class_from_mono_type (type);
1612                 g_assert (mono_class_is_gtd (owner));
1613                 param->param.owner = mono_class_get_generic_container (owner);
1614         }
1615
1616         MonoClass *pklass = mono_class_from_generic_parameter_internal ((MonoGenericParam *) param);
1617
1618         result = &pklass->byval_arg;
1619
1620         mono_class_set_ref_info (pklass, MONO_HANDLE_CAST (MonoObject, ref_gparam));
1621         mono_image_append_class_to_reflection_info_set (pklass);
1622
1623         MONO_HANDLE_SETVAL (MONO_HANDLE_CAST (MonoReflectionType, ref_gparam), type, MonoType*, result);
1624
1625 leave:
1626         HANDLE_FUNCTION_RETURN_VAL (result);
1627 }
1628
1629 static MonoType*
1630 mono_type_array_get_and_resolve_raw (MonoArray* array_raw, int idx, MonoError *error)
1631 {
1632         HANDLE_FUNCTION_ENTER(); /* FIXME callers of mono_type_array_get_and_resolve_raw should use handles */
1633         error_init (error);
1634         MONO_HANDLE_DCL (MonoArray, array);
1635         MonoType *result = mono_type_array_get_and_resolve (array, idx, error);
1636         HANDLE_FUNCTION_RETURN_VAL (result);
1637 }
1638
1639 MonoType*
1640 mono_reflection_type_handle_mono_type (MonoReflectionTypeHandle ref, MonoError *error)
1641 {
1642         HANDLE_FUNCTION_ENTER ();
1643         error_init (error);
1644
1645         MonoType* result = NULL;
1646
1647         g_assert (ref);
1648         if (MONO_HANDLE_IS_NULL (ref))
1649                 goto leave;
1650         MonoType *t = MONO_HANDLE_GETVAL (ref, type);
1651         if (t) {
1652                 result = t;
1653                 goto leave;
1654         }
1655
1656         if (mono_reflection_is_usertype (ref)) {
1657                 MONO_HANDLE_ASSIGN (ref, mono_reflection_type_get_underlying_system_type (ref, error));
1658                 if (!is_ok (error) || MONO_HANDLE_IS_NULL (ref) || mono_reflection_is_usertype (ref))
1659                         goto leave;
1660                 t = MONO_HANDLE_GETVAL (ref, type);
1661                 if (t) {
1662                         result = t;
1663                         goto leave;
1664                 }
1665         }
1666
1667         MonoClass *klass = mono_handle_class (ref);
1668
1669         if (is_sre_array (klass)) {
1670                 MonoReflectionArrayTypeHandle sre_array = MONO_HANDLE_CAST (MonoReflectionArrayType, ref);
1671                 MonoReflectionTypeHandle ref_element = MONO_HANDLE_NEW_GET (MonoReflectionType, sre_array, element_type);
1672                 MonoType *base = mono_reflection_type_handle_mono_type (ref_element, error);
1673                 if (!is_ok (error))
1674                         goto leave;
1675                 g_assert (base);
1676                 gint32 rank = MONO_HANDLE_GETVAL (sre_array, rank);
1677                 MonoClass *eclass = mono_class_from_mono_type (base);
1678                 result = mono_image_new0 (eclass->image, MonoType, 1);
1679                 if (rank == 0)  {
1680                         result->type = MONO_TYPE_SZARRAY;
1681                         result->data.klass = eclass;
1682                 } else {
1683                         MonoArrayType *at = (MonoArrayType *)mono_image_alloc0 (eclass->image, sizeof (MonoArrayType));
1684                         result->type = MONO_TYPE_ARRAY;
1685                         result->data.array = at;
1686                         at->eklass = eclass;
1687                         at->rank = rank;
1688                 }
1689                 MONO_HANDLE_SETVAL (ref, type, MonoType*, result);
1690         } else if (is_sre_byref (klass)) {
1691                 MonoReflectionDerivedTypeHandle sre_byref = MONO_HANDLE_CAST (MonoReflectionDerivedType, ref);
1692                 MonoReflectionTypeHandle ref_element = MONO_HANDLE_NEW_GET (MonoReflectionType, sre_byref, element_type);
1693                 MonoType *base = mono_reflection_type_handle_mono_type (ref_element, error);
1694                 if (!is_ok (error))
1695                         goto leave;
1696                 g_assert (base);
1697                 result = &mono_class_from_mono_type (base)->this_arg;
1698                 MONO_HANDLE_SETVAL (ref, type, MonoType*, result);
1699         } else if (is_sre_pointer (klass)) {
1700                 MonoReflectionDerivedTypeHandle sre_pointer = MONO_HANDLE_CAST (MonoReflectionDerivedType, ref);
1701                 MonoReflectionTypeHandle ref_element = MONO_HANDLE_NEW_GET (MonoReflectionType, sre_pointer, element_type);
1702                 MonoType *base = mono_reflection_type_handle_mono_type (ref_element, error);
1703                 if (!is_ok (error))
1704                         goto leave;
1705                 g_assert (base);
1706                 result = &mono_ptr_class_get (base)->byval_arg;
1707                 MONO_HANDLE_SETVAL (ref, type, MonoType*, result);
1708         } else if (is_sre_generic_instance (klass)) {
1709                 result = reflection_instance_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionGenericClass, ref), error);
1710         } else if (is_sre_gparam_builder (klass)) {
1711                 result = reflection_param_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionGenericParam, ref), error);
1712         } else if (is_sre_enum_builder (klass)) {
1713                 MonoReflectionEnumBuilderHandle ref_ebuilder = MONO_HANDLE_CAST (MonoReflectionEnumBuilder, ref);
1714
1715                 MonoReflectionTypeHandle ref_tb = MONO_HANDLE_NEW_GET (MonoReflectionType, ref_ebuilder, tb);
1716                 result = mono_reflection_type_handle_mono_type (ref_tb, error);
1717         } else if (is_sre_type_builder (klass)) {
1718                 MonoReflectionTypeBuilderHandle ref_tb = MONO_HANDLE_CAST (MonoReflectionTypeBuilder, ref);
1719
1720                 /* This happens when a finished type references an unfinished one. Have to create the minimal type */
1721                 reflection_setup_internal_class (ref_tb, error);
1722                 mono_error_assert_ok (error);
1723                 result = MONO_HANDLE_GETVAL (ref, type);
1724         } else {
1725                 g_error ("Cannot handle corlib user type %s", mono_type_full_name (&mono_object_class(ref)->byval_arg));
1726         }
1727 leave:
1728         HANDLE_FUNCTION_RETURN_VAL (result);
1729 }
1730
1731 /**
1732  * LOCKING: Assumes the loader lock is held.
1733  */
1734 static MonoMethodSignature*
1735 parameters_to_signature (MonoImage *image, MonoArrayHandle parameters, MonoError *error) {
1736         MonoMethodSignature *sig;
1737         int count, i;
1738
1739         error_init (error);
1740
1741         count = MONO_HANDLE_IS_NULL (parameters) ? 0 : mono_array_handle_length (parameters);
1742
1743         sig = (MonoMethodSignature *)mono_image_g_malloc0 (image, MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * count);
1744         sig->param_count = count;
1745         sig->sentinelpos = -1; /* FIXME */
1746         for (i = 0; i < count; ++i) {
1747                 sig->params [i] = mono_type_array_get_and_resolve (parameters, i, error);
1748                 if (!is_ok (error)) {
1749                         image_g_free (image, sig);
1750                         return NULL;
1751                 }
1752         }
1753         return sig;
1754 }
1755
1756 /**
1757  * LOCKING: Assumes the loader lock is held.
1758  */
1759 static MonoMethodSignature*
1760 ctor_builder_to_signature (MonoImage *image, MonoReflectionCtorBuilderHandle ctor, MonoError *error) {
1761         MonoMethodSignature *sig;
1762
1763         error_init (error);
1764
1765         sig = parameters_to_signature (image, MONO_HANDLE_NEW_GET (MonoArray, ctor, parameters), error);
1766         return_val_if_nok (error, NULL);
1767         sig->hasthis = MONO_HANDLE_GETVAL (ctor, attrs) & METHOD_ATTRIBUTE_STATIC? 0: 1;
1768         sig->ret = &mono_defaults.void_class->byval_arg;
1769         return sig;
1770 }
1771
1772 static MonoMethodSignature*
1773 ctor_builder_to_signature_raw (MonoImage *image, MonoReflectionCtorBuilder* ctor_raw, MonoError *error) {
1774         HANDLE_FUNCTION_ENTER();
1775         MONO_HANDLE_DCL (MonoReflectionCtorBuilder, ctor);
1776         MonoMethodSignature *sig = ctor_builder_to_signature (image, ctor, error);
1777         HANDLE_FUNCTION_RETURN_VAL (sig);
1778 }
1779 /**
1780  * LOCKING: Assumes the loader lock is held.
1781  */
1782 static MonoMethodSignature*
1783 method_builder_to_signature (MonoImage *image, MonoReflectionMethodBuilderHandle method, MonoError *error) {
1784         MonoMethodSignature *sig;
1785
1786         error_init (error);
1787
1788         sig = parameters_to_signature (image, MONO_HANDLE_NEW_GET(MonoArray, method, parameters), error);
1789         return_val_if_nok (error, NULL);
1790         sig->hasthis = MONO_HANDLE_GETVAL (method, attrs) & METHOD_ATTRIBUTE_STATIC? 0: 1;
1791         MonoReflectionTypeHandle rtype = MONO_HANDLE_NEW_GET (MonoReflectionType, method, rtype);
1792         if (!MONO_HANDLE_IS_NULL (rtype)) {
1793                 sig->ret = mono_reflection_type_handle_mono_type (rtype, error);
1794                 if (!is_ok (error)) {
1795                         image_g_free (image, sig);
1796                         return NULL;
1797                 }
1798         } else {
1799                 sig->ret = &mono_defaults.void_class->byval_arg;
1800         }
1801         MonoArrayHandle generic_params = MONO_HANDLE_NEW_GET (MonoArray, method, generic_params);
1802         sig->generic_param_count = MONO_HANDLE_IS_NULL (generic_params) ? 0 : mono_array_handle_length (generic_params);
1803         return sig;
1804 }
1805
1806 static MonoMethodSignature*
1807 dynamic_method_to_signature (MonoReflectionDynamicMethodHandle method, MonoError *error) {
1808         HANDLE_FUNCTION_ENTER ();
1809         MonoMethodSignature *sig = NULL;
1810
1811         error_init (error);
1812
1813         sig = parameters_to_signature (NULL, MONO_HANDLE_NEW_GET (MonoArray, method, parameters), error);
1814         if (!is_ok (error))
1815                 goto leave;
1816         sig->hasthis = MONO_HANDLE_GETVAL (method, attrs) & METHOD_ATTRIBUTE_STATIC? 0: 1;
1817         MonoReflectionTypeHandle rtype = MONO_HANDLE_NEW_GET (MonoReflectionType, method, rtype);
1818         if (!MONO_HANDLE_IS_NULL (rtype)) {
1819                 sig->ret = mono_reflection_type_handle_mono_type (rtype, error);
1820                 if (!is_ok (error)) {
1821                         g_free (sig);
1822                         sig = NULL;
1823                         goto leave;
1824                 }
1825         } else {
1826                 sig->ret = &mono_defaults.void_class->byval_arg;
1827         }
1828         sig->generic_param_count = 0;
1829 leave:
1830         HANDLE_FUNCTION_RETURN_VAL (sig);
1831 }
1832
1833 static void
1834 get_prop_name_and_type (MonoObject *prop, char **name, MonoType **type, MonoError *error)
1835 {
1836         error_init (error);
1837         MonoClass *klass = mono_object_class (prop);
1838         if (strcmp (klass->name, "PropertyBuilder") == 0) {
1839                 MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *)prop;
1840                 *name = mono_string_to_utf8_checked (pb->name, error);
1841                 return_if_nok (error);
1842                 *type = mono_reflection_type_get_handle ((MonoReflectionType*)pb->type, error);
1843         } else {
1844                 MonoReflectionProperty *p = (MonoReflectionProperty *)prop;
1845                 *name = g_strdup (p->property->name);
1846                 if (p->property->get)
1847                         *type = mono_method_signature (p->property->get)->ret;
1848                 else
1849                         *type = mono_method_signature (p->property->set)->params [mono_method_signature (p->property->set)->param_count - 1];
1850         }
1851 }
1852
1853 static void
1854 get_field_name_and_type (MonoObject *field, char **name, MonoType **type, MonoError *error)
1855 {
1856         error_init (error);
1857         MonoClass *klass = mono_object_class (field);
1858         if (strcmp (klass->name, "FieldBuilder") == 0) {
1859                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)field;
1860                 *name = mono_string_to_utf8_checked (fb->name, error);
1861                 return_if_nok (error);
1862                 *type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
1863         } else {
1864                 MonoReflectionField *f = (MonoReflectionField *)field;
1865                 *name = g_strdup (mono_field_get_name (f->field));
1866                 *type = f->field->type;
1867         }
1868 }
1869
1870 #else /* DISABLE_REFLECTION_EMIT */
1871
1872 static gboolean
1873 is_sre_type_builder (MonoClass *klass)
1874 {
1875         return FALSE;
1876 }
1877
1878 static gboolean
1879 is_sre_generic_instance (MonoClass *klass)
1880 {
1881         return FALSE;
1882 }
1883
1884 gboolean
1885 mono_is_sre_ctor_builder (MonoClass *klass)
1886 {
1887         return FALSE;
1888 }
1889
1890 gboolean
1891 mono_is_sre_method_on_tb_inst (MonoClass *klass)
1892 {
1893         return FALSE;
1894 }
1895
1896 gboolean
1897 mono_is_sre_ctor_on_tb_inst (MonoClass *klass)
1898 {
1899         return FALSE;
1900 }
1901
1902 #endif /* !DISABLE_REFLECTION_EMIT */
1903
1904
1905 static gboolean
1906 is_sr_mono_field (MonoClass *klass)
1907 {
1908         check_corlib_type_cached (klass, "System.Reflection", "MonoField");
1909 }
1910
1911 gboolean
1912 mono_is_sr_mono_property (MonoClass *klass)
1913 {
1914         check_corlib_type_cached (klass, "System.Reflection", "MonoProperty");
1915 }
1916
1917 static gboolean
1918 is_sr_mono_method (MonoClass *klass)
1919 {
1920         check_corlib_type_cached (klass, "System.Reflection", "MonoMethod");
1921 }
1922
1923 gboolean
1924 mono_is_sr_mono_cmethod (MonoClass *klass)
1925 {
1926         check_corlib_type_cached (klass, "System.Reflection", "MonoCMethod");
1927 }
1928
1929 gboolean
1930 mono_class_is_reflection_method_or_constructor (MonoClass *klass)
1931 {
1932         return is_sr_mono_method (klass) || mono_is_sr_mono_cmethod (klass);
1933 }
1934
1935 gboolean
1936 mono_is_sre_type_builder (MonoClass *klass)
1937 {
1938         return is_sre_type_builder (klass);
1939 }
1940
1941 gboolean
1942 mono_is_sre_generic_instance (MonoClass *klass)
1943 {
1944         return is_sre_generic_instance (klass);
1945 }
1946
1947
1948
1949 /**
1950  * encode_cattr_value:
1951  * Encode a value in a custom attribute stream of bytes.
1952  * The value to encode is either supplied as an object in argument val
1953  * (valuetypes are boxed), or as a pointer to the data in the
1954  * argument argval.
1955  * @type represents the type of the value
1956  * @buffer is the start of the buffer
1957  * @p the current position in the buffer
1958  * @buflen contains the size of the buffer and is used to return the new buffer size
1959  * if this needs to be realloced.
1960  * @retbuffer and @retp return the start and the position of the buffer
1961  * @error set on error.
1962  */
1963 static void
1964 encode_cattr_value (MonoAssembly *assembly, char *buffer, char *p, char **retbuffer, char **retp, guint32 *buflen, MonoType *type, MonoObject *arg, char *argval, MonoError *error)
1965 {
1966         MonoTypeEnum simple_type;
1967
1968         error_init (error);
1969         if ((p-buffer) + 10 >= *buflen) {
1970                 char *newbuf;
1971                 *buflen *= 2;
1972                 newbuf = (char *)g_realloc (buffer, *buflen);
1973                 p = newbuf + (p-buffer);
1974                 buffer = newbuf;
1975         }
1976         if (!argval)
1977                 argval = ((char*)arg + sizeof (MonoObject));
1978         simple_type = type->type;
1979 handle_enum:
1980         switch (simple_type) {
1981         case MONO_TYPE_BOOLEAN:
1982         case MONO_TYPE_U1:
1983         case MONO_TYPE_I1:
1984                 *p++ = *argval;
1985                 break;
1986         case MONO_TYPE_CHAR:
1987         case MONO_TYPE_U2:
1988         case MONO_TYPE_I2:
1989                 swap_with_size (p, argval, 2, 1);
1990                 p += 2;
1991                 break;
1992         case MONO_TYPE_U4:
1993         case MONO_TYPE_I4:
1994         case MONO_TYPE_R4:
1995                 swap_with_size (p, argval, 4, 1);
1996                 p += 4;
1997                 break;
1998         case MONO_TYPE_R8:
1999                 swap_with_size (p, argval, 8, 1);
2000                 p += 8;
2001                 break;
2002         case MONO_TYPE_U8:
2003         case MONO_TYPE_I8:
2004                 swap_with_size (p, argval, 8, 1);
2005                 p += 8;
2006                 break;
2007         case MONO_TYPE_VALUETYPE:
2008                 if (type->data.klass->enumtype) {
2009                         simple_type = mono_class_enum_basetype (type->data.klass)->type;
2010                         goto handle_enum;
2011                 } else {
2012                         g_warning ("generic valutype %s not handled in custom attr value decoding", type->data.klass->name);
2013                 }
2014                 break;
2015         case MONO_TYPE_STRING: {
2016                 char *str;
2017                 guint32 slen;
2018                 if (!arg) {
2019                         *p++ = 0xFF;
2020                         break;
2021                 }
2022                 str = mono_string_to_utf8_checked ((MonoString*)arg, error);
2023                 return_if_nok (error);
2024                 slen = strlen (str);
2025                 if ((p-buffer) + 10 + slen >= *buflen) {
2026                         char *newbuf;
2027                         *buflen *= 2;
2028                         *buflen += slen;
2029                         newbuf = (char *)g_realloc (buffer, *buflen);
2030                         p = newbuf + (p-buffer);
2031                         buffer = newbuf;
2032                 }
2033                 mono_metadata_encode_value (slen, p, &p);
2034                 memcpy (p, str, slen);
2035                 p += slen;
2036                 g_free (str);
2037                 break;
2038         }
2039         case MONO_TYPE_CLASS: {
2040                 char *str;
2041                 guint32 slen;
2042                 MonoType *arg_type;
2043                 if (!arg) {
2044                         *p++ = 0xFF;
2045                         break;
2046                 }
2047 handle_type:
2048                 arg_type = mono_reflection_type_get_handle ((MonoReflectionType*)arg, error);
2049                 return_if_nok (error);
2050
2051                 str = type_get_qualified_name (arg_type, NULL);
2052                 slen = strlen (str);
2053                 if ((p-buffer) + 10 + slen >= *buflen) {
2054                         char *newbuf;
2055                         *buflen *= 2;
2056                         *buflen += slen;
2057                         newbuf = (char *)g_realloc (buffer, *buflen);
2058                         p = newbuf + (p-buffer);
2059                         buffer = newbuf;
2060                 }
2061                 mono_metadata_encode_value (slen, p, &p);
2062                 memcpy (p, str, slen);
2063                 p += slen;
2064                 g_free (str);
2065                 break;
2066         }
2067         case MONO_TYPE_SZARRAY: {
2068                 int len, i;
2069                 MonoClass *eclass, *arg_eclass;
2070
2071                 if (!arg) {
2072                         *p++ = 0xff; *p++ = 0xff; *p++ = 0xff; *p++ = 0xff;
2073                         break;
2074                 }
2075                 len = mono_array_length ((MonoArray*)arg);
2076                 *p++ = len & 0xff;
2077                 *p++ = (len >> 8) & 0xff;
2078                 *p++ = (len >> 16) & 0xff;
2079                 *p++ = (len >> 24) & 0xff;
2080                 *retp = p;
2081                 *retbuffer = buffer;
2082                 eclass = type->data.klass;
2083                 arg_eclass = mono_object_class (arg)->element_class;
2084
2085                 if (!eclass) {
2086                         /* Happens when we are called from the MONO_TYPE_OBJECT case below */
2087                         eclass = mono_defaults.object_class;
2088                 }
2089                 if (eclass == mono_defaults.object_class && arg_eclass->valuetype) {
2090                         char *elptr = mono_array_addr ((MonoArray*)arg, char, 0);
2091                         int elsize = mono_class_array_element_size (arg_eclass);
2092                         for (i = 0; i < len; ++i) {
2093                                 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &arg_eclass->byval_arg, NULL, elptr, error);
2094                                 return_if_nok (error);
2095                                 elptr += elsize;
2096                         }
2097                 } else if (eclass->valuetype && arg_eclass->valuetype) {
2098                         char *elptr = mono_array_addr ((MonoArray*)arg, char, 0);
2099                         int elsize = mono_class_array_element_size (eclass);
2100                         for (i = 0; i < len; ++i) {
2101                                 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &eclass->byval_arg, NULL, elptr, error);
2102                                 return_if_nok (error);
2103                                 elptr += elsize;
2104                         }
2105                 } else {
2106                         for (i = 0; i < len; ++i) {
2107                                 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &eclass->byval_arg, mono_array_get ((MonoArray*)arg, MonoObject*, i), NULL, error);
2108                                 return_if_nok (error);
2109                         }
2110                 }
2111                 break;
2112         }
2113         case MONO_TYPE_OBJECT: {
2114                 MonoClass *klass;
2115                 char *str;
2116                 guint32 slen;
2117
2118                 /*
2119                  * The parameter type is 'object' but the type of the actual
2120                  * argument is not. So we have to add type information to the blob
2121                  * too. This is completely undocumented in the spec.
2122                  */
2123
2124                 if (arg == NULL) {
2125                         *p++ = MONO_TYPE_STRING;        // It's same hack as MS uses
2126                         *p++ = 0xFF;
2127                         break;
2128                 }
2129
2130                 klass = mono_object_class (arg);
2131
2132                 if (mono_object_isinst_checked (arg, mono_defaults.systemtype_class, error)) {
2133                         *p++ = 0x50;
2134                         goto handle_type;
2135                 } else {
2136                         return_if_nok (error);
2137                 }
2138
2139                 if (klass->enumtype) {
2140                         *p++ = 0x55;
2141                 } else if (klass == mono_defaults.string_class) {
2142                         simple_type = MONO_TYPE_STRING;
2143                         *p++ = 0x0E;
2144                         goto handle_enum;
2145                 } else if (klass->rank == 1) {
2146                         *p++ = 0x1D;
2147                         if (klass->element_class->byval_arg.type == MONO_TYPE_OBJECT)
2148                                 /* See Partition II, Appendix B3 */
2149                                 *p++ = 0x51;
2150                         else
2151                                 *p++ = klass->element_class->byval_arg.type;
2152                         encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &klass->byval_arg, arg, NULL, error);
2153                         return_if_nok (error);
2154                         break;
2155                 } else if (klass->byval_arg.type >= MONO_TYPE_BOOLEAN && klass->byval_arg.type <= MONO_TYPE_R8) {
2156                         *p++ = simple_type = klass->byval_arg.type;
2157                         goto handle_enum;
2158                 } else {
2159                         g_error ("unhandled type in custom attr");
2160                 }
2161                 str = type_get_qualified_name (mono_class_get_type(klass), NULL);
2162                 slen = strlen (str);
2163                 if ((p-buffer) + 10 + slen >= *buflen) {
2164                         char *newbuf;
2165                         *buflen *= 2;
2166                         *buflen += slen;
2167                         newbuf = (char *)g_realloc (buffer, *buflen);
2168                         p = newbuf + (p-buffer);
2169                         buffer = newbuf;
2170                 }
2171                 mono_metadata_encode_value (slen, p, &p);
2172                 memcpy (p, str, slen);
2173                 p += slen;
2174                 g_free (str);
2175                 simple_type = mono_class_enum_basetype (klass)->type;
2176                 goto handle_enum;
2177         }
2178         default:
2179                 g_error ("type 0x%02x not yet supported in custom attr encoder", simple_type);
2180         }
2181         *retp = p;
2182         *retbuffer = buffer;
2183 }
2184
2185 static void
2186 encode_field_or_prop_type (MonoType *type, char *p, char **retp)
2187 {
2188         if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
2189                 char *str = type_get_qualified_name (type, NULL);
2190                 int slen = strlen (str);
2191
2192                 *p++ = 0x55;
2193                 /*
2194                  * This seems to be optional...
2195                  * *p++ = 0x80;
2196                  */
2197                 mono_metadata_encode_value (slen, p, &p);
2198                 memcpy (p, str, slen);
2199                 p += slen;
2200                 g_free (str);
2201         } else if (type->type == MONO_TYPE_OBJECT) {
2202                 *p++ = 0x51;
2203         } else if (type->type == MONO_TYPE_CLASS) {
2204                 /* it should be a type: encode_cattr_value () has the check */
2205                 *p++ = 0x50;
2206         } else {
2207                 mono_metadata_encode_value (type->type, p, &p);
2208                 if (type->type == MONO_TYPE_SZARRAY)
2209                         /* See the examples in Partition VI, Annex B */
2210                         encode_field_or_prop_type (&type->data.klass->byval_arg, p, &p);
2211         }
2212
2213         *retp = p;
2214 }
2215
2216 #ifndef DISABLE_REFLECTION_EMIT
2217 static void
2218 encode_named_val (MonoReflectionAssembly *assembly, char *buffer, char *p, char **retbuffer, char **retp, guint32 *buflen, MonoType *type, char *name, MonoObject *value, MonoError *error)
2219 {
2220         int len;
2221
2222         error_init (error);
2223
2224         /* Preallocate a large enough buffer */
2225         if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
2226                 char *str = type_get_qualified_name (type, NULL);
2227                 len = strlen (str);
2228                 g_free (str);
2229         } else if (type->type == MONO_TYPE_SZARRAY && type->data.klass->enumtype) {
2230                 char *str = type_get_qualified_name (&type->data.klass->byval_arg, NULL);
2231                 len = strlen (str);
2232                 g_free (str);
2233         } else {
2234                 len = 0;
2235         }
2236         len += strlen (name);
2237
2238         if ((p-buffer) + 20 + len >= *buflen) {
2239                 char *newbuf;
2240                 *buflen *= 2;
2241                 *buflen += len;
2242                 newbuf = (char *)g_realloc (buffer, *buflen);
2243                 p = newbuf + (p-buffer);
2244                 buffer = newbuf;
2245         }
2246
2247         encode_field_or_prop_type (type, p, &p);
2248
2249         len = strlen (name);
2250         mono_metadata_encode_value (len, p, &p);
2251         memcpy (p, name, len);
2252         p += len;
2253         encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, buflen, type, value, NULL, error);
2254         return_if_nok (error);
2255         *retp = p;
2256         *retbuffer = buffer;
2257 }
2258
2259 /**
2260  * mono_reflection_get_custom_attrs_blob:
2261  * \param ctor custom attribute constructor
2262  * \param ctorArgs arguments o the constructor
2263  * \param properties
2264  * \param propValues
2265  * \param fields
2266  * \param fieldValues
2267  * Creates the blob of data that needs to be saved in the metadata and that represents
2268  * the custom attributed described by \p ctor, \p ctorArgs etc.
2269  * \returns a \c Byte array representing the blob of data.
2270  */
2271 MonoArray*
2272 mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
2273 {
2274         MonoError error;
2275         MonoArray *result = mono_reflection_get_custom_attrs_blob_checked (assembly, ctor, ctorArgs, properties, propValues, fields, fieldValues, &error);
2276         mono_error_cleanup (&error);
2277         return result;
2278 }
2279
2280 /**
2281  * mono_reflection_get_custom_attrs_blob_checked:
2282  * \param ctor custom attribute constructor
2283  * \param ctorArgs arguments o the constructor
2284  * \param properties
2285  * \param propValues
2286  * \param fields
2287  * \param fieldValues
2288  * \param error set on error
2289  * Creates the blob of data that needs to be saved in the metadata and that represents
2290  * the custom attributed described by \p ctor, \p ctorArgs etc.
2291  * \returns a \c Byte array representing the blob of data.  On failure returns NULL and sets \p error.
2292  */
2293 MonoArray*
2294 mono_reflection_get_custom_attrs_blob_checked (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues, MonoError *error)
2295 {
2296         MonoArray *result = NULL;
2297         MonoMethodSignature *sig;
2298         MonoObject *arg;
2299         char *buffer, *p;
2300         guint32 buflen, i;
2301
2302         error_init (error);
2303
2304         if (strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
2305                 /* sig is freed later so allocate it in the heap */
2306                 sig = ctor_builder_to_signature_raw (NULL, (MonoReflectionCtorBuilder*)ctor, error); /* FIXME use handles */
2307                 if (!is_ok (error)) {
2308                         g_free (sig);
2309                         return NULL;
2310                 }
2311         } else {
2312                 sig = mono_method_signature (((MonoReflectionMethod*)ctor)->method);
2313         }
2314
2315         g_assert (mono_array_length (ctorArgs) == sig->param_count);
2316         buflen = 256;
2317         p = buffer = (char *)g_malloc (buflen);
2318         /* write the prolog */
2319         *p++ = 1;
2320         *p++ = 0;
2321         for (i = 0; i < sig->param_count; ++i) {
2322                 arg = mono_array_get (ctorArgs, MonoObject*, i);
2323                 encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, &buflen, sig->params [i], arg, NULL, error);
2324                 if (!is_ok (error)) goto leave;
2325         }
2326         i = 0;
2327         if (properties)
2328                 i += mono_array_length (properties);
2329         if (fields)
2330                 i += mono_array_length (fields);
2331         *p++ = i & 0xff;
2332         *p++ = (i >> 8) & 0xff;
2333         if (properties) {
2334                 MonoObject *prop;
2335                 for (i = 0; i < mono_array_length (properties); ++i) {
2336                         MonoType *ptype;
2337                         char *pname;
2338
2339                         prop = (MonoObject *)mono_array_get (properties, gpointer, i);
2340                         get_prop_name_and_type (prop, &pname, &ptype, error);
2341                         if (!is_ok (error)) goto leave;
2342                         *p++ = 0x54; /* PROPERTY signature */
2343                         encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ptype, pname, (MonoObject*)mono_array_get (propValues, gpointer, i), error);
2344                         g_free (pname);
2345                         if (!is_ok (error)) goto leave;
2346                 }
2347         }
2348
2349         if (fields) {
2350                 MonoObject *field;
2351                 for (i = 0; i < mono_array_length (fields); ++i) {
2352                         MonoType *ftype;
2353                         char *fname;
2354
2355                         field = (MonoObject *)mono_array_get (fields, gpointer, i);
2356                         get_field_name_and_type (field, &fname, &ftype, error);
2357                         if (!is_ok (error)) goto leave;
2358                         *p++ = 0x53; /* FIELD signature */
2359                         encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ftype, fname, (MonoObject*)mono_array_get (fieldValues, gpointer, i), error);
2360                         g_free (fname);
2361                         if (!is_ok (error)) goto leave;
2362                 }
2363         }
2364
2365         g_assert (p - buffer <= buflen);
2366         buflen = p - buffer;
2367         result = mono_array_new_checked (mono_domain_get (), mono_defaults.byte_class, buflen, error);
2368         if (!is_ok (error))
2369                 goto leave;
2370         p = mono_array_addr (result, char, 0);
2371         memcpy (p, buffer, buflen);
2372 leave:
2373         g_free (buffer);
2374         if (strcmp (ctor->vtable->klass->name, "MonoCMethod"))
2375                 g_free (sig);
2376         return result;
2377 }
2378
2379 static gboolean
2380 reflection_setup_class_hierarchy (GHashTable *unparented, MonoError *error)
2381 {
2382         error_init (error);
2383
2384         mono_loader_lock ();
2385
2386         MonoType *parent_type;
2387         MonoType *child_type;
2388         GHashTableIter iter;
2389
2390         g_hash_table_iter_init (&iter, unparented);
2391
2392         while (g_hash_table_iter_next (&iter, (gpointer *) &child_type, (gpointer *) &parent_type)) {
2393                 MonoClass *child_class = mono_class_from_mono_type (child_type);
2394                 if (parent_type != NULL) {
2395                         MonoClass *parent_class = mono_class_from_mono_type (parent_type);
2396                         child_class->parent = NULL;
2397                         /* fool mono_class_setup_parent */
2398                         child_class->supertypes = NULL;
2399                         mono_class_setup_parent (child_class, parent_class);
2400                 } else if (strcmp (child_class->name, "Object") == 0 && strcmp (child_class->name_space, "System") == 0) {
2401                         const char *old_n = child_class->name;
2402                         /* trick to get relative numbering right when compiling corlib */
2403                         child_class->name = "BuildingObject";
2404                         mono_class_setup_parent (child_class, mono_defaults.object_class);
2405                         child_class->name = old_n;
2406                 }
2407                 mono_class_setup_mono_type (child_class);
2408                 mono_class_setup_supertypes (child_class);
2409         }
2410
2411         mono_loader_unlock ();
2412         return is_ok (error);
2413 }
2414
2415 static gboolean
2416 reflection_setup_internal_class_internal (MonoReflectionTypeBuilderHandle ref_tb, MonoError *error)
2417 {
2418         HANDLE_FUNCTION_ENTER ();
2419         error_init (error);
2420
2421         mono_loader_lock ();
2422
2423         gint32 entering_state = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionTypeBuilder, ref_tb), state);
2424         if (entering_state != MonoTypeBuilderNew) {
2425                 g_assert (MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionType, ref_tb), type));
2426                 goto leave;
2427         }
2428
2429         MONO_HANDLE_SETVAL (ref_tb, state, MonoTypeBuilderState, MonoTypeBuilderEntered);
2430         MonoReflectionModuleBuilderHandle module_ref = MONO_HANDLE_NEW_GET (MonoReflectionModuleBuilder, ref_tb, module);
2431         GHashTable *unparented_classes = MONO_HANDLE_GETVAL(module_ref, unparented_classes);
2432
2433         // If this type is already setup, exit. We'll fix the parenting later
2434         MonoType *type = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionType, ref_tb), type);
2435         if (type)
2436                 goto leave;
2437
2438         MonoReflectionModuleBuilderHandle ref_module = MONO_HANDLE_NEW_GET (MonoReflectionModuleBuilder, ref_tb, module);
2439         MonoDynamicImage *dynamic_image = MONO_HANDLE_GETVAL (ref_module, dynamic_image);
2440
2441         MonoStringHandle ref_name = MONO_HANDLE_NEW_GET (MonoString, ref_tb, name);
2442         MonoStringHandle ref_nspace = MONO_HANDLE_NEW_GET (MonoString, ref_tb, nspace);
2443
2444         guint32 table_idx = MONO_HANDLE_GETVAL (ref_tb, table_idx);
2445         /*
2446          * The size calculation here warrants some explaining.
2447          * reflection_setup_internal_class is called too early, well before we know whether the type will be a GTD or DEF,
2448          * meaning we need to alloc enough space to morth a def into a gtd.
2449          */
2450         MonoClass *klass = (MonoClass *)mono_image_alloc0 (&dynamic_image->image, MAX (sizeof (MonoClassDef), sizeof (MonoClassGtd)));
2451         klass->class_kind = MONO_CLASS_DEF;
2452
2453         klass->image = &dynamic_image->image;
2454
2455         klass->inited = 1; /* we lie to the runtime */
2456         klass->name = mono_string_to_utf8_image (klass->image, ref_name, error);
2457         if (!is_ok (error))
2458                 goto leave;
2459         klass->name_space = mono_string_to_utf8_image (klass->image, ref_nspace, error);
2460         if (!is_ok (error))
2461                 goto leave;
2462         klass->type_token = MONO_TOKEN_TYPE_DEF | table_idx;
2463         mono_class_set_flags (klass, MONO_HANDLE_GETVAL (ref_tb, attrs));
2464
2465         MONO_PROFILER_RAISE (class_loading, (klass));
2466
2467         klass->element_class = klass;
2468
2469         g_assert (!mono_class_has_ref_info (klass));
2470         mono_class_set_ref_info (klass, MONO_HANDLE_CAST (MonoObject, ref_tb));
2471
2472         MonoReflectionTypeHandle ref_nesting_type = MONO_HANDLE_NEW_GET (MonoReflectionType, ref_tb, nesting_type);
2473         /* Put into cache so mono_class_get_checked () will find it.
2474            Skip nested types as those should not be available on the global scope. */
2475         if (MONO_HANDLE_IS_NULL (ref_nesting_type))
2476                 mono_image_add_to_name_cache (klass->image, klass->name_space, klass->name, table_idx);
2477
2478         /*
2479           We must register all types as we cannot rely on the name_cache hashtable since we find the class
2480           by performing a mono_class_get which does the full resolution.
2481
2482           Working around this semantics would require us to write a lot of code for no clear advantage.
2483         */
2484         mono_image_append_class_to_reflection_info_set (klass);
2485
2486         mono_dynamic_image_register_token (dynamic_image, MONO_TOKEN_TYPE_DEF | table_idx, MONO_HANDLE_CAST (MonoObject, ref_tb), MONO_DYN_IMAGE_TOK_NEW);
2487
2488         if ((!strcmp (klass->name, "ValueType") && !strcmp (klass->name_space, "System")) ||
2489                         (!strcmp (klass->name, "Object") && !strcmp (klass->name_space, "System")) ||
2490                         (!strcmp (klass->name, "Enum") && !strcmp (klass->name_space, "System"))) {
2491                 klass->instance_size = sizeof (MonoObject);
2492                 klass->size_inited = 1;
2493                 mono_class_setup_vtable_general (klass, NULL, 0, NULL);
2494         }
2495
2496         mono_class_setup_mono_type (klass);
2497
2498         /*
2499          * FIXME: handle interfaces.
2500          */
2501         MonoReflectionTypeHandle ref_tb_type = MONO_HANDLE_CAST (MonoReflectionType, ref_tb);
2502         MONO_HANDLE_SETVAL (ref_tb_type, type, MonoType*, &klass->byval_arg);
2503         MONO_HANDLE_SETVAL (ref_tb, state, gint32, MonoTypeBuilderFinished);
2504
2505         reflection_init_generic_class (ref_tb, error);
2506         if (!is_ok (error))
2507                 goto leave;
2508
2509         // Do here so that the search inside of the parent can see the above type that's been set.
2510         MonoReflectionTypeHandle ref_parent = MONO_HANDLE_NEW_GET (MonoReflectionType, ref_tb, parent);
2511         MonoType *parent_type = NULL;
2512         if (!MONO_HANDLE_IS_NULL (ref_parent)) {
2513                 MonoClass *parent_klass = mono_handle_class (ref_parent);
2514                 gboolean recursive_init = TRUE;
2515
2516                 if (is_sre_type_builder (parent_klass)) {
2517                         MonoTypeBuilderState parent_state = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionTypeBuilder, ref_parent), state);
2518
2519                         if (parent_state != MonoTypeBuilderNew) {
2520                                 // Initialize types reachable from parent recursively
2521                                 // We'll fix the type hierarchy later
2522                                 recursive_init = FALSE;
2523                         }
2524                 }
2525
2526                 if (recursive_init) {
2527                         // If we haven't encountered a cycle, force the creation of ref_parent's type
2528                         mono_reflection_type_handle_mono_type (ref_parent, error);
2529                         if (!is_ok (error))
2530                                 goto leave;
2531                 }
2532
2533                 parent_type = MONO_HANDLE_GETVAL (ref_parent, type);
2534
2535                 // If we failed to create the parent, fail the child
2536                 if (!parent_type)
2537                         goto leave;
2538         }
2539
2540         // Push the child type and parent type to process later
2541         // Note: parent_type may be null.
2542         g_assert (!g_hash_table_lookup (unparented_classes, &klass->byval_arg));
2543         g_hash_table_insert (unparented_classes, &klass->byval_arg, parent_type);
2544
2545         if (!MONO_HANDLE_IS_NULL (ref_nesting_type)) {
2546                 if (!reflection_setup_internal_class (MONO_HANDLE_CAST (MonoReflectionTypeBuilder, ref_nesting_type), error))
2547                         goto leave;
2548
2549                 MonoType *nesting_type = mono_reflection_type_handle_mono_type (ref_nesting_type, error);
2550                 if (!is_ok (error))
2551                         goto leave;
2552                 klass->nested_in = mono_class_from_mono_type (nesting_type);
2553         }
2554
2555         /*g_print ("setup %s as %s (%p)\n", klass->name, ((MonoObject*)tb)->vtable->klass->name, tb);*/
2556
2557         MONO_PROFILER_RAISE (class_loaded, (klass));
2558
2559 leave:
2560         mono_loader_unlock ();
2561         HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
2562 }
2563
2564 /**
2565  * reflection_init_generic_class:
2566  * @tb: a TypeBuilder object
2567  * @error: set on error
2568  *
2569  * Creates the generic class after all generic parameters have been added.
2570  * On success returns TRUE, on failure returns FALSE and sets @error.
2571  *
2572  * This assumes that reflection_setup_internal_class has already set up
2573  * ref_tb
2574  */
2575 static gboolean
2576 reflection_init_generic_class (MonoReflectionTypeBuilderHandle ref_tb, MonoError *error)
2577 {
2578         HANDLE_FUNCTION_ENTER ();
2579
2580         error_init (error);
2581
2582         MonoTypeBuilderState ref_state = MONO_HANDLE_GETVAL (ref_tb, state);
2583         g_assert (ref_state == MonoTypeBuilderFinished);
2584
2585         MonoType *type = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionType, ref_tb), type);
2586         MonoClass *klass = mono_class_from_mono_type (type);
2587
2588         MonoArrayHandle generic_params = MONO_HANDLE_NEW_GET (MonoArray, ref_tb, generic_params);
2589         int count = MONO_HANDLE_IS_NULL (generic_params) ? 0 : mono_array_handle_length (generic_params);
2590
2591         if (count == 0)
2592                 goto leave;
2593
2594         if (mono_class_try_get_generic_container (klass) != NULL)
2595                 goto leave; /* already setup */
2596
2597         MonoGenericContainer *generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
2598
2599         generic_container->owner.klass = klass;
2600         generic_container->type_argc = count;
2601         generic_container->type_params = (MonoGenericParamFull *)mono_image_alloc0 (klass->image, sizeof (MonoGenericParamFull) * count);
2602
2603         klass->class_kind = MONO_CLASS_GTD;
2604         mono_class_set_generic_container (klass, generic_container);
2605
2606
2607         MonoReflectionGenericParamHandle ref_gparam = MONO_HANDLE_NEW (MonoReflectionGenericParam, NULL);
2608         for (int i = 0; i < count; i++) {
2609                 MONO_HANDLE_ARRAY_GETREF (ref_gparam, generic_params, i);
2610                 MonoType *param_type = mono_reflection_type_handle_mono_type (MONO_HANDLE_CAST (MonoReflectionType, ref_gparam), error);
2611                 if (!is_ok (error))
2612                         goto leave;
2613                 MonoGenericParamFull *param = (MonoGenericParamFull *) param_type->data.generic_param;
2614                 generic_container->type_params [i] = *param;
2615                 /*Make sure we are a diferent type instance */
2616                 generic_container->type_params [i].param.owner = generic_container;
2617                 generic_container->type_params [i].info.pklass = NULL;
2618                 generic_container->type_params [i].info.flags = MONO_HANDLE_GETVAL (ref_gparam, attrs);
2619
2620                 g_assert (generic_container->type_params [i].param.owner);
2621         }
2622
2623         generic_container->context.class_inst = mono_get_shared_generic_inst (generic_container);
2624         MonoGenericContext* context = &generic_container->context;
2625         MonoType *canonical_inst = &((MonoClassGtd*)klass)->canonical_inst;
2626         canonical_inst->type = MONO_TYPE_GENERICINST;
2627         canonical_inst->data.generic_class = mono_metadata_lookup_generic_class (klass, context->class_inst, FALSE);
2628
2629 leave:
2630         HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
2631 }
2632
2633 static MonoMarshalSpec*
2634 mono_marshal_spec_from_builder (MonoImage *image, MonoAssembly *assembly,
2635                                 MonoReflectionMarshal *minfo, MonoError *error)
2636 {
2637         MonoMarshalSpec *res;
2638
2639         error_init (error);
2640
2641         res = image_g_new0 (image, MonoMarshalSpec, 1);
2642         res->native = (MonoMarshalNative)minfo->type;
2643
2644         switch (minfo->type) {
2645         case MONO_NATIVE_LPARRAY:
2646                 res->data.array_data.elem_type = (MonoMarshalNative)minfo->eltype;
2647                 if (minfo->has_size) {
2648                         res->data.array_data.param_num = minfo->param_num;
2649                         res->data.array_data.num_elem = minfo->count;
2650                         res->data.array_data.elem_mult = minfo->param_num == -1 ? 0 : 1;
2651                 }
2652                 else {
2653                         res->data.array_data.param_num = -1;
2654                         res->data.array_data.num_elem = -1;
2655                         res->data.array_data.elem_mult = -1;
2656                 }
2657                 break;
2658
2659         case MONO_NATIVE_BYVALTSTR:
2660         case MONO_NATIVE_BYVALARRAY:
2661                 res->data.array_data.num_elem = minfo->count;
2662                 break;
2663
2664         case MONO_NATIVE_CUSTOM:
2665                 if (minfo->marshaltyperef) {
2666                         MonoType *marshaltyperef = mono_reflection_type_get_handle ((MonoReflectionType*)minfo->marshaltyperef, error);
2667                         if (!is_ok (error)) {
2668                                 image_g_free (image, res);
2669                                 return NULL;
2670                         }
2671                         res->data.custom_data.custom_name =
2672                                 type_get_fully_qualified_name (marshaltyperef);
2673                 }
2674                 if (minfo->mcookie) {
2675                         res->data.custom_data.cookie = mono_string_to_utf8_checked (minfo->mcookie, error);
2676                         if (!is_ok (error)) {
2677                                 image_g_free (image, res);
2678                                 return NULL;
2679                         }
2680                 }
2681                 break;
2682
2683         default:
2684                 break;
2685         }
2686
2687         return res;
2688 }
2689 #endif /* !DISABLE_REFLECTION_EMIT */
2690
2691 MonoReflectionMarshalAsAttributeHandle
2692 mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
2693                                                         MonoMarshalSpec *spec, MonoError *error)
2694 {
2695         error_init (error);
2696
2697         MonoReflectionMarshalAsAttributeHandle minfo = MONO_HANDLE_NEW (MonoReflectionMarshalAsAttribute, mono_object_new_checked (domain, mono_class_get_marshal_as_attribute_class (), error));
2698         if (!is_ok (error))
2699                 goto fail;
2700         guint32 utype = spec->native;
2701         MONO_HANDLE_SETVAL (minfo, utype, guint32, utype);
2702
2703         switch (utype) {
2704         case MONO_NATIVE_LPARRAY:
2705                 MONO_HANDLE_SETVAL (minfo, array_subtype, guint32, spec->data.array_data.elem_type);
2706                 MONO_HANDLE_SETVAL (minfo, size_const, gint32, spec->data.array_data.num_elem);
2707                 if (spec->data.array_data.param_num != -1)
2708                         MONO_HANDLE_SETVAL (minfo, size_param_index, gint16, spec->data.array_data.param_num);
2709                 break;
2710
2711         case MONO_NATIVE_BYVALTSTR:
2712         case MONO_NATIVE_BYVALARRAY:
2713                 MONO_HANDLE_SETVAL (minfo, size_const, gint32, spec->data.array_data.num_elem);
2714                 break;
2715
2716         case MONO_NATIVE_CUSTOM:
2717                 if (spec->data.custom_data.custom_name) {
2718                         MonoType *mtype = mono_reflection_type_from_name_checked (spec->data.custom_data.custom_name, klass->image, error);
2719                         if (!is_ok (error))
2720                                 goto fail;
2721
2722                         if (mtype) {
2723                                 MonoReflectionTypeHandle rt = mono_type_get_object_handle (domain, mtype, error);
2724                                 if (!is_ok (error))
2725                                         goto fail;
2726
2727                                 MONO_HANDLE_SET (minfo, marshal_type_ref, rt);
2728                         }
2729
2730                         MonoStringHandle custom_name = mono_string_new_handle (domain, spec->data.custom_data.custom_name, error);
2731                         if (!is_ok (error))
2732                                 goto fail;
2733                         MONO_HANDLE_SET (minfo, marshal_type, custom_name);
2734                 }
2735                 if (spec->data.custom_data.cookie) {
2736                         MonoStringHandle cookie = mono_string_new_handle (domain, spec->data.custom_data.cookie, error);
2737                         if (!is_ok (error))
2738                                 goto fail;
2739                         MONO_HANDLE_SET (minfo, marshal_cookie, cookie);
2740                 }
2741                 break;
2742
2743         default:
2744                 break;
2745         }
2746
2747         return minfo;
2748 fail:
2749         return MONO_HANDLE_NEW (MonoReflectionMarshalAsAttribute, NULL);
2750 }
2751
2752 #ifndef DISABLE_REFLECTION_EMIT
2753 static MonoMethod*
2754 reflection_methodbuilder_to_mono_method (MonoClass *klass,
2755                                          ReflectionMethodBuilder *rmb,
2756                                          MonoMethodSignature *sig,
2757                                          MonoError *error)
2758 {
2759         MonoMethod *m;
2760         MonoMethodWrapper *wrapperm;
2761         MonoMarshalSpec **specs;
2762         MonoReflectionMethodAux *method_aux;
2763         MonoImage *image;
2764         gboolean dynamic;
2765         int i;
2766
2767         error_init (error);
2768         /*
2769          * Methods created using a MethodBuilder should have their memory allocated
2770          * inside the image mempool, while dynamic methods should have their memory
2771          * malloc'd.
2772          */
2773         dynamic = rmb->refs != NULL;
2774         image = dynamic ? NULL : klass->image;
2775
2776         if (!dynamic)
2777                 g_assert (!mono_class_is_ginst (klass));
2778
2779         mono_loader_lock ();
2780
2781         if ((rmb->attrs & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
2782                         (rmb->iattrs & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
2783                 m = (MonoMethod *)image_g_new0 (image, MonoMethodPInvoke, 1);
2784         else
2785                 m = (MonoMethod *)image_g_new0 (image, MonoMethodWrapper, 1);
2786
2787         wrapperm = (MonoMethodWrapper*)m;
2788
2789         m->dynamic = dynamic;
2790         m->slot = -1;
2791         m->flags = rmb->attrs;
2792         m->iflags = rmb->iattrs;
2793         m->name = mono_string_to_utf8_image_ignore (image, rmb->name);
2794         m->klass = klass;
2795         m->signature = sig;
2796         m->sre_method = TRUE;
2797         m->skip_visibility = rmb->skip_visibility;
2798         if (rmb->table_idx)
2799                 m->token = MONO_TOKEN_METHOD_DEF | (*rmb->table_idx);
2800
2801         if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
2802                 if (klass == mono_defaults.string_class && !strcmp (m->name, ".ctor"))
2803                         m->string_ctor = 1;
2804
2805                 m->signature->pinvoke = 1;
2806         } else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
2807                 m->signature->pinvoke = 1;
2808
2809                 method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
2810
2811                 method_aux->dllentry = rmb->dllentry ? string_to_utf8_image_raw (image, rmb->dllentry, error) : image_strdup (image, m->name);
2812                 mono_error_assert_ok (error);
2813                 method_aux->dll = string_to_utf8_image_raw (image, rmb->dll, error);
2814                 mono_error_assert_ok (error);
2815
2816                 ((MonoMethodPInvoke*)m)->piflags = (rmb->native_cc << 8) | (rmb->charset ? (rmb->charset - 1) * 2 : 0) | rmb->extra_flags;
2817
2818                 if (image_is_dynamic (klass->image))
2819                         g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
2820
2821                 mono_loader_unlock ();
2822
2823                 return m;
2824         } else if (!(m->flags & METHOD_ATTRIBUTE_ABSTRACT) &&
2825                            !(m->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
2826                 MonoMethodHeader *header;
2827                 guint32 code_size;
2828                 gint32 max_stack, i;
2829                 gint32 num_locals = 0;
2830                 gint32 num_clauses = 0;
2831                 guint8 *code;
2832
2833                 if (rmb->ilgen) {
2834                         code = mono_array_addr (rmb->ilgen->code, guint8, 0);
2835                         code_size = rmb->ilgen->code_len;
2836                         max_stack = rmb->ilgen->max_stack;
2837                         num_locals = rmb->ilgen->locals ? mono_array_length (rmb->ilgen->locals) : 0;
2838                         if (rmb->ilgen->ex_handlers)
2839                                 num_clauses = mono_reflection_method_count_clauses (rmb->ilgen);
2840                 } else {
2841                         if (rmb->code) {
2842                                 code = mono_array_addr (rmb->code, guint8, 0);
2843                                 code_size = mono_array_length (rmb->code);
2844                                 /* we probably need to run a verifier on the code... */
2845                                 max_stack = 8;
2846                         }
2847                         else {
2848                                 code = NULL;
2849                                 code_size = 0;
2850                                 max_stack = 8;
2851                         }
2852                 }
2853
2854                 header = (MonoMethodHeader *)mono_image_g_malloc0 (image, MONO_SIZEOF_METHOD_HEADER + num_locals * sizeof (MonoType*));
2855                 header->code_size = code_size;
2856                 header->code = (const unsigned char *)image_g_malloc (image, code_size);
2857                 memcpy ((char*)header->code, code, code_size);
2858                 header->max_stack = max_stack;
2859                 header->init_locals = rmb->init_locals;
2860                 header->num_locals = num_locals;
2861
2862                 for (i = 0; i < num_locals; ++i) {
2863                         MonoReflectionLocalBuilder *lb =
2864                                 mono_array_get (rmb->ilgen->locals, MonoReflectionLocalBuilder*, i);
2865
2866                         header->locals [i] = image_g_new0 (image, MonoType, 1);
2867                         MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)lb->type, error);
2868                         mono_error_assert_ok (error);
2869                         memcpy (header->locals [i], type, MONO_SIZEOF_TYPE);
2870                 }
2871
2872                 header->num_clauses = num_clauses;
2873                 if (num_clauses) {
2874                         header->clauses = method_encode_clauses (image, (MonoDynamicImage*)klass->image,
2875                                                                  rmb->ilgen, num_clauses, error);
2876                         mono_error_assert_ok (error);
2877                 }
2878
2879                 wrapperm->header = header;
2880         }
2881
2882         if (rmb->generic_params) {
2883                 int count = mono_array_length (rmb->generic_params);
2884                 MonoGenericContainer *container;
2885
2886                 container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
2887                 container->is_method = TRUE;
2888                 container->is_anonymous = FALSE;
2889                 container->type_argc = count;
2890                 container->type_params = image_g_new0 (image, MonoGenericParamFull, count);
2891                 container->owner.method = m;
2892
2893                 m->is_generic = TRUE;
2894                 mono_method_set_generic_container (m, container);
2895
2896                 for (i = 0; i < count; i++) {
2897                         MonoReflectionGenericParam *gp =
2898                                 mono_array_get (rmb->generic_params, MonoReflectionGenericParam*, i);
2899                         MonoType *gp_type = mono_reflection_type_get_handle ((MonoReflectionType*)gp, error);
2900                         mono_error_assert_ok (error);
2901                         MonoGenericParamFull *param = (MonoGenericParamFull *) gp_type->data.generic_param;
2902                         container->type_params [i] = *param;
2903                         container->type_params [i].param.owner = container;
2904
2905                         gp->type.type->data.generic_param = (MonoGenericParam*)&container->type_params [i];
2906
2907                         MonoClass *gklass = mono_class_from_mono_type (gp_type);
2908                         gklass->wastypebuilder = TRUE;
2909                 }
2910
2911                 /*
2912                  * The method signature might have pointers to generic parameters that belong to other methods.
2913                  * This is a valid SRE case, but the resulting method signature must be encoded using the proper
2914                  * generic parameters.
2915                  */
2916                 for (i = 0; i < m->signature->param_count; ++i) {
2917                         MonoType *t = m->signature->params [i];
2918                         if (t->type == MONO_TYPE_MVAR) {
2919                                 MonoGenericParam *gparam =  t->data.generic_param;
2920                                 if (gparam->num < count) {
2921                                         m->signature->params [i] = mono_metadata_type_dup (image, m->signature->params [i]);
2922                                         m->signature->params [i]->data.generic_param = mono_generic_container_get_param (container, gparam->num);
2923                                 }
2924
2925                         }
2926                 }
2927
2928                 if (mono_class_is_gtd (klass)) {
2929                         container->parent = mono_class_get_generic_container (klass);
2930                         container->context.class_inst = mono_class_get_generic_container (klass)->context.class_inst;
2931                 }
2932                 container->context.method_inst = mono_get_shared_generic_inst (container);
2933         }
2934
2935         if (rmb->refs) {
2936                 MonoMethodWrapper *mw = (MonoMethodWrapper*)m;
2937                 int i;
2938                 void **data;
2939
2940                 m->wrapper_type = MONO_WRAPPER_DYNAMIC_METHOD;
2941
2942                 mw->method_data = data = image_g_new (image, gpointer, rmb->nrefs + 1);
2943                 data [0] = GUINT_TO_POINTER (rmb->nrefs);
2944                 for (i = 0; i < rmb->nrefs; ++i)
2945                         data [i + 1] = rmb->refs [i];
2946         }
2947
2948         method_aux = NULL;
2949
2950         /* Parameter info */
2951         if (rmb->pinfo) {
2952                 if (!method_aux)
2953                         method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
2954                 method_aux->param_names = image_g_new0 (image, char *, mono_method_signature (m)->param_count + 1);
2955                 for (i = 0; i <= m->signature->param_count; ++i) {
2956                         MonoReflectionParamBuilder *pb;
2957                         if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) {
2958                                 if ((i > 0) && (pb->attrs)) {
2959                                         /* Make a copy since it might point to a shared type structure */
2960                                         m->signature->params [i - 1] = mono_metadata_type_dup (klass->image, m->signature->params [i - 1]);
2961                                         m->signature->params [i - 1]->attrs = pb->attrs;
2962                                 }
2963
2964                                 if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
2965                                         MonoDynamicImage *assembly;
2966                                         guint32 idx, len;
2967                                         MonoTypeEnum def_type;
2968                                         char *p;
2969                                         const char *p2;
2970
2971                                         if (!method_aux->param_defaults) {
2972                                                 method_aux->param_defaults = image_g_new0 (image, guint8*, m->signature->param_count + 1);
2973                                                 method_aux->param_default_types = image_g_new0 (image, guint32, m->signature->param_count + 1);
2974                                         }
2975                                         assembly = (MonoDynamicImage*)klass->image;
2976                                         idx = mono_dynimage_encode_constant (assembly, pb->def_value, &def_type);
2977                                         /* Copy the data from the blob since it might get realloc-ed */
2978                                         p = assembly->blob.data + idx;
2979                                         len = mono_metadata_decode_blob_size (p, &p2);
2980                                         len += p2 - p;
2981                                         method_aux->param_defaults [i] = (uint8_t *)image_g_malloc (image, len);
2982                                         method_aux->param_default_types [i] = def_type;
2983                                         memcpy ((gpointer)method_aux->param_defaults [i], p, len);
2984                                 }
2985
2986                                 if (pb->name) {
2987                                         method_aux->param_names [i] = string_to_utf8_image_raw (image, pb->name, error);
2988                                         mono_error_assert_ok (error);
2989                                 }
2990                                 if (pb->cattrs) {
2991                                         if (!method_aux->param_cattr)
2992                                                 method_aux->param_cattr = image_g_new0 (image, MonoCustomAttrInfo*, m->signature->param_count + 1);
2993                                         method_aux->param_cattr [i] = mono_custom_attrs_from_builders (image, klass->image, pb->cattrs);
2994                                 }
2995                         }
2996                 }
2997         }
2998
2999         /* Parameter marshalling */
3000         specs = NULL;
3001         if (rmb->pinfo)
3002                 for (i = 0; i < mono_array_length (rmb->pinfo); ++i) {
3003                         MonoReflectionParamBuilder *pb;
3004                         if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) {
3005                                 if (pb->marshal_info) {
3006                                         if (specs == NULL)
3007                                                 specs = image_g_new0 (image, MonoMarshalSpec*, sig->param_count + 1);
3008                                         specs [pb->position] =
3009                                                 mono_marshal_spec_from_builder (image, klass->image->assembly, pb->marshal_info, error);
3010                                         if (!is_ok (error)) {
3011                                                 mono_loader_unlock ();
3012                                                 image_g_free (image, specs);
3013                                                 /* FIXME: if image is NULL, this leaks all the other stuff we alloc'd in this function */
3014                                                 return NULL;
3015                                         }
3016                                 }
3017                         }
3018                 }
3019         if (specs != NULL) {
3020                 if (!method_aux)
3021                         method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
3022                 method_aux->param_marshall = specs;
3023         }
3024
3025         if (image_is_dynamic (klass->image) && method_aux)
3026                 g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
3027
3028         mono_loader_unlock ();
3029
3030         return m;
3031 }
3032
3033 static MonoMethod*
3034 ctorbuilder_to_mono_method (MonoClass *klass, MonoReflectionCtorBuilder* mb, MonoError *error)
3035 {
3036         ReflectionMethodBuilder rmb;
3037         MonoMethodSignature *sig;
3038
3039         mono_loader_lock ();
3040
3041         if (!mono_reflection_methodbuilder_from_ctor_builder (&rmb, mb, error))
3042                 return NULL;
3043
3044         g_assert (klass->image != NULL);
3045         sig = ctor_builder_to_signature_raw (klass->image, mb, error); /* FIXME use handles */
3046         mono_loader_unlock ();
3047         return_val_if_nok (error, NULL);
3048
3049         mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig, error);
3050         return_val_if_nok (error, NULL);
3051         mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
3052
3053         if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save) {
3054                 /* ilgen is no longer needed */
3055                 mb->ilgen = NULL;
3056         }
3057
3058         return mb->mhandle;
3059 }
3060
3061 static MonoMethod*
3062 methodbuilder_to_mono_method (MonoClass *klass, MonoReflectionMethodBuilderHandle ref_mb, MonoError *error)
3063 {
3064         ReflectionMethodBuilder rmb;
3065         MonoMethodSignature *sig;
3066
3067         error_init (error);
3068
3069         mono_loader_lock ();
3070
3071         MonoReflectionMethodBuilder *mb = MONO_HANDLE_RAW (ref_mb); /* FIXME use handles */
3072         if (!mono_reflection_methodbuilder_from_method_builder (&rmb, mb, error))
3073                 return NULL;
3074
3075         g_assert (klass->image != NULL);
3076         sig = method_builder_to_signature (klass->image, ref_mb, error);
3077         mono_loader_unlock ();
3078         return_val_if_nok (error, NULL);
3079
3080         MonoMethod *method = reflection_methodbuilder_to_mono_method (klass, &rmb, sig, error);
3081         return_val_if_nok (error, NULL);
3082         MONO_HANDLE_SETVAL (ref_mb, mhandle, MonoMethod*, method);
3083         mono_save_custom_attrs (klass->image, method, mb->cattrs);
3084
3085         if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save)
3086                 /* ilgen is no longer needed */
3087                 mb->ilgen = NULL;
3088         return method;
3089 }
3090
3091 static MonoMethod*
3092 methodbuilder_to_mono_method_raw (MonoClass *klass, MonoReflectionMethodBuilder* mb_raw, MonoError *error)
3093 {
3094         HANDLE_FUNCTION_ENTER (); /* FIXME change callers of methodbuilder_to_mono_method_raw to use handles */
3095         error_init (error);
3096         MONO_HANDLE_DCL (MonoReflectionMethodBuilder, mb);
3097         MonoMethod *result = methodbuilder_to_mono_method (klass, mb, error);
3098         HANDLE_FUNCTION_RETURN_VAL (result);
3099 }
3100
3101 #endif
3102
3103 #ifndef DISABLE_REFLECTION_EMIT
3104
3105 /**
3106  * fix_partial_generic_class:
3107  * @klass: a generic instantiation MonoClass
3108  * @error: set on error
3109  *
3110  * Assumes that the generic container of @klass has its vtable
3111  * initialized, and updates the parent class, interfaces, methods and
3112  * fields of @klass by inflating the types using the generic context.
3113  *
3114  * On success returns TRUE, on failure returns FALSE and sets @error.
3115  *
3116  */
3117 static gboolean
3118 fix_partial_generic_class (MonoClass *klass, MonoError *error)
3119 {
3120         MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
3121         int i;
3122
3123         error_init (error);
3124
3125         if (klass->wastypebuilder)
3126                 return TRUE;
3127
3128         if (klass->parent != gklass->parent) {
3129                 MonoType *parent_type = mono_class_inflate_generic_type_checked (&gklass->parent->byval_arg, &mono_class_get_generic_class (klass)->context, error);
3130                 if (mono_error_ok (error)) {
3131                         MonoClass *parent = mono_class_from_mono_type (parent_type);
3132                         mono_metadata_free_type (parent_type);
3133                         if (parent != klass->parent) {
3134                                 /*fool mono_class_setup_parent*/
3135                                 klass->supertypes = NULL;
3136                                 mono_class_setup_parent (klass, parent);
3137                         }
3138                 } else {
3139                         if (gklass->wastypebuilder)
3140                                 klass->wastypebuilder = TRUE;
3141                         return FALSE;
3142                 }
3143         }
3144
3145         if (!mono_class_get_generic_class (klass)->need_sync)
3146                 return TRUE;
3147
3148         int mcount = mono_class_get_method_count (klass);
3149         int gmcount = mono_class_get_method_count (gklass);
3150         if (mcount != gmcount) {
3151                 mono_class_set_method_count (klass, gmcount);
3152                 klass->methods = (MonoMethod **)mono_image_alloc (klass->image, sizeof (MonoMethod*) * (gmcount + 1));
3153
3154                 for (i = 0; i < gmcount; i++) {
3155                         klass->methods [i] = mono_class_inflate_generic_method_full_checked (
3156                                 gklass->methods [i], klass, mono_class_get_context (klass), error);
3157                         mono_error_assert_ok (error);
3158                 }
3159         }
3160
3161         if (klass->interface_count && klass->interface_count != gklass->interface_count) {
3162                 klass->interface_count = gklass->interface_count;
3163                 klass->interfaces = (MonoClass **)mono_image_alloc (klass->image, sizeof (MonoClass*) * gklass->interface_count);
3164                 klass->interfaces_packed = NULL; /*make setup_interface_offsets happy*/
3165
3166                 for (i = 0; i < gklass->interface_count; ++i) {
3167                         MonoType *iface_type = mono_class_inflate_generic_type_checked (&gklass->interfaces [i]->byval_arg, mono_class_get_context (klass), error);
3168                         return_val_if_nok (error, FALSE);
3169
3170                         klass->interfaces [i] = mono_class_from_mono_type (iface_type);
3171                         mono_metadata_free_type (iface_type);
3172
3173                         if (!ensure_runtime_vtable (klass->interfaces [i], error))
3174                                 return FALSE;
3175                 }
3176                 klass->interfaces_inited = 1;
3177         }
3178
3179         int fcount = mono_class_get_field_count (klass);
3180         int gfcount = mono_class_get_field_count (gklass);
3181         if (fcount != gfcount) {
3182                 mono_class_set_field_count (klass, gfcount);
3183                 klass->fields = image_g_new0 (klass->image, MonoClassField, gfcount);
3184
3185                 for (i = 0; i < gfcount; i++) {
3186                         klass->fields [i] = gklass->fields [i];
3187                         klass->fields [i].parent = klass;
3188                         klass->fields [i].type = mono_class_inflate_generic_type_checked (gklass->fields [i].type, mono_class_get_context (klass), error);
3189                         return_val_if_nok (error, FALSE);
3190                 }
3191         }
3192
3193         /*We can only finish with this klass once it's parent has as well*/
3194         if (gklass->wastypebuilder)
3195                 klass->wastypebuilder = TRUE;
3196         return TRUE;
3197 }
3198
3199 /**
3200  * ensure_generic_class_runtime_vtable:
3201  * @klass a generic class
3202  * @error set on error
3203  *
3204  * Ensures that the generic container of @klass has a vtable and
3205  * returns TRUE on success.  On error returns FALSE and sets @error.
3206  */
3207 static gboolean
3208 ensure_generic_class_runtime_vtable (MonoClass *klass, MonoError *error)
3209 {
3210         MonoClass *gklass = mono_class_get_generic_class (klass)->container_class;
3211
3212         error_init (error);
3213
3214         if (!ensure_runtime_vtable (gklass, error))
3215                 return FALSE;
3216
3217         return fix_partial_generic_class (klass, error);
3218 }
3219
3220 /**
3221  * ensure_runtime_vtable:
3222  * @klass the class
3223  * @error set on error
3224  *
3225  * Ensures that @klass has a vtable and returns TRUE on success. On
3226  * error returns FALSE and sets @error.
3227  */
3228 static gboolean
3229 ensure_runtime_vtable (MonoClass *klass, MonoError *error)
3230 {
3231         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
3232         int i, num, j;
3233
3234         error_init (error);
3235
3236         if (!image_is_dynamic (klass->image) || (!tb && !mono_class_is_ginst (klass)) || klass->wastypebuilder)
3237                 return TRUE;
3238         if (klass->parent)
3239                 if (!ensure_runtime_vtable (klass->parent, error))
3240                         return FALSE;
3241
3242         if (tb) {
3243                 num = tb->ctors? mono_array_length (tb->ctors): 0;
3244                 num += tb->num_methods;
3245                 mono_class_set_method_count (klass, num);
3246                 klass->methods = (MonoMethod **)mono_image_alloc (klass->image, sizeof (MonoMethod*) * num);
3247                 num = tb->ctors? mono_array_length (tb->ctors): 0;
3248                 for (i = 0; i < num; ++i) {
3249                         MonoMethod *ctor = ctorbuilder_to_mono_method (klass, mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i), error);
3250                         if (!ctor)
3251                                 return FALSE;
3252                         klass->methods [i] = ctor;
3253                 }
3254                 num = tb->num_methods;
3255                 j = i;
3256                 for (i = 0; i < num; ++i) {
3257                         MonoMethod *meth = methodbuilder_to_mono_method_raw (klass, mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i), error); /* FIXME use handles */
3258                         if (!meth)
3259                                 return FALSE;
3260                         klass->methods [j++] = meth;
3261                 }
3262
3263                 if (tb->interfaces) {
3264                         klass->interface_count = mono_array_length (tb->interfaces);
3265                         klass->interfaces = (MonoClass **)mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
3266                         for (i = 0; i < klass->interface_count; ++i) {
3267                                 MonoType *iface = mono_type_array_get_and_resolve_raw (tb->interfaces, i, error); /* FIXME use handles */
3268                                 return_val_if_nok (error, FALSE);
3269                                 klass->interfaces [i] = mono_class_from_mono_type (iface);
3270                                 if (!ensure_runtime_vtable (klass->interfaces [i], error))
3271                                         return FALSE;
3272                         }
3273                         klass->interfaces_inited = 1;
3274                 }
3275         } else if (mono_class_is_ginst (klass)){
3276                 if (!ensure_generic_class_runtime_vtable (klass, error)) {
3277                         mono_class_set_type_load_failure (klass, "Could not initialize vtable for generic class due to: %s", mono_error_get_message (error));
3278                         return FALSE;
3279                 }
3280         }
3281
3282         if (mono_class_is_interface (klass) && !mono_class_is_ginst (klass)) {
3283                 int slot_num = 0;
3284                 int mcount = mono_class_get_method_count (klass);
3285                 for (i = 0; i < mcount; ++i) {
3286                         MonoMethod *im = klass->methods [i];
3287                         if (!(im->flags & METHOD_ATTRIBUTE_STATIC))
3288                                 im->slot = slot_num++;
3289                 }
3290
3291                 klass->interfaces_packed = NULL; /*make setup_interface_offsets happy*/
3292                 mono_class_setup_interface_offsets (klass);
3293                 mono_class_setup_interface_id (klass);
3294         }
3295
3296         /*
3297          * The generic vtable is needed even if image->run is not set since some
3298          * runtime code like ves_icall_Type_GetMethodsByName depends on
3299          * method->slot being defined.
3300          */
3301
3302         /*
3303          * tb->methods could not be freed since it is used for determining
3304          * overrides during dynamic vtable construction.
3305          */
3306
3307         return TRUE;
3308 }
3309
3310 static MonoMethod*
3311 mono_reflection_method_get_handle (MonoObject *method, MonoError *error)
3312 {
3313         error_init (error);
3314         MonoClass *klass = mono_object_class (method);
3315         if (is_sr_mono_method (klass)) {
3316                 MonoReflectionMethod *sr_method = (MonoReflectionMethod*)method;
3317                 return sr_method->method;
3318         }
3319         if (is_sre_method_builder (klass)) {
3320                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)method;
3321                 return mb->mhandle;
3322         }
3323         if (mono_is_sre_method_on_tb_inst (klass)) {
3324                 MonoClass *handle_class;
3325
3326                 MonoMethod *result =  mono_reflection_resolve_object (NULL, method, &handle_class, NULL, error);
3327                 return_val_if_nok (error, NULL);
3328
3329                 return result;
3330         }
3331
3332         g_error ("Can't handle methods of type %s:%s", klass->name_space, klass->name);
3333         return NULL;
3334 }
3335
3336 void
3337 mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error)
3338 {
3339         MonoReflectionTypeBuilder *tb;
3340         int i, j, onum;
3341         MonoReflectionMethod *m;
3342
3343         error_init (error);
3344         *overrides = NULL;
3345         *num_overrides = 0;
3346
3347         g_assert (image_is_dynamic (klass->image));
3348
3349         if (!mono_class_has_ref_info (klass))
3350                 return;
3351
3352         tb = (MonoReflectionTypeBuilder*)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
3353         g_assert (strcmp (mono_object_class (tb)->name, "TypeBuilder") == 0);
3354
3355         onum = 0;
3356         if (tb->methods) {
3357                 for (i = 0; i < tb->num_methods; ++i) {
3358                         MonoReflectionMethodBuilder *mb =
3359                                 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
3360                         if (mb->override_methods)
3361                                 onum += mono_array_length (mb->override_methods);
3362                 }
3363         }
3364
3365         if (onum) {
3366                 *overrides = g_new0 (MonoMethod*, onum * 2);
3367
3368                 onum = 0;
3369                 for (i = 0; i < tb->num_methods; ++i) {
3370                         MonoReflectionMethodBuilder *mb =
3371                                 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
3372                         if (mb->override_methods) {
3373                                 for (j = 0; j < mono_array_length (mb->override_methods); ++j) {
3374                                         m = mono_array_get (mb->override_methods, MonoReflectionMethod*, j);
3375
3376                                         (*overrides) [onum * 2] = mono_reflection_method_get_handle ((MonoObject*)m, error);
3377                                         return_if_nok (error);
3378                                         (*overrides) [onum * 2 + 1] = mb->mhandle;
3379
3380                                         g_assert (mb->mhandle);
3381
3382                                         onum ++;
3383                                 }
3384                         }
3385                 }
3386         }
3387
3388         *num_overrides = onum;
3389 }
3390
3391 /* This initializes the same data as mono_class_setup_fields () */
3392 static void
3393 typebuilder_setup_fields (MonoClass *klass, MonoError *error)
3394 {
3395         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
3396         MonoReflectionFieldBuilder *fb;
3397         MonoClassField *field;
3398         MonoFieldDefaultValue *def_values;
3399         MonoImage *image = klass->image;
3400         const char *p, *p2;
3401         int i, instance_size, packing_size = 0;
3402         guint32 len, idx;
3403
3404         if (klass->parent) {
3405                 if (!klass->parent->size_inited)
3406                         mono_class_init (klass->parent);
3407                 instance_size = klass->parent->instance_size;
3408         } else {
3409                 instance_size = sizeof (MonoObject);
3410         }
3411
3412         int fcount = tb->num_fields;
3413         mono_class_set_field_count (klass, fcount);
3414
3415         error_init (error);
3416
3417         if (tb->class_size) {
3418                 packing_size = tb->packing_size;
3419                 instance_size += tb->class_size;
3420         }
3421
3422         klass->fields = image_g_new0 (image, MonoClassField, fcount);
3423         def_values = image_g_new0 (image, MonoFieldDefaultValue, fcount);
3424         mono_class_set_field_def_values (klass, def_values);
3425         /*
3426         This is, guess what, a hack.
3427         The issue is that the runtime doesn't know how to setup the fields of a typebuider and crash.
3428         On the static path no field class is resolved, only types are built. This is the right thing to do
3429         but we suck.
3430         Setting size_inited is harmless because we're doing the same job as mono_class_setup_fields anyway.
3431         */
3432         klass->size_inited = 1;
3433
3434         for (i = 0; i < fcount; ++i) {
3435                 MonoArray *rva_data;
3436                 fb = (MonoReflectionFieldBuilder *)mono_array_get (tb->fields, gpointer, i);
3437                 field = &klass->fields [i];
3438                 field->parent = klass;
3439                 field->name = string_to_utf8_image_raw (image, fb->name, error); /* FIXME use handles */
3440                 if (!mono_error_ok (error))
3441                         return;
3442                 if (fb->attrs) {
3443                         MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
3444                         return_if_nok (error);
3445                         field->type = mono_metadata_type_dup (klass->image, type);
3446                         field->type->attrs = fb->attrs;
3447                 } else {
3448                         field->type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
3449                         return_if_nok (error);
3450                 }
3451
3452                 if (!klass->enumtype && !mono_type_get_underlying_type (field->type)) {
3453                         mono_class_set_type_load_failure (klass, "Field '%s' is an enum type with a bad underlying type", field->name);
3454                         continue;
3455                 }
3456
3457                 if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && (rva_data = fb->rva_data)) {
3458                         char *base = mono_array_addr (rva_data, char, 0);
3459                         size_t size = mono_array_length (rva_data);
3460                         char *data = (char *)mono_image_alloc (klass->image, size);
3461                         memcpy (data, base, size);
3462                         def_values [i].data = data;
3463                 }
3464                 if (fb->offset != -1)
3465                         field->offset = fb->offset;
3466                 fb->handle = field;
3467                 mono_save_custom_attrs (klass->image, field, fb->cattrs);
3468
3469                 if (fb->def_value) {
3470                         MonoDynamicImage *assembly = (MonoDynamicImage*)klass->image;
3471                         field->type->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
3472                         idx = mono_dynimage_encode_constant (assembly, fb->def_value, &def_values [i].def_type);
3473                         /* Copy the data from the blob since it might get realloc-ed */
3474                         p = assembly->blob.data + idx;
3475                         len = mono_metadata_decode_blob_size (p, &p2);
3476                         len += p2 - p;
3477                         def_values [i].data = (const char *)mono_image_alloc (image, len);
3478                         memcpy ((gpointer)def_values [i].data, p, len);
3479                 }
3480         }
3481
3482         if (!mono_class_has_failure (klass)) {
3483                 mono_class_layout_fields (klass, instance_size, packing_size, TRUE);
3484         }
3485 }
3486
3487 static void
3488 typebuilder_setup_properties (MonoClass *klass, MonoError *error)
3489 {
3490         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
3491         MonoReflectionPropertyBuilder *pb;
3492         MonoImage *image = klass->image;
3493         MonoProperty *properties;
3494         MonoClassPropertyInfo *info;
3495         int i;
3496
3497         error_init (error);
3498
3499         info = mono_class_get_property_info (klass);
3500         if (!info) {
3501                 info = mono_class_alloc0 (klass, sizeof (MonoClassPropertyInfo));
3502                 mono_class_set_property_info (klass, info);
3503         }
3504
3505         info->count = tb->properties ? mono_array_length (tb->properties) : 0;
3506         info->first = 0;
3507
3508         properties = image_g_new0 (image, MonoProperty, info->count);
3509         info->properties = properties;
3510         for (i = 0; i < info->count; ++i) {
3511                 pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
3512                 properties [i].parent = klass;
3513                 properties [i].attrs = pb->attrs;
3514                 properties [i].name = string_to_utf8_image_raw (image, pb->name, error); /* FIXME use handles */
3515                 if (!mono_error_ok (error))
3516                         return;
3517                 if (pb->get_method)
3518                         properties [i].get = pb->get_method->mhandle;
3519                 if (pb->set_method)
3520                         properties [i].set = pb->set_method->mhandle;
3521
3522                 mono_save_custom_attrs (klass->image, &properties [i], pb->cattrs);
3523                 if (pb->def_value) {
3524                         guint32 len, idx;
3525                         const char *p, *p2;
3526                         MonoDynamicImage *assembly = (MonoDynamicImage*)klass->image;
3527                         if (!info->def_values)
3528                                 info->def_values = image_g_new0 (image, MonoFieldDefaultValue, info->count);
3529                         properties [i].attrs |= PROPERTY_ATTRIBUTE_HAS_DEFAULT;
3530                         idx = mono_dynimage_encode_constant (assembly, pb->def_value, &info->def_values [i].def_type);
3531                         /* Copy the data from the blob since it might get realloc-ed */
3532                         p = assembly->blob.data + idx;
3533                         len = mono_metadata_decode_blob_size (p, &p2);
3534                         len += p2 - p;
3535                         info->def_values [i].data = (const char *)mono_image_alloc (image, len);
3536                         memcpy ((gpointer)info->def_values [i].data, p, len);
3537                 }
3538         }
3539 }
3540
3541 static void
3542 typebuilder_setup_events (MonoClass *klass, MonoError *error)
3543 {
3544         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
3545         MonoReflectionEventBuilder *eb;
3546         MonoImage *image = klass->image;
3547         MonoEvent *events;
3548         MonoClassEventInfo *info;
3549         int i;
3550
3551         error_init (error);
3552
3553         info = mono_class_alloc0 (klass, sizeof (MonoClassEventInfo));
3554         mono_class_set_event_info (klass, info);
3555
3556         info->count = tb->events ? mono_array_length (tb->events) : 0;
3557         info->first = 0;
3558
3559         events = image_g_new0 (image, MonoEvent, info->count);
3560         info->events = events;
3561         for (i = 0; i < info->count; ++i) {
3562                 eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
3563                 events [i].parent = klass;
3564                 events [i].attrs = eb->attrs;
3565                 events [i].name = string_to_utf8_image_raw (image, eb->name, error); /* FIXME use handles */
3566                 if (!mono_error_ok (error))
3567                         return;
3568                 if (eb->add_method)
3569                         events [i].add = eb->add_method->mhandle;
3570                 if (eb->remove_method)
3571                         events [i].remove = eb->remove_method->mhandle;
3572                 if (eb->raise_method)
3573                         events [i].raise = eb->raise_method->mhandle;
3574
3575 #ifndef MONO_SMALL_CONFIG
3576                 if (eb->other_methods) {
3577                         int j;
3578                         events [i].other = image_g_new0 (image, MonoMethod*, mono_array_length (eb->other_methods) + 1);
3579                         for (j = 0; j < mono_array_length (eb->other_methods); ++j) {
3580                                 MonoReflectionMethodBuilder *mb =
3581                                         mono_array_get (eb->other_methods,
3582                                                                         MonoReflectionMethodBuilder*, j);
3583                                 events [i].other [j] = mb->mhandle;
3584                         }
3585                 }
3586 #endif
3587                 mono_save_custom_attrs (klass->image, &events [i], eb->cattrs);
3588         }
3589 }
3590
3591 struct remove_instantiations_user_data
3592 {
3593         MonoClass *klass;
3594         MonoError *error;
3595 };
3596
3597 static gboolean
3598 remove_instantiations_of_and_ensure_contents (gpointer key,
3599                                                   gpointer value,
3600                                                   gpointer user_data)
3601 {
3602         struct remove_instantiations_user_data *data = (struct remove_instantiations_user_data*)user_data;
3603         MonoType *type = (MonoType*)key;
3604         MonoClass *klass = data->klass;
3605         gboolean already_failed = !is_ok (data->error);
3606         MonoError lerror;
3607         MonoError *error = already_failed ? &lerror : data->error;
3608
3609         if ((type->type == MONO_TYPE_GENERICINST) && (type->data.generic_class->container_class == klass)) {
3610                 MonoClass *inst_klass = mono_class_from_mono_type (type);
3611                 //Ensure it's safe to use it.
3612                 if (!fix_partial_generic_class (inst_klass, error)) {
3613                         mono_class_set_type_load_failure (inst_klass, "Could not initialized generic type instance due to: %s", mono_error_get_message (error));
3614                         // Marked the class with failure, but since some other instantiation already failed,
3615                         // just report that one, and swallow the error from this one.
3616                         if (already_failed)
3617                                 mono_error_cleanup (error);
3618                 }
3619                 return TRUE;
3620         } else
3621                 return FALSE;
3622 }
3623
3624 /**
3625  * reflection_setup_internal_class:
3626  * @tb: a TypeBuilder object
3627  * @error: set on error
3628  *
3629  * Creates a MonoClass that represents the TypeBuilder.
3630  * This is a trick that lets us simplify a lot of reflection code
3631  * (and will allow us to support Build and Run assemblies easier).
3632  *
3633  * Returns TRUE on success. On failure, returns FALSE and sets @error.
3634  */
3635 static gboolean
3636 reflection_setup_internal_class (MonoReflectionTypeBuilderHandle ref_tb, MonoError *error)
3637 {
3638         MonoReflectionModuleBuilderHandle module_ref = MONO_HANDLE_NEW_GET (MonoReflectionModuleBuilder, ref_tb, module);
3639         GHashTable *unparented_classes = MONO_HANDLE_GETVAL(module_ref, unparented_classes);
3640
3641         if (unparented_classes) {
3642                 return reflection_setup_internal_class_internal (ref_tb, error);
3643         } else {
3644                 // If we're not being called recursively
3645                 unparented_classes = g_hash_table_new (NULL, NULL);
3646                 MONO_HANDLE_SETVAL (module_ref, unparented_classes, GHashTable *, unparented_classes);
3647
3648                 gboolean ret_val = reflection_setup_internal_class_internal (ref_tb, error);
3649                 mono_error_assert_ok (error);
3650
3651                 // Fix the relationship between the created classes and their parents
3652                 reflection_setup_class_hierarchy (unparented_classes, error);
3653                 mono_error_assert_ok (error);
3654
3655                 g_hash_table_destroy (unparented_classes);
3656                 MONO_HANDLE_SETVAL (module_ref, unparented_classes, GHashTable *, NULL);
3657
3658                 return ret_val;
3659         }
3660 }
3661
3662
3663 MonoReflectionTypeHandle
3664 ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilderHandle ref_tb, MonoError *error)
3665 {
3666         error_init (error);
3667
3668         reflection_setup_internal_class (ref_tb, error);
3669         mono_error_assert_ok (error);
3670
3671         MonoDomain *domain = MONO_HANDLE_DOMAIN (ref_tb);
3672         MonoType *type = MONO_HANDLE_GETVAL (MONO_HANDLE_CAST (MonoReflectionType, ref_tb), type);
3673         MonoClass *klass = mono_class_from_mono_type (type);
3674
3675         MonoArrayHandle cattrs = MONO_HANDLE_NEW_GET (MonoArray, ref_tb, cattrs);
3676         mono_save_custom_attrs (klass->image, klass, MONO_HANDLE_RAW (cattrs)); /* FIXME use handles */
3677
3678         /*
3679          * we need to lock the domain because the lock will be taken inside
3680          * So, we need to keep the locking order correct.
3681          */
3682         mono_loader_lock ();
3683         mono_domain_lock (domain);
3684         if (klass->wastypebuilder) {
3685                 mono_domain_unlock (domain);
3686                 mono_loader_unlock ();
3687
3688                 return mono_type_get_object_handle (domain, &klass->byval_arg, error);
3689         }
3690         /*
3691          * Fields to set in klass:
3692          * the various flags: delegate/unicode/contextbound etc.
3693          */
3694         mono_class_set_flags (klass, MONO_HANDLE_GETVAL (ref_tb, attrs));
3695         klass->has_cctor = 1;
3696
3697         mono_class_setup_parent (klass, klass->parent);
3698         /* fool mono_class_setup_supertypes */
3699         klass->supertypes = NULL;
3700         mono_class_setup_supertypes (klass);
3701         mono_class_setup_mono_type (klass);
3702
3703         /* enums are done right away */
3704         if (!klass->enumtype)
3705                 if (!ensure_runtime_vtable (klass, error))
3706                         goto failure;
3707
3708         MonoArrayHandle nested_types = MONO_HANDLE_NEW_GET (MonoArray, ref_tb, subtypes);
3709         if (!MONO_HANDLE_IS_NULL (nested_types)) {
3710                 GList *nested = NULL;
3711                 int num_nested = mono_array_handle_length (nested_types);
3712                 MonoReflectionTypeHandle nested_tb = MONO_HANDLE_NEW (MonoReflectionType, NULL);
3713                 for (int i = 0; i < num_nested; ++i) {
3714                         MONO_HANDLE_ARRAY_GETREF (nested_tb, nested_types, i);
3715
3716                         if (MONO_HANDLE_GETVAL (nested_tb, type) == NULL) {
3717                                 reflection_setup_internal_class (MONO_HANDLE_CAST (MonoReflectionTypeBuilder, nested_tb), error);
3718                                 mono_error_assert_ok (error);
3719                         }
3720
3721                         MonoType *subtype = mono_reflection_type_handle_mono_type (nested_tb, error);
3722                         if (!is_ok (error)) goto failure;
3723                         nested = g_list_prepend_image (klass->image, nested, mono_class_from_mono_type (subtype));
3724                 }
3725                 mono_class_set_nested_classes_property (klass, nested);
3726         }
3727
3728         klass->nested_classes_inited = TRUE;
3729
3730         typebuilder_setup_fields (klass, error);
3731         if (!is_ok (error))
3732                 goto failure;
3733         typebuilder_setup_properties (klass, error);
3734         if (!is_ok (error))
3735                 goto failure;
3736
3737         typebuilder_setup_events (klass, error);
3738         if (!is_ok (error))
3739                 goto failure;
3740
3741         klass->wastypebuilder = TRUE;
3742
3743         MonoArrayHandle generic_params = MONO_HANDLE_NEW_GET (MonoArray, ref_tb, generic_params);
3744         if (!MONO_HANDLE_IS_NULL (generic_params)) {
3745                 int num_params = mono_array_handle_length (generic_params);
3746                 MonoReflectionTypeHandle ref_gparam = MONO_HANDLE_NEW (MonoReflectionType, NULL);
3747                 for (int i = 0; i < num_params; i++) {
3748                         MONO_HANDLE_ARRAY_GETREF (ref_gparam, generic_params, i);
3749                         MonoType *param_type = mono_reflection_type_handle_mono_type (ref_gparam, error);
3750                         if (!is_ok (error))
3751                                 goto failure;
3752                         MonoClass *gklass = mono_class_from_mono_type (param_type);
3753
3754                         gklass->wastypebuilder = TRUE;
3755                 }
3756         }
3757
3758         /*
3759          * If we are a generic TypeBuilder, there might be instantiations in the type cache
3760          * which have type System.Reflection.MonoGenericClass, but after the type is created,
3761          * we want to return normal System.MonoType objects, so clear these out from the cache.
3762          *
3763          * Together with this we must ensure the contents of all instances to match the created type.
3764          */
3765         if (domain->type_hash && mono_class_is_gtd (klass)) {
3766                 struct remove_instantiations_user_data data;
3767                 data.klass = klass;
3768                 data.error = error;
3769                 mono_error_assert_ok (error);
3770                 mono_g_hash_table_foreach_remove (domain->type_hash, remove_instantiations_of_and_ensure_contents, &data);
3771                 if (!is_ok (error))
3772                         goto failure;
3773         }
3774
3775         mono_domain_unlock (domain);
3776         mono_loader_unlock ();
3777
3778         if (klass->enumtype && !mono_class_is_valid_enum (klass)) {
3779                 mono_class_set_type_load_failure (klass, "Not a valid enumeration");
3780                 mono_error_set_type_load_class (error, klass, "Not a valid enumeration");
3781                 goto failure_unlocked;
3782         }
3783
3784         MonoReflectionTypeHandle res = mono_type_get_object_handle (domain, &klass->byval_arg, error);
3785         if (!is_ok (error))
3786                 goto failure_unlocked;
3787
3788         return res;
3789
3790 failure:
3791         mono_class_set_type_load_failure (klass, "TypeBuilder could not create runtime class due to: %s", mono_error_get_message (error));
3792         klass->wastypebuilder = TRUE;
3793         mono_domain_unlock (domain);
3794         mono_loader_unlock ();
3795 failure_unlocked:
3796         return NULL;
3797 }
3798
3799 typedef struct {
3800         MonoMethod *handle;
3801         MonoDomain *domain;
3802 } DynamicMethodReleaseData;
3803
3804 /*
3805  * The runtime automatically clean up those after finalization.
3806 */
3807 static MonoReferenceQueue *dynamic_method_queue;
3808
3809 static void
3810 free_dynamic_method (void *dynamic_method)
3811 {
3812         DynamicMethodReleaseData *data = (DynamicMethodReleaseData *)dynamic_method;
3813         MonoDomain *domain = data->domain;
3814         MonoMethod *method = data->handle;
3815         guint32 dis_link;
3816
3817         mono_domain_lock (domain);
3818         dis_link = (guint32)(size_t)g_hash_table_lookup (domain->method_to_dyn_method, method);
3819         g_hash_table_remove (domain->method_to_dyn_method, method);
3820         mono_domain_unlock (domain);
3821         g_assert (dis_link);
3822         mono_gchandle_free (dis_link);
3823
3824         mono_runtime_free_method (domain, method);
3825         g_free (data);
3826 }
3827
3828 static gboolean
3829 reflection_create_dynamic_method (MonoReflectionDynamicMethodHandle ref_mb, MonoError *error)
3830 {
3831         MonoReferenceQueue *queue;
3832         MonoMethod *handle;
3833         DynamicMethodReleaseData *release_data;
3834         ReflectionMethodBuilder rmb;
3835         MonoMethodSignature *sig;
3836         MonoClass *klass;
3837         MonoDomain *domain;
3838         GSList *l;
3839         int i;
3840
3841         error_init (error);
3842
3843         if (mono_runtime_is_shutting_down ()) {
3844                 mono_error_set_generic_error (error, "System", "InvalidOperationException", "");
3845                 return FALSE;
3846         }
3847
3848         if (!(queue = dynamic_method_queue)) {
3849                 mono_loader_lock ();
3850                 if (!(queue = dynamic_method_queue))
3851                         queue = dynamic_method_queue = mono_gc_reference_queue_new (free_dynamic_method);
3852                 mono_loader_unlock ();
3853         }
3854
3855         sig = dynamic_method_to_signature (ref_mb, error);
3856         return_val_if_nok (error, FALSE);
3857
3858         MonoReflectionDynamicMethod *mb = MONO_HANDLE_RAW (ref_mb); /* FIXME convert reflection_create_dynamic_method to use handles */
3859         reflection_methodbuilder_from_dynamic_method (&rmb, mb);
3860
3861         /*
3862          * Resolve references.
3863          */
3864         /*
3865          * Every second entry in the refs array is reserved for storing handle_class,
3866          * which is needed by the ldtoken implementation in the JIT.
3867          */
3868         rmb.nrefs = mb->nrefs;
3869         rmb.refs = g_new0 (gpointer, mb->nrefs + 1);
3870         for (i = 0; i < mb->nrefs; i += 2) {
3871                 MonoClass *handle_class;
3872                 gpointer ref;
3873                 MonoObject *obj = mono_array_get (mb->refs, MonoObject*, i);
3874
3875                 if (strcmp (obj->vtable->klass->name, "DynamicMethod") == 0) {
3876                         MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)obj;
3877                         /*
3878                          * The referenced DynamicMethod should already be created by the managed
3879                          * code, except in the case of circular references. In that case, we store
3880                          * method in the refs array, and fix it up later when the referenced
3881                          * DynamicMethod is created.
3882                          */
3883                         if (method->mhandle) {
3884                                 ref = method->mhandle;
3885                         } else {
3886                                 /* FIXME: GC object stored in unmanaged memory */
3887                                 ref = method;
3888
3889                                 /* FIXME: GC object stored in unmanaged memory */
3890                                 method->referenced_by = g_slist_append (method->referenced_by, mb);
3891                         }
3892                         handle_class = mono_defaults.methodhandle_class;
3893                 } else {
3894                         MonoException *ex = NULL;
3895                         ref = mono_reflection_resolve_object (mb->module->image, obj, &handle_class, NULL, error);
3896                         if (!is_ok  (error)) {
3897                                 g_free (rmb.refs);
3898                                 return FALSE;
3899                         }
3900                         if (!ref)
3901                                 ex = mono_get_exception_type_load (NULL, NULL);
3902                         else if (mono_security_core_clr_enabled ())
3903                                 ex = mono_security_core_clr_ensure_dynamic_method_resolved_object (ref, handle_class);
3904
3905                         if (ex) {
3906                                 g_free (rmb.refs);
3907                                 mono_error_set_exception_instance (error, ex);
3908                                 return FALSE;
3909                         }
3910                 }
3911
3912                 rmb.refs [i] = ref; /* FIXME: GC object stored in unmanaged memory (change also resolve_object() signature) */
3913                 rmb.refs [i + 1] = handle_class;
3914         }
3915
3916         if (mb->owner) {
3917                 MonoType *owner_type = mono_reflection_type_get_handle ((MonoReflectionType*)mb->owner, error);
3918                 if (!is_ok (error)) {
3919                         g_free (rmb.refs);
3920                         return FALSE;
3921                 }
3922                 klass = mono_class_from_mono_type (owner_type);
3923         } else {
3924                 klass = mono_defaults.object_class;
3925         }
3926
3927         mb->mhandle = handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig, error);
3928         g_free (rmb.refs);
3929         return_val_if_nok (error, FALSE);
3930
3931         release_data = g_new (DynamicMethodReleaseData, 1);
3932         release_data->handle = handle;
3933         release_data->domain = mono_object_get_domain ((MonoObject*)mb);
3934         if (!mono_gc_reference_queue_add (queue, (MonoObject*)mb, release_data))
3935                 g_free (release_data);
3936
3937         /* Fix up refs entries pointing at us */
3938         for (l = mb->referenced_by; l; l = l->next) {
3939                 MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)l->data;
3940                 MonoMethodWrapper *wrapper = (MonoMethodWrapper*)method->mhandle;
3941                 gpointer *data;
3942
3943                 g_assert (method->mhandle);
3944
3945                 data = (gpointer*)wrapper->method_data;
3946                 for (i = 0; i < GPOINTER_TO_UINT (data [0]); i += 2) {
3947                         if ((data [i + 1] == mb) && (data [i + 1 + 1] == mono_defaults.methodhandle_class))
3948                                 data [i + 1] = mb->mhandle;
3949                 }
3950         }
3951         g_slist_free (mb->referenced_by);
3952
3953         /* ilgen is no longer needed */
3954         mb->ilgen = NULL;
3955
3956         domain = mono_domain_get ();
3957         mono_domain_lock (domain);
3958         if (!domain->method_to_dyn_method)
3959                 domain->method_to_dyn_method = g_hash_table_new (NULL, NULL);
3960         g_hash_table_insert (domain->method_to_dyn_method, handle, (gpointer)(size_t)mono_gchandle_new_weakref ((MonoObject *)mb, TRUE));
3961         mono_domain_unlock (domain);
3962
3963         return TRUE;
3964 }
3965
3966 void
3967 ves_icall_DynamicMethod_create_dynamic_method (MonoReflectionDynamicMethodHandle mb, MonoError *error)
3968 {
3969         (void) reflection_create_dynamic_method (mb, error);
3970 }
3971
3972 #endif /* DISABLE_REFLECTION_EMIT */
3973
3974 MonoMethodSignature *
3975 mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error)
3976 {
3977         MonoMethodSignature *sig;
3978         g_assert (image_is_dynamic (image));
3979
3980         error_init (error);
3981
3982         sig = (MonoMethodSignature *)g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
3983         if (sig)
3984                 return sig;
3985
3986         return mono_method_signature_checked (method, error);
3987 }
3988
3989 #ifndef DISABLE_REFLECTION_EMIT
3990
3991 /*
3992  * ensure_complete_type:
3993  *
3994  *   Ensure that KLASS is completed if it is a dynamic type, or references
3995  * dynamic types.
3996  */
3997 static void
3998 ensure_complete_type (MonoClass *klass, MonoError *error)
3999 {
4000         error_init (error);
4001
4002         if (image_is_dynamic (klass->image) && !klass->wastypebuilder && mono_class_has_ref_info (klass)) {
4003                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info_raw (klass); /* FIXME use handles */
4004
4005                 mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error);
4006                 return_if_nok (error);
4007
4008                 // Asserting here could break a lot of code
4009                 //g_assert (klass->wastypebuilder);
4010         }
4011
4012         if (mono_class_is_ginst (klass)) {
4013                 MonoGenericInst *inst = mono_class_get_generic_class (klass)->context.class_inst;
4014                 int i;
4015
4016                 for (i = 0; i < inst->type_argc; ++i) {
4017                         ensure_complete_type (mono_class_from_mono_type (inst->type_argv [i]), error);
4018                         return_if_nok (error);
4019                 }
4020         }
4021 }
4022
4023 gpointer
4024 mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context, MonoError *error)
4025 {
4026         MonoClass *oklass = obj->vtable->klass;
4027         gpointer result = NULL;
4028
4029         error_init (error);
4030
4031         if (strcmp (oklass->name, "String") == 0) {
4032                 result = mono_string_intern_checked ((MonoString*)obj, error);
4033                 return_val_if_nok (error, NULL);
4034                 *handle_class = mono_defaults.string_class;
4035                 g_assert (result);
4036         } else if (strcmp (oklass->name, "RuntimeType") == 0) {
4037                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error);
4038                 return_val_if_nok (error, NULL);
4039                 MonoClass *mc = mono_class_from_mono_type (type);
4040                 if (!mono_class_init (mc)) {
4041                         mono_error_set_for_class_failure (error, mc);
4042                         return NULL;
4043                 }
4044
4045                 if (context) {
4046                         MonoType *inflated = mono_class_inflate_generic_type_checked (type, context, error);
4047                         return_val_if_nok (error, NULL);
4048
4049                         result = mono_class_from_mono_type (inflated);
4050                         mono_metadata_free_type (inflated);
4051                 } else {
4052                         result = mono_class_from_mono_type (type);
4053                 }
4054                 *handle_class = mono_defaults.typehandle_class;
4055                 g_assert (result);
4056         } else if (strcmp (oklass->name, "MonoMethod") == 0 ||
4057                            strcmp (oklass->name, "MonoCMethod") == 0) {
4058                 result = ((MonoReflectionMethod*)obj)->method;
4059                 if (context) {
4060                         result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error);
4061                         mono_error_assert_ok (error);
4062                 }
4063                 *handle_class = mono_defaults.methodhandle_class;
4064                 g_assert (result);
4065         } else if (strcmp (oklass->name, "MonoField") == 0) {
4066                 MonoClassField *field = ((MonoReflectionField*)obj)->field;
4067
4068                 ensure_complete_type (field->parent, error);
4069                 return_val_if_nok (error, NULL);
4070
4071                 if (context) {
4072                         MonoType *inflated = mono_class_inflate_generic_type_checked (&field->parent->byval_arg, context, error);
4073                         return_val_if_nok (error, NULL);
4074
4075                         MonoClass *klass = mono_class_from_mono_type (inflated);
4076                         MonoClassField *inflated_field;
4077                         gpointer iter = NULL;
4078                         mono_metadata_free_type (inflated);
4079                         while ((inflated_field = mono_class_get_fields (klass, &iter))) {
4080                                 if (!strcmp (field->name, inflated_field->name))
4081                                         break;
4082                         }
4083                         g_assert (inflated_field && !strcmp (field->name, inflated_field->name));
4084                         result = inflated_field;
4085                 } else {
4086                         result = field;
4087                 }
4088                 *handle_class = mono_defaults.fieldhandle_class;
4089                 g_assert (result);
4090         } else if (strcmp (oklass->name, "TypeBuilder") == 0) {
4091                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)obj;
4092                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error);
4093                 return_val_if_nok (error, NULL);
4094                 MonoClass *klass;
4095
4096                 klass = type->data.klass;
4097                 if (klass->wastypebuilder) {
4098                         /* Already created */
4099                         result = klass;
4100                 }
4101                 else {
4102                         mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error);
4103                         return_val_if_nok (error, NULL);
4104                         result = type->data.klass;
4105                         g_assert (result);
4106                 }
4107                 *handle_class = mono_defaults.typehandle_class;
4108         } else if (strcmp (oklass->name, "SignatureHelper") == 0) {
4109                 MonoReflectionSigHelper *helper = (MonoReflectionSigHelper*)obj;
4110                 MonoMethodSignature *sig;
4111                 int nargs, i;
4112
4113                 if (helper->arguments)
4114                         nargs = mono_array_length (helper->arguments);
4115                 else
4116                         nargs = 0;
4117
4118                 sig = mono_metadata_signature_alloc (image, nargs);
4119                 sig->explicit_this = helper->call_conv & 64 ? 1 : 0;
4120                 sig->hasthis = helper->call_conv & 32 ? 1 : 0;
4121
4122                 if (helper->unmanaged_call_conv) { /* unmanaged */
4123                         sig->call_convention = helper->unmanaged_call_conv - 1;
4124                         sig->pinvoke = TRUE;
4125                 } else if (helper->call_conv & 0x02) {
4126                         sig->call_convention = MONO_CALL_VARARG;
4127                 } else {
4128                         sig->call_convention = MONO_CALL_DEFAULT;
4129                 }
4130
4131                 sig->param_count = nargs;
4132                 /* TODO: Copy type ? */
4133                 sig->ret = helper->return_type->type;
4134                 for (i = 0; i < nargs; ++i) {
4135                         sig->params [i] = mono_type_array_get_and_resolve_raw (helper->arguments, i, error); /* FIXME use handles */
4136                         if (!is_ok (error)) {
4137                                 image_g_free (image, sig);
4138                                 return NULL;
4139                         }
4140                 }
4141
4142                 result = sig;
4143                 *handle_class = NULL;
4144         } else if (strcmp (oklass->name, "DynamicMethod") == 0) {
4145                 MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)obj;
4146                 /* Already created by the managed code */
4147                 g_assert (method->mhandle);
4148                 result = method->mhandle;
4149                 *handle_class = mono_defaults.methodhandle_class;
4150         } else if (strcmp (oklass->name, "MonoArrayMethod") == 0) {
4151                 MonoReflectionArrayMethod *m = (MonoReflectionArrayMethod*)obj;
4152                 MonoType *mtype;
4153                 MonoClass *klass;
4154                 MonoMethod *method;
4155                 gpointer iter;
4156                 char *name;
4157
4158                 mtype = mono_reflection_type_get_handle (m->parent, error);
4159                 return_val_if_nok (error, NULL);
4160                 klass = mono_class_from_mono_type (mtype);
4161
4162                 /* Find the method */
4163
4164                 name = mono_string_to_utf8_checked (m->name, error);
4165                 return_val_if_nok (error, NULL);
4166                 iter = NULL;
4167                 while ((method = mono_class_get_methods (klass, &iter))) {
4168                         if (!strcmp (method->name, name))
4169                                 break;
4170                 }
4171                 g_free (name);
4172
4173                 // FIXME:
4174                 g_assert (method);
4175                 // FIXME: Check parameters/return value etc. match
4176
4177                 result = method;
4178                 *handle_class = mono_defaults.methodhandle_class;
4179         } else if (is_sre_method_builder (oklass) ||
4180                            mono_is_sre_ctor_builder (oklass) ||
4181                            is_sre_field_builder (oklass) ||
4182                            is_sre_gparam_builder (oklass) ||
4183                            is_sre_generic_instance (oklass) ||
4184                            is_sre_array (oklass) ||
4185                            is_sre_byref (oklass) ||
4186                            is_sre_pointer (oklass) ||
4187                            !strcmp (oklass->name, "FieldOnTypeBuilderInst") ||
4188                            !strcmp (oklass->name, "MethodOnTypeBuilderInst") ||
4189                            !strcmp (oklass->name, "ConstructorOnTypeBuilderInst")) {
4190                 static MonoMethod *resolve_method;
4191                 if (!resolve_method) {
4192                         MonoMethod *m = mono_class_get_method_from_name_flags (mono_class_get_module_builder_class (), "RuntimeResolve", 1, 0);
4193                         g_assert (m);
4194                         mono_memory_barrier ();
4195                         resolve_method = m;
4196                 }
4197                 void *args [16];
4198                 args [0] = obj;
4199                 obj = mono_runtime_invoke_checked (resolve_method, NULL, args, error);
4200                 mono_error_assert_ok (error);
4201                 g_assert (obj);
4202                 return mono_reflection_resolve_object (image, obj, handle_class, context, error);
4203         } else {
4204                 g_print ("%s\n", obj->vtable->klass->name);
4205                 g_assert_not_reached ();
4206         }
4207         return result;
4208 }
4209
4210 #else /* DISABLE_REFLECTION_EMIT */
4211
4212 MonoArray*
4213 mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
4214 {
4215         g_assert_not_reached ();
4216         return NULL;
4217 }
4218
4219 void
4220 mono_reflection_dynimage_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
4221 {
4222         g_error ("This mono runtime was configured with --enable-minimal=reflection_emit, so System.Reflection.Emit is not supported.");
4223 }
4224
4225 static gboolean
4226 mono_image_module_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error)
4227 {
4228         g_assert_not_reached ();
4229         return FALSE;
4230 }
4231
4232 guint32
4233 mono_image_insert_string (MonoReflectionModuleBuilderHandle module, MonoStringHandle str, MonoError *error)
4234 {
4235         g_assert_not_reached ();
4236         return 0;
4237 }
4238
4239 guint32
4240 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObjectHandle obj, MonoArrayHandle opt_param_types, MonoError *error)
4241 {
4242         g_assert_not_reached ();
4243         return 0;
4244 }
4245
4246 guint32
4247 mono_image_create_token (MonoDynamicImage *assembly, MonoObjectHandle obj,
4248                          gboolean create_open_instance, gboolean register_token, MonoError *error)
4249 {
4250         g_assert_not_reached ();
4251         return 0;
4252 }
4253
4254 void
4255 mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error)
4256 {
4257         error_init (error);
4258         *overrides = NULL;
4259         *num_overrides = 0;
4260 }
4261
4262 MonoReflectionTypeHandle
4263 ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilderHandle tb, MonoError *error)
4264 {
4265         g_assert_not_reached ();
4266         return NULL;
4267 }
4268
4269 void
4270 ves_icall_DynamicMethod_create_dynamic_method (MonoReflectionDynamicMethodHandle mb, MonoError *error)
4271 {
4272         error_init (error);
4273 }
4274
4275 MonoType*
4276 mono_reflection_type_get_handle (MonoReflectionType* ref, MonoError *error)
4277 {
4278         error_init (error);
4279         if (!ref)
4280                 return NULL;
4281         return ref->type;
4282 }
4283
4284 MonoType*
4285 mono_reflection_type_handle_mono_type (MonoReflectionTypeHandle ref, MonoError *error)
4286 {
4287         error_init (error);
4288         if (MONO_HANDLE_IS_NULL (ref))
4289                 return NULL;
4290         return MONO_HANDLE_GETVAL (ref, type);
4291 }
4292
4293
4294 #endif /* DISABLE_REFLECTION_EMIT */
4295
4296 void
4297 mono_sre_generic_param_table_entry_free (GenericParamTableEntry *entry)
4298 {
4299         MONO_GC_UNREGISTER_ROOT_IF_MOVING (entry->gparam);
4300         g_free (entry);
4301 }
4302
4303 gint32
4304 ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilderHandle mb, MonoObjectHandle obj, gboolean create_open_instance, MonoError *error)
4305 {
4306         error_init (error);
4307         if (MONO_HANDLE_IS_NULL (obj)) {
4308                 mono_error_set_argument_null (error, "obj", "");
4309                 return 0;
4310         }
4311         return mono_image_create_token (MONO_HANDLE_GETVAL (mb, dynamic_image), obj, create_open_instance, TRUE, error);
4312 }
4313
4314 gint32
4315 ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilderHandle mb,
4316                                         MonoReflectionMethodHandle method,
4317                                         MonoArrayHandle opt_param_types,
4318                                         MonoError *error)
4319 {
4320         error_init (error);
4321         if (MONO_HANDLE_IS_NULL (method)) {
4322                 mono_error_set_argument_null (error, "method", "");
4323                 return 0;
4324         }
4325
4326         return mono_image_create_method_token (MONO_HANDLE_GETVAL (mb, dynamic_image), MONO_HANDLE_CAST (MonoObject, method), opt_param_types, error);
4327 }
4328
4329 void
4330 ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder *mb, HANDLE file)
4331 {
4332         MonoError error;
4333         mono_image_create_pefile (mb, file, &error);
4334         mono_error_set_pending_exception (&error);
4335 }
4336
4337 void
4338 ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder *mb)
4339 {
4340         MonoError error;
4341         mono_image_build_metadata (mb, &error);
4342         mono_error_set_pending_exception (&error);
4343 }
4344
4345 void
4346 ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilderHandle mb, MonoObjectHandle obj, guint32 token, MonoError *error)
4347 {
4348         error_init (error);
4349         /* This function may be called by ModuleBuilder.FixupTokens to update
4350          * an existing token, so replace is okay here. */
4351         mono_dynamic_image_register_token (MONO_HANDLE_GETVAL (mb, dynamic_image), token, obj, MONO_DYN_IMAGE_TOK_REPLACE);
4352 }
4353
4354 MonoObjectHandle
4355 ves_icall_ModuleBuilder_GetRegisteredToken (MonoReflectionModuleBuilderHandle mb, guint32 token, MonoError *error)
4356 {
4357         error_init (error);
4358         MonoDynamicImage *dynamic_image = MONO_HANDLE_GETVAL (mb, dynamic_image);
4359         return mono_dynamic_image_get_registered_token (dynamic_image, token, error);
4360 }
4361
4362 #ifndef DISABLE_REFLECTION_EMIT
4363 MonoArray*
4364 ves_icall_CustomAttributeBuilder_GetBlob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
4365 {
4366         MonoError error;
4367         MonoArray *result = mono_reflection_get_custom_attrs_blob_checked (assembly, ctor, ctorArgs, properties, propValues, fields, fieldValues, &error);
4368         mono_error_set_pending_exception (&error);
4369         return result;
4370 }
4371 #endif
4372
4373 void
4374 ves_icall_AssemblyBuilder_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
4375 {
4376         mono_reflection_dynimage_basic_init (assemblyb);
4377 }
4378
4379 void
4380 ves_icall_EnumBuilder_setup_enum_type (MonoReflectionTypeHandle enumtype,
4381                                        MonoReflectionTypeHandle t,
4382                                        MonoError *error)
4383 {
4384         error_init (error);
4385         MONO_HANDLE_SETVAL (enumtype, type, MonoType*, MONO_HANDLE_GETVAL (t, type));
4386 }
4387
4388 void
4389 ves_icall_ModuleBuilder_basic_init (MonoReflectionModuleBuilderHandle moduleb, MonoError *error)
4390 {
4391         error_init (error);
4392         mono_image_module_basic_init (moduleb, error);
4393 }
4394
4395 guint32
4396 ves_icall_ModuleBuilder_getUSIndex (MonoReflectionModuleBuilderHandle module, MonoStringHandle str, MonoError *error)
4397 {
4398         return mono_image_insert_string (module, str, error);
4399 }
4400
4401 void
4402 ves_icall_ModuleBuilder_set_wrappers_type (MonoReflectionModuleBuilderHandle moduleb, MonoReflectionTypeHandle ref_type, MonoError *error)
4403 {
4404         error_init (error);
4405         MonoDynamicImage *image = MONO_HANDLE_GETVAL (moduleb, dynamic_image);
4406         MonoType *type = MONO_HANDLE_GETVAL (ref_type, type);
4407
4408         g_assert (type);
4409         image->wrappers_type = mono_class_from_mono_type (type);
4410 }