mono/metadata/reflection.c

   1 /*
   2  * reflection.c: Routines for creating an image at runtime.
   3  *
   4  * Author:
   5  *   Paolo Molaro (lupus@ximian.com)
   6  *
   7  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   8  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
   9  * Copyright 2011 Rodrigo Kumpera
  10  *
  11  */
  12 #include <config.h>
  13 #include "mono/utils/mono-digest.h"
  14 #include "mono/utils/mono-membar.h"
  15 #include "mono/metadata/reflection-internals.h"
  16 #include "mono/metadata/tabledefs.h"
  17 #include "mono/metadata/metadata-internals.h"
  18 #include <mono/metadata/profiler-private.h>
  19 #include "mono/metadata/class-internals.h"
  20 #include "mono/metadata/gc-internals.h"
  21 #include "mono/metadata/tokentype.h"
  22 #include "mono/metadata/domain-internals.h"
  23 #include "mono/metadata/opcodes.h"
  24 #include "mono/metadata/assembly.h"
  25 #include "mono/metadata/object-internals.h"
  26 #include <mono/metadata/exception.h>
  27 #include <mono/metadata/marshal.h>
  28 #include <mono/metadata/security-manager.h>
  29 #include <stdio.h>
  30 #include <glib.h>
  31 #include <errno.h>
  32 #include <time.h>
  33 #include <string.h>
  34 #include <ctype.h>
  35 #include "image.h"
  36 #include "cil-coff.h"
  37 #include "mono-endian.h"
  38 #include <mono/metadata/gc-internals.h>
  39 #include <mono/metadata/mempool-internals.h>
  40 #include <mono/metadata/security-core-clr.h>
  41 #include <mono/metadata/debug-helpers.h>
  42 #include <mono/metadata/verify-internals.h>
  43 #include <mono/metadata/mono-ptr-array.h>
  44 #include <mono/utils/mono-string.h>
  45 #include <mono/utils/mono-error-internals.h>
  46 #include <mono/utils/checked-build.h>
  47
  48 static gboolean is_usertype (MonoReflectionType *ref);
  49 static MonoReflectionType *mono_reflection_type_resolve_user_types (MonoReflectionType *type, MonoError *error);
  50
  51 typedef struct {
  52         char *p;
  53         char *buf;
  54         char *end;
  55 } SigBuffer;
  56
  57 #define TEXT_OFFSET 512
  58 #define CLI_H_SIZE 136
  59 #define FILE_ALIGN 512
  60 #define VIRT_ALIGN 8192
  61 #define START_TEXT_RVA  0x00002000
  62
  63 typedef struct {
  64         MonoReflectionILGen *ilgen;
  65         MonoReflectionType *rtype;
  66         MonoArray *parameters;
  67         MonoArray *generic_params;
  68         MonoGenericContainer *generic_container;
  69         MonoArray *pinfo;
  70         MonoArray *opt_types;
  71         guint32 attrs;
  72         guint32 iattrs;
  73         guint32 call_conv;
  74         guint32 *table_idx; /* note: it's a pointer */
  75         MonoArray *code;
  76         MonoObject *type;
  77         MonoString *name;
  78         MonoBoolean init_locals;
  79         MonoBoolean skip_visibility;
  80         MonoArray *return_modreq;
  81         MonoArray *return_modopt;
  82         MonoArray *param_modreq;
  83         MonoArray *param_modopt;
  84         MonoArray *permissions;
  85         MonoMethod *mhandle;
  86         guint32 nrefs;
  87         gpointer *refs;
  88         /* for PInvoke */
  89         int charset, extra_flags, native_cc;
  90         MonoString *dll, *dllentry;
  91 } ReflectionMethodBuilder;
  92
  93 typedef struct {
  94         guint32 owner;
  95         MonoReflectionGenericParam *gparam;
  96 } GenericParamTableEntry;
  97
  98 const unsigned char table_sizes [MONO_TABLE_NUM] = {
  99         MONO_MODULE_SIZE,
 100         MONO_TYPEREF_SIZE,
 101         MONO_TYPEDEF_SIZE,
 102         0,
 103         MONO_FIELD_SIZE,
 104         0,
 105         MONO_METHOD_SIZE,
 106         0,
 107         MONO_PARAM_SIZE,
 108         MONO_INTERFACEIMPL_SIZE,
 109         MONO_MEMBERREF_SIZE,    /* 0x0A */
 110         MONO_CONSTANT_SIZE,
 111         MONO_CUSTOM_ATTR_SIZE,
 112         MONO_FIELD_MARSHAL_SIZE,
 113         MONO_DECL_SECURITY_SIZE,
 114         MONO_CLASS_LAYOUT_SIZE,
 115         MONO_FIELD_LAYOUT_SIZE, /* 0x10 */
 116         MONO_STAND_ALONE_SIGNATURE_SIZE,
 117         MONO_EVENT_MAP_SIZE,
 118         0,
 119         MONO_EVENT_SIZE,
 120         MONO_PROPERTY_MAP_SIZE,
 121         0,
 122         MONO_PROPERTY_SIZE,
 123         MONO_METHOD_SEMA_SIZE,
 124         MONO_METHODIMPL_SIZE,
 125         MONO_MODULEREF_SIZE,    /* 0x1A */
 126         MONO_TYPESPEC_SIZE,
 127         MONO_IMPLMAP_SIZE,
 128         MONO_FIELD_RVA_SIZE,
 129         0,
 130         0,
 131         MONO_ASSEMBLY_SIZE,     /* 0x20 */
 132         MONO_ASSEMBLY_PROCESSOR_SIZE,
 133         MONO_ASSEMBLYOS_SIZE,
 134         MONO_ASSEMBLYREF_SIZE,
 135         MONO_ASSEMBLYREFPROC_SIZE,
 136         MONO_ASSEMBLYREFOS_SIZE,
 137         MONO_FILE_SIZE,
 138         MONO_EXP_TYPE_SIZE,
 139         MONO_MANIFEST_SIZE,
 140         MONO_NESTED_CLASS_SIZE,
 141
 142         MONO_GENERICPARAM_SIZE, /* 0x2A */
 143         MONO_METHODSPEC_SIZE,
 144         MONO_GENPARCONSTRAINT_SIZE
 145
 146 };
 147
 148 #ifndef DISABLE_REFLECTION_EMIT
 149 static guint32 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec);
 150 static guint32 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_open_instance, MonoError *error);
 151 static guint32 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *cb, MonoError *error);
 152 static guint32 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error);
 153 static gboolean ensure_runtime_vtable (MonoClass *klass, MonoError  *error);
 154 static gpointer resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context, MonoError *error);
 155 static guint32 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method, MonoError *error);
 156 static guint32 encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context);
 157 static gpointer register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly);
 158 static gboolean reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb, MonoError *error);
 159 static gboolean reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb, MonoError *error);
 160 static guint32 create_generic_typespec (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb, MonoError *error);
 161 #endif
 162
 163 static guint32 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type);
 164 static guint32 mono_image_typedef_or_ref_full (MonoDynamicImage *assembly, MonoType *type, gboolean try_typespec);
 165 static void    mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly);
 166 static guint32 encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, MonoError *error);
 167 static guint32 encode_constant (MonoDynamicImage *assembly, MonoObject *val, guint32 *ret_type);
 168 static char*   type_get_qualified_name (MonoType *type, MonoAssembly *ass);
 169 static void    encode_type (MonoDynamicImage *assembly, MonoType *type, SigBuffer *buf);
 170 static void get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types);
 171 static MonoReflectionType *mono_reflection_type_get_underlying_system_type (MonoReflectionType* t, MonoError *error);
 172 static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error);
 173 static MonoReflectionType* mono_reflection_type_resolve_user_types (MonoReflectionType *type, MonoError *error);
 174 static gboolean is_sre_array (MonoClass *klass);
 175 static gboolean is_sre_byref (MonoClass *klass);
 176 static gboolean is_sre_pointer (MonoClass *klass);
 177 static gboolean is_sre_type_builder (MonoClass *klass);
 178 static gboolean is_sre_method_builder (MonoClass *klass);
 179 static gboolean is_sre_ctor_builder (MonoClass *klass);
 180 static gboolean is_sre_field_builder (MonoClass *klass);
 181 static gboolean is_sr_mono_method (MonoClass *klass);
 182 static gboolean is_sr_mono_cmethod (MonoClass *klass);
 183 static gboolean is_sr_mono_generic_method (MonoClass *klass);
 184 static gboolean is_sr_mono_generic_cmethod (MonoClass *klass);
 185 static gboolean is_sr_mono_field (MonoClass *klass);
 186 static gboolean is_sr_mono_property (MonoClass *klass);
 187 static gboolean is_sre_method_on_tb_inst (MonoClass *klass);
 188 static gboolean is_sre_ctor_on_tb_inst (MonoClass *klass);
 189
 190 static gboolean type_is_reference (MonoType *type);
 191
 192 static guint32 mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *method);
 193 static guint32 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m);
 194 static MonoMethod * inflate_method (MonoReflectionType *type, MonoObject *obj, MonoError *error);
 195
 196 static guint32 create_typespec (MonoDynamicImage *assembly, MonoType *type);
 197 static void init_type_builder_generics (MonoObject *type);
 198
 199 #define RESOLVE_TYPE(type, error) do {                                  \
 200         type = (MonoObject *)mono_reflection_type_resolve_user_types ((MonoReflectionType*)type, error); \
 201 } while (0)
 202 #define RESOLVE_ARRAY_TYPE_ELEMENT(array, index, error) do {            \
 203         MonoReflectionType *__type = mono_array_get (array, MonoReflectionType*, index); \
 204         __type = mono_reflection_type_resolve_user_types (__type, error); \
 205         if (mono_error_ok (error))                                      \
 206                 mono_array_set (arr, MonoReflectionType*, index, __type); \
 207 } while (0)
 208
 209 #define mono_type_array_get_and_resolve(array, index, error) mono_reflection_type_get_handle ((MonoReflectionType*)mono_array_get (array, gpointer, index), error)
 210
 211 #define CHECK_ADD4_OVERFLOW_UN(a, b) ((guint32)(0xFFFFFFFFU) - (guint32)(b) < (guint32)(a))
 212 #define CHECK_ADD8_OVERFLOW_UN(a, b) ((guint64)(0xFFFFFFFFFFFFFFFFUL) - (guint64)(b) < (guint64)(a))
 213
 214 #if SIZEOF_VOID_P == 4
 215 #define CHECK_ADDP_OVERFLOW_UN(a,b) CHECK_ADD4_OVERFLOW_UN(a, b)
 216 #else
 217 #define CHECK_ADDP_OVERFLOW_UN(a,b) CHECK_ADD8_OVERFLOW_UN(a, b)
 218 #endif
 219
 220 #define ADDP_IS_GREATER_OR_OVF(a, b, c) (((a) + (b) > (c)) || CHECK_ADDP_OVERFLOW_UN (a, b))
 221 #define ADD_IS_GREATER_OR_OVF(a, b, c) (((a) + (b) > (c)) || CHECK_ADD4_OVERFLOW_UN (a, b))
 222
 223 /* Class lazy loading functions */
 224 static GENERATE_GET_CLASS_WITH_CACHE (mono_assembly, System.Reflection, MonoAssembly)
 225 static GENERATE_GET_CLASS_WITH_CACHE (mono_module, System.Reflection, MonoModule)
 226 static GENERATE_GET_CLASS_WITH_CACHE (mono_generic_method, System.Reflection, MonoGenericMethod);
 227 static GENERATE_GET_CLASS_WITH_CACHE (mono_generic_cmethod, System.Reflection, MonoGenericCMethod);
 228 static GENERATE_GET_CLASS_WITH_CACHE (mono_method, System.Reflection, MonoMethod);
 229 static GENERATE_GET_CLASS_WITH_CACHE (mono_cmethod, System.Reflection, MonoCMethod);
 230 static GENERATE_GET_CLASS_WITH_CACHE (mono_field, System.Reflection, MonoField);
 231 static GENERATE_GET_CLASS_WITH_CACHE (mono_event, System.Reflection, MonoEvent);
 232 static GENERATE_GET_CLASS_WITH_CACHE (mono_property, System.Reflection, MonoProperty);
 233 static GENERATE_GET_CLASS_WITH_CACHE (mono_parameter_info, System.Reflection, MonoParameterInfo);
 234 static GENERATE_GET_CLASS_WITH_CACHE (missing, System.Reflection, Missing);
 235 static GENERATE_GET_CLASS_WITH_CACHE (method_body, System.Reflection, MethodBody);
 236 static GENERATE_GET_CLASS_WITH_CACHE (local_variable_info, System.Reflection, LocalVariableInfo);
 237 static GENERATE_GET_CLASS_WITH_CACHE (exception_handling_clause, System.Reflection, ExceptionHandlingClause);
 238 static GENERATE_GET_CLASS_WITH_CACHE (custom_attribute_typed_argument, System.Reflection, CustomAttributeTypedArgument);
 239 static GENERATE_GET_CLASS_WITH_CACHE (custom_attribute_named_argument, System.Reflection, CustomAttributeNamedArgument);
 240 static GENERATE_GET_CLASS_WITH_CACHE (type_builder, System.Reflection.Emit, TypeBuilder);
 241 static GENERATE_GET_CLASS_WITH_CACHE (marshal_as_attribute, System.Runtime.InteropServices, MarshalAsAttribute);
 242 static GENERATE_GET_CLASS_WITH_CACHE (dbnull, System, DBNull);
 243
 244 // The dynamic images list is only needed to support the mempool reference tracking feature in checked-build.
 245 static GPtrArray *dynamic_images;
 246 static mono_mutex_t dynamic_images_mutex;
 247
 248 static inline void
 249 dynamic_images_lock (void)
 250 {
 251         mono_os_mutex_lock (&dynamic_images_mutex);
 252 }
 253
 254 static inline void
 255 dynamic_images_unlock (void)
 256 {
 257         mono_os_mutex_unlock (&dynamic_images_mutex);
 258 }
 259
 260 /**
 261  * mono_find_dynamic_image_owner:
 262  *
 263  * Find the dynamic image, if any, which a given pointer is located in the memory of.
 264  */
 265 MonoImage *
 266 mono_find_dynamic_image_owner (void *ptr)
 267 {
 268         MonoImage *owner = NULL;
 269         int i;
 270
 271         dynamic_images_lock ();
 272
 273         if (dynamic_images)
 274         {
 275                 for (i = 0; !owner && i < dynamic_images->len; ++i) {
 276                         MonoImage *image = (MonoImage *)g_ptr_array_index (dynamic_images, i);
 277                         if (mono_mempool_contains_addr (image->mempool, ptr))
 278                                 owner = image;
 279                 }
 280         }
 281
 282         dynamic_images_unlock ();
 283
 284         return owner;
 285 }
 286
 287 void
 288 mono_reflection_init (void)
 289 {
 290         mono_os_mutex_init (&dynamic_images_mutex);
 291 }
 292
 293 static inline void
 294 dynamic_image_lock (MonoDynamicImage *image)
 295 {
 296         MONO_PREPARE_BLOCKING;
 297         mono_image_lock ((MonoImage*)image);
 298         MONO_FINISH_BLOCKING;
 299 }
 300
 301 static inline void
 302 dynamic_image_unlock (MonoDynamicImage *image)
 303 {
 304         mono_image_unlock ((MonoImage*)image);
 305 }
 306
 307 static void
 308 register_dyn_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj)
 309 {
 310         MONO_REQ_GC_UNSAFE_MODE;
 311
 312         dynamic_image_lock (assembly);
 313         mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), obj);
 314         dynamic_image_unlock (assembly);
 315 }
 316
 317 static MonoObject*
 318 lookup_dyn_token (MonoDynamicImage *assembly, guint32 token)
 319 {
 320         MONO_REQ_GC_UNSAFE_MODE;
 321
 322         MonoObject *obj;
 323
 324         dynamic_image_lock (assembly);
 325         obj = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
 326         dynamic_image_unlock (assembly);
 327
 328         return obj;
 329 }
 330
 331 static void
 332 sigbuffer_init (SigBuffer *buf, int size)
 333 {
 334         MONO_REQ_GC_NEUTRAL_MODE;
 335
 336         buf->buf = (char *)g_malloc (size);
 337         buf->p = buf->buf;
 338         buf->end = buf->buf + size;
 339 }
 340
 341 static void
 342 sigbuffer_make_room (SigBuffer *buf, int size)
 343 {
 344         MONO_REQ_GC_NEUTRAL_MODE;
 345
 346         if (buf->end - buf->p < size) {
 347                 int new_size = buf->end - buf->buf + size + 32;
 348                 char *p = (char *)g_realloc (buf->buf, new_size);
 349                 size = buf->p - buf->buf;
 350                 buf->buf = p;
 351                 buf->p = p + size;
 352                 buf->end = buf->buf + new_size;
 353         }
 354 }
 355
 356 static void
 357 sigbuffer_add_value (SigBuffer *buf, guint32 val)
 358 {
 359         MONO_REQ_GC_NEUTRAL_MODE;
 360
 361         sigbuffer_make_room (buf, 6);
 362         mono_metadata_encode_value (val, buf->p, &buf->p);
 363 }
 364
 365 static void
 366 sigbuffer_add_byte (SigBuffer *buf, guint8 val)
 367 {
 368         MONO_REQ_GC_NEUTRAL_MODE;
 369
 370         sigbuffer_make_room (buf, 1);
 371         buf->p [0] = val;
 372         buf->p++;
 373 }
 374
 375 static void
 376 sigbuffer_add_mem (SigBuffer *buf, char *p, guint32 size)
 377 {
 378         MONO_REQ_GC_NEUTRAL_MODE;
 379
 380         sigbuffer_make_room (buf, size);
 381         memcpy (buf->p, p, size);
 382         buf->p += size;
 383 }
 384
 385 static void
 386 sigbuffer_free (SigBuffer *buf)
 387 {
 388         MONO_REQ_GC_NEUTRAL_MODE;
 389
 390         g_free (buf->buf);
 391 }
 392
 393 #ifndef DISABLE_REFLECTION_EMIT
 394 /**
 395  * mp_g_alloc:
 396  *
 397  * Allocate memory from the @image mempool if it is non-NULL. Otherwise, allocate memory
 398  * from the C heap.
 399  */
 400 static gpointer
 401 image_g_malloc (MonoImage *image, guint size)
 402 {
 403         MONO_REQ_GC_NEUTRAL_MODE;
 404
 405         if (image)
 406                 return mono_image_alloc (image, size);
 407         else
 408                 return g_malloc (size);
 409 }
 410 #endif /* !DISABLE_REFLECTION_EMIT */
 411
 412 /**
 413  * image_g_alloc0:
 414  *
 415  * Allocate memory from the @image mempool if it is non-NULL. Otherwise, allocate memory
 416  * from the C heap.
 417  */
 418 static gpointer
 419 image_g_malloc0 (MonoImage *image, guint size)
 420 {
 421         MONO_REQ_GC_NEUTRAL_MODE;
 422
 423         if (image)
 424                 return mono_image_alloc0 (image, size);
 425         else
 426                 return g_malloc0 (size);
 427 }
 428
 429 /**
 430  * image_g_free:
 431  * @image: a MonoImage
 432  * @ptr: pointer
 433  *
 434  * If @image is NULL, free @ptr, otherwise do nothing.
 435  */
 436 static void
 437 image_g_free (MonoImage *image, gpointer ptr)
 438 {
 439         if (image == NULL)
 440                 g_free (ptr);
 441 }
 442
 443 #ifndef DISABLE_REFLECTION_EMIT
 444 static char*
 445 image_strdup (MonoImage *image, const char *s)
 446 {
 447         MONO_REQ_GC_NEUTRAL_MODE;
 448
 449         if (image)
 450                 return mono_image_strdup (image, s);
 451         else
 452                 return g_strdup (s);
 453 }
 454 #endif
 455
 456 #define image_g_new(image,struct_type, n_structs)               \
 457     ((struct_type *) image_g_malloc (image, ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
 458
 459 #define image_g_new0(image,struct_type, n_structs)              \
 460     ((struct_type *) image_g_malloc0 (image, ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
 461
 462
 463 static void
 464 alloc_table (MonoDynamicTable *table, guint nrows)
 465 {
 466         MONO_REQ_GC_NEUTRAL_MODE;
 467
 468         table->rows = nrows;
 469         g_assert (table->columns);
 470         if (nrows + 1 >= table->alloc_rows) {
 471                 while (nrows + 1 >= table->alloc_rows) {
 472                         if (table->alloc_rows == 0)
 473                                 table->alloc_rows = 16;
 474                         else
 475                                 table->alloc_rows *= 2;
 476                 }
 477
 478                 table->values = (guint32 *)g_renew (guint32, table->values, (table->alloc_rows) * table->columns);
 479         }
 480 }
 481
 482 static void
 483 make_room_in_stream (MonoDynamicStream *stream, int size)
 484 {
 485         MONO_REQ_GC_NEUTRAL_MODE;
 486
 487         if (size <= stream->alloc_size)
 488                 return;
 489
 490         while (stream->alloc_size <= size) {
 491                 if (stream->alloc_size < 4096)
 492                         stream->alloc_size = 4096;
 493                 else
 494                         stream->alloc_size *= 2;
 495         }
 496
 497         stream->data = (char *)g_realloc (stream->data, stream->alloc_size);
 498 }
 499
 500 static guint32
 501 string_heap_insert (MonoDynamicStream *sh, const char *str)
 502 {
 503         MONO_REQ_GC_NEUTRAL_MODE;
 504
 505         guint32 idx;
 506         guint32 len;
 507         gpointer oldkey, oldval;
 508
 509         if (g_hash_table_lookup_extended (sh->hash, str, &oldkey, &oldval))
 510                 return GPOINTER_TO_UINT (oldval);
 511
 512         len = strlen (str) + 1;
 513         idx = sh->index;
 514
 515         make_room_in_stream (sh, idx + len);
 516
 517         /*
 518          * We strdup the string even if we already copy them in sh->data
 519          * so that the string pointers in the hash remain valid even if
 520          * we need to realloc sh->data. We may want to avoid that later.
 521          */
 522         g_hash_table_insert (sh->hash, g_strdup (str), GUINT_TO_POINTER (idx));
 523         memcpy (sh->data + idx, str, len);
 524         sh->index += len;
 525         return idx;
 526 }
 527
 528 static guint32
 529 string_heap_insert_mstring (MonoDynamicStream *sh, MonoString *str)
 530 {
 531         MONO_REQ_GC_UNSAFE_MODE;
 532
 533         char *name = mono_string_to_utf8 (str);
 534         guint32 idx;
 535         idx = string_heap_insert (sh, name);
 536         g_free (name);
 537         return idx;
 538 }
 539
 540 #ifndef DISABLE_REFLECTION_EMIT
 541 static void
 542 string_heap_init (MonoDynamicStream *sh)
 543 {
 544         MONO_REQ_GC_NEUTRAL_MODE;
 545
 546         sh->index = 0;
 547         sh->alloc_size = 4096;
 548         sh->data = (char *)g_malloc (4096);
 549         sh->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 550         string_heap_insert (sh, "");
 551 }
 552 #endif
 553
 554 static guint32
 555 mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
 556 {
 557         MONO_REQ_GC_NEUTRAL_MODE;
 558
 559         guint32 idx;
 560
 561         make_room_in_stream (stream, stream->index + len);
 562         memcpy (stream->data + stream->index, data, len);
 563         idx = stream->index;
 564         stream->index += len;
 565         /*
 566          * align index? Not without adding an additional param that controls it since
 567          * we may store a blob value in pieces.
 568          */
 569         return idx;
 570 }
 571
 572 static guint32
 573 mono_image_add_stream_zero (MonoDynamicStream *stream, guint32 len)
 574 {
 575         MONO_REQ_GC_NEUTRAL_MODE;
 576
 577         guint32 idx;
 578
 579         make_room_in_stream (stream, stream->index + len);
 580         memset (stream->data + stream->index, 0, len);
 581         idx = stream->index;
 582         stream->index += len;
 583         return idx;
 584 }
 585
 586 static void
 587 stream_data_align (MonoDynamicStream *stream)
 588 {
 589         MONO_REQ_GC_NEUTRAL_MODE;
 590
 591         char buf [4] = {0};
 592         guint32 count = stream->index % 4;
 593
 594         /* we assume the stream data will be aligned */
 595         if (count)
 596                 mono_image_add_stream_data (stream, buf, 4 - count);
 597 }
 598
 599 #ifndef DISABLE_REFLECTION_EMIT
 600 static int
 601 mono_blob_entry_hash (const char* str)
 602 {
 603         MONO_REQ_GC_NEUTRAL_MODE;
 604
 605         guint len, h;
 606         const char *end;
 607         len = mono_metadata_decode_blob_size (str, &str);
 608         if (len > 0) {
 609                 end = str + len;
 610                 h = *str;
 611                 for (str += 1; str < end; str++)
 612                         h = (h << 5) - h + *str;
 613                 return h;
 614         } else {
 615                 return 0;
 616         }
 617 }
 618
 619 static gboolean
 620 mono_blob_entry_equal (const char *str1, const char *str2) {
 621         MONO_REQ_GC_NEUTRAL_MODE;
 622
 623         int len, len2;
 624         const char *end1;
 625         const char *end2;
 626         len = mono_metadata_decode_blob_size (str1, &end1);
 627         len2 = mono_metadata_decode_blob_size (str2, &end2);
 628         if (len != len2)
 629                 return 0;
 630         return memcmp (end1, end2, len) == 0;
 631 }
 632 #endif
 633 static guint32
 634 add_to_blob_cached (MonoDynamicImage *assembly, char *b1, int s1, char *b2, int s2)
 635 {
 636         MONO_REQ_GC_NEUTRAL_MODE;
 637
 638         guint32 idx;
 639         char *copy;
 640         gpointer oldkey, oldval;
 641
 642         copy = (char *)g_malloc (s1+s2);
 643         memcpy (copy, b1, s1);
 644         memcpy (copy + s1, b2, s2);
 645         if (g_hash_table_lookup_extended (assembly->blob_cache, copy, &oldkey, &oldval)) {
 646                 g_free (copy);
 647                 idx = GPOINTER_TO_UINT (oldval);
 648         } else {
 649                 idx = mono_image_add_stream_data (&assembly->blob, b1, s1);
 650                 mono_image_add_stream_data (&assembly->blob, b2, s2);
 651                 g_hash_table_insert (assembly->blob_cache, copy, GUINT_TO_POINTER (idx));
 652         }
 653         return idx;
 654 }
 655
 656 static guint32
 657 sigbuffer_add_to_blob_cached (MonoDynamicImage *assembly, SigBuffer *buf)
 658 {
 659         MONO_REQ_GC_NEUTRAL_MODE;
 660
 661         char blob_size [8];
 662         char *b = blob_size;
 663         guint32 size = buf->p - buf->buf;
 664         /* store length */
 665         g_assert (size <= (buf->end - buf->buf));
 666         mono_metadata_encode_value (size, b, &b);
 667         return add_to_blob_cached (assembly, blob_size, b-blob_size, buf->buf, size);
 668 }
 669
 670 /*
 671  * Copy len * nelem bytes from val to dest, swapping bytes to LE if necessary.
 672  * dest may be misaligned.
 673  */
 674 static void
 675 swap_with_size (char *dest, const char* val, int len, int nelem) {
 676         MONO_REQ_GC_NEUTRAL_MODE;
 677 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 678         int elem;
 679
 680         for (elem = 0; elem < nelem; ++elem) {
 681                 switch (len) {
 682                 case 1:
 683                         *dest = *val;
 684                         break;
 685                 case 2:
 686                         dest [0] = val [1];
 687                         dest [1] = val [0];
 688                         break;
 689                 case 4:
 690                         dest [0] = val [3];
 691                         dest [1] = val [2];
 692                         dest [2] = val [1];
 693                         dest [3] = val [0];
 694                         break;
 695                 case 8:
 696                         dest [0] = val [7];
 697                         dest [1] = val [6];
 698                         dest [2] = val [5];
 699                         dest [3] = val [4];
 700                         dest [4] = val [3];
 701                         dest [5] = val [2];
 702                         dest [6] = val [1];
 703                         dest [7] = val [0];
 704                         break;
 705                 default:
 706                         g_assert_not_reached ();
 707                 }
 708                 dest += len;
 709                 val += len;
 710         }
 711 #else
 712         memcpy (dest, val, len * nelem);
 713 #endif
 714 }
 715
 716 static guint32
 717 add_mono_string_to_blob_cached (MonoDynamicImage *assembly, MonoString *str)
 718 {
 719         MONO_REQ_GC_UNSAFE_MODE;
 720
 721         char blob_size [64];
 722         char *b = blob_size;
 723         guint32 idx = 0, len;
 724
 725         len = str->length * 2;
 726         mono_metadata_encode_value (len, b, &b);
 727 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 728         {
 729                 char *swapped = g_malloc (2 * mono_string_length (str));
 730                 const char *p = (const char*)mono_string_chars (str);
 731
 732                 swap_with_size (swapped, p, 2, mono_string_length (str));
 733                 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, swapped, len);
 734                 g_free (swapped);
 735         }
 736 #else
 737         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, (char*)mono_string_chars (str), len);
 738 #endif
 739         return idx;
 740 }
 741
 742 #ifndef DISABLE_REFLECTION_EMIT
 743 static MonoClass *
 744 default_class_from_mono_type (MonoType *type)
 745 {
 746         MONO_REQ_GC_NEUTRAL_MODE;
 747
 748         switch (type->type) {
 749         case MONO_TYPE_OBJECT:
 750                 return mono_defaults.object_class;
 751         case MONO_TYPE_VOID:
 752                 return mono_defaults.void_class;
 753         case MONO_TYPE_BOOLEAN:
 754                 return mono_defaults.boolean_class;
 755         case MONO_TYPE_CHAR:
 756                 return mono_defaults.char_class;
 757         case MONO_TYPE_I1:
 758                 return mono_defaults.sbyte_class;
 759         case MONO_TYPE_U1:
 760                 return mono_defaults.byte_class;
 761         case MONO_TYPE_I2:
 762                 return mono_defaults.int16_class;
 763         case MONO_TYPE_U2:
 764                 return mono_defaults.uint16_class;
 765         case MONO_TYPE_I4:
 766                 return mono_defaults.int32_class;
 767         case MONO_TYPE_U4:
 768                 return mono_defaults.uint32_class;
 769         case MONO_TYPE_I:
 770                 return mono_defaults.int_class;
 771         case MONO_TYPE_U:
 772                 return mono_defaults.uint_class;
 773         case MONO_TYPE_I8:
 774                 return mono_defaults.int64_class;
 775         case MONO_TYPE_U8:
 776                 return mono_defaults.uint64_class;
 777         case MONO_TYPE_R4:
 778                 return mono_defaults.single_class;
 779         case MONO_TYPE_R8:
 780                 return mono_defaults.double_class;
 781         case MONO_TYPE_STRING:
 782                 return mono_defaults.string_class;
 783         default:
 784                 g_warning ("default_class_from_mono_type: implement me 0x%02x\n", type->type);
 785                 g_assert_not_reached ();
 786         }
 787
 788         return NULL;
 789 }
 790 #endif
 791
 792 /*
 793  * mono_class_get_ref_info:
 794  *
 795  *   Return the type builder/generic param builder corresponding to KLASS, if it exists.
 796  */
 797 gpointer
 798 mono_class_get_ref_info (MonoClass *klass)
 799 {
 800         MONO_REQ_GC_UNSAFE_MODE;
 801
 802         if (klass->ref_info_handle == 0)
 803                 return NULL;
 804         else
 805                 return mono_gchandle_get_target (klass->ref_info_handle);
 806 }
 807
 808 void
 809 mono_class_set_ref_info (MonoClass *klass, gpointer obj)
 810 {
 811         MONO_REQ_GC_UNSAFE_MODE;
 812
 813         klass->ref_info_handle = mono_gchandle_new ((MonoObject*)obj, FALSE);
 814         g_assert (klass->ref_info_handle != 0);
 815 }
 816
 817 void
 818 mono_class_free_ref_info (MonoClass *klass)
 819 {
 820         MONO_REQ_GC_NEUTRAL_MODE;
 821
 822         if (klass->ref_info_handle) {
 823                 mono_gchandle_free (klass->ref_info_handle);
 824                 klass->ref_info_handle = 0;
 825         }
 826 }
 827
 828 static void
 829 encode_generic_class (MonoDynamicImage *assembly, MonoGenericClass *gclass, SigBuffer *buf)
 830 {
 831         MONO_REQ_GC_NEUTRAL_MODE;
 832
 833         int i;
 834         MonoGenericInst *class_inst;
 835         MonoClass *klass;
 836
 837         g_assert (gclass);
 838
 839         class_inst = gclass->context.class_inst;
 840
 841         sigbuffer_add_value (buf, MONO_TYPE_GENERICINST);
 842         klass = gclass->container_class;
 843         sigbuffer_add_value (buf, klass->byval_arg.type);
 844         sigbuffer_add_value (buf, mono_image_typedef_or_ref_full (assembly, &klass->byval_arg, FALSE));
 845
 846         sigbuffer_add_value (buf, class_inst->type_argc);
 847         for (i = 0; i < class_inst->type_argc; ++i)
 848                 encode_type (assembly, class_inst->type_argv [i], buf);
 849
 850 }
 851
 852 static void
 853 encode_type (MonoDynamicImage *assembly, MonoType *type, SigBuffer *buf)
 854 {
 855         MONO_REQ_GC_NEUTRAL_MODE;
 856
 857         if (!type) {
 858                 g_assert_not_reached ();
 859                 return;
 860         }
 861
 862         if (type->byref)
 863                 sigbuffer_add_value (buf, MONO_TYPE_BYREF);
 864
 865         switch (type->type){
 866         case MONO_TYPE_VOID:
 867         case MONO_TYPE_BOOLEAN:
 868         case MONO_TYPE_CHAR:
 869         case MONO_TYPE_I1:
 870         case MONO_TYPE_U1:
 871         case MONO_TYPE_I2:
 872         case MONO_TYPE_U2:
 873         case MONO_TYPE_I4:
 874         case MONO_TYPE_U4:
 875         case MONO_TYPE_I8:
 876         case MONO_TYPE_U8:
 877         case MONO_TYPE_R4:
 878         case MONO_TYPE_R8:
 879         case MONO_TYPE_I:
 880         case MONO_TYPE_U:
 881         case MONO_TYPE_STRING:
 882         case MONO_TYPE_OBJECT:
 883         case MONO_TYPE_TYPEDBYREF:
 884                 sigbuffer_add_value (buf, type->type);
 885                 break;
 886         case MONO_TYPE_PTR:
 887                 sigbuffer_add_value (buf, type->type);
 888                 encode_type (assembly, type->data.type, buf);
 889                 break;
 890         case MONO_TYPE_SZARRAY:
 891                 sigbuffer_add_value (buf, type->type);
 892                 encode_type (assembly, &type->data.klass->byval_arg, buf);
 893                 break;
 894         case MONO_TYPE_VALUETYPE:
 895         case MONO_TYPE_CLASS: {
 896                 MonoClass *k = mono_class_from_mono_type (type);
 897
 898                 if (k->generic_container) {
 899                         MonoGenericClass *gclass = mono_metadata_lookup_generic_class (k, k->generic_container->context.class_inst, TRUE);
 900                         encode_generic_class (assembly, gclass, buf);
 901                 } else {
 902                         /*
 903                          * Make sure we use the correct type.
 904                          */
 905                         sigbuffer_add_value (buf, k->byval_arg.type);
 906                         /*
 907                          * ensure only non-byref gets passed to mono_image_typedef_or_ref(),
 908                          * otherwise two typerefs could point to the same type, leading to
 909                          * verification errors.
 910                          */
 911                         sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, &k->byval_arg));
 912                 }
 913                 break;
 914         }
 915         case MONO_TYPE_ARRAY:
 916                 sigbuffer_add_value (buf, type->type);
 917                 encode_type (assembly, &type->data.array->eklass->byval_arg, buf);
 918                 sigbuffer_add_value (buf, type->data.array->rank);
 919                 sigbuffer_add_value (buf, 0); /* FIXME: set to 0 for now */
 920                 sigbuffer_add_value (buf, 0);
 921                 break;
 922         case MONO_TYPE_GENERICINST:
 923                 encode_generic_class (assembly, type->data.generic_class, buf);
 924                 break;
 925         case MONO_TYPE_VAR:
 926         case MONO_TYPE_MVAR:
 927                 sigbuffer_add_value (buf, type->type);
 928                 sigbuffer_add_value (buf, mono_type_get_generic_param_num (type));
 929                 break;
 930         default:
 931                 g_error ("need to encode type %x", type->type);
 932         }
 933 }
 934
 935 static void
 936 encode_reflection_type (MonoDynamicImage *assembly, MonoReflectionType *type, SigBuffer *buf, MonoError *error)
 937 {
 938         MONO_REQ_GC_UNSAFE_MODE;
 939
 940         mono_error_init (error);
 941
 942         if (!type) {
 943                 sigbuffer_add_value (buf, MONO_TYPE_VOID);
 944                 return;
 945         }
 946
 947         MonoType *t = mono_reflection_type_get_handle (type, error);
 948         return_if_nok (error);
 949         encode_type (assembly, t, buf);
 950 }
 951
 952 static void
 953 encode_custom_modifiers (MonoDynamicImage *assembly, MonoArray *modreq, MonoArray *modopt, SigBuffer *buf, MonoError *error)
 954 {
 955         MONO_REQ_GC_UNSAFE_MODE;
 956
 957         int i;
 958
 959         mono_error_init (error);
 960
 961         if (modreq) {
 962                 for (i = 0; i < mono_array_length (modreq); ++i) {
 963                         MonoType *mod = mono_type_array_get_and_resolve (modreq, i, error);
 964                         return_if_nok (error);
 965                         sigbuffer_add_byte (buf, MONO_TYPE_CMOD_REQD);
 966                         sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, mod));
 967                 }
 968         }
 969         if (modopt) {
 970                 for (i = 0; i < mono_array_length (modopt); ++i) {
 971                         MonoType *mod = mono_type_array_get_and_resolve (modopt, i, error);
 972                         return_if_nok (error);
 973                         sigbuffer_add_byte (buf, MONO_TYPE_CMOD_OPT);
 974                         sigbuffer_add_value (buf, mono_image_typedef_or_ref (assembly, mod));
 975                 }
 976         }
 977 }
 978
 979 #ifndef DISABLE_REFLECTION_EMIT
 980 static guint32
 981 method_encode_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig)
 982 {
 983         MONO_REQ_GC_UNSAFE_MODE;
 984
 985         SigBuffer buf;
 986         int i;
 987         guint32 nparams =  sig->param_count;
 988         guint32 idx;
 989
 990         if (!assembly->save)
 991                 return 0;
 992
 993         sigbuffer_init (&buf, 32);
 994         /*
 995          * FIXME: vararg, explicit_this, differenc call_conv values...
 996          */
 997         idx = sig->call_convention;
 998         if (sig->hasthis)
 999                 idx |= 0x20; /* hasthis */
1000         if (sig->generic_param_count)
1001                 idx |= 0x10; /* generic */
1002         sigbuffer_add_byte (&buf, idx);
1003         if (sig->generic_param_count)
1004                 sigbuffer_add_value (&buf, sig->generic_param_count);
1005         sigbuffer_add_value (&buf, nparams);
1006         encode_type (assembly, sig->ret, &buf);
1007         for (i = 0; i < nparams; ++i) {
1008                 if (i == sig->sentinelpos)
1009                         sigbuffer_add_byte (&buf, MONO_TYPE_SENTINEL);
1010                 encode_type (assembly, sig->params [i], &buf);
1011         }
1012         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1013         sigbuffer_free (&buf);
1014         return idx;
1015 }
1016 #endif
1017
1018 static guint32
1019 method_builder_encode_signature (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb, MonoError *error)
1020 {
1021         MONO_REQ_GC_UNSAFE_MODE;
1022
1023         mono_error_init (error);
1024
1025         /*
1026          * FIXME: reuse code from method_encode_signature().
1027          */
1028         SigBuffer buf;
1029         int i;
1030         guint32 nparams =  mb->parameters ? mono_array_length (mb->parameters): 0;
1031         guint32 ngparams = mb->generic_params ? mono_array_length (mb->generic_params): 0;
1032         guint32 notypes = mb->opt_types ? mono_array_length (mb->opt_types): 0;
1033         guint32 idx;
1034
1035         sigbuffer_init (&buf, 32);
1036         /* LAMESPEC: all the call conv spec is foobared */
1037         idx = mb->call_conv & 0x60; /* has-this, explicit-this */
1038         if (mb->call_conv & 2)
1039                 idx |= 0x5; /* vararg */
1040         if (!(mb->attrs & METHOD_ATTRIBUTE_STATIC))
1041                 idx |= 0x20; /* hasthis */
1042         if (ngparams)
1043                 idx |= 0x10; /* generic */
1044         sigbuffer_add_byte (&buf, idx);
1045         if (ngparams)
1046                 sigbuffer_add_value (&buf, ngparams);
1047         sigbuffer_add_value (&buf, nparams + notypes);
1048         encode_custom_modifiers (assembly, mb->return_modreq, mb->return_modopt, &buf, error);
1049         if (!is_ok (error))
1050                 goto leave;
1051         encode_reflection_type (assembly, mb->rtype, &buf, error);
1052         if (!is_ok (error))
1053                 goto leave;
1054         for (i = 0; i < nparams; ++i) {
1055                 MonoArray *modreq = NULL;
1056                 MonoArray *modopt = NULL;
1057                 MonoReflectionType *pt;
1058
1059                 if (mb->param_modreq && (i < mono_array_length (mb->param_modreq)))
1060                         modreq = mono_array_get (mb->param_modreq, MonoArray*, i);
1061                 if (mb->param_modopt && (i < mono_array_length (mb->param_modopt)))
1062                         modopt = mono_array_get (mb->param_modopt, MonoArray*, i);
1063                 encode_custom_modifiers (assembly, modreq, modopt, &buf, error);
1064                 if (!is_ok (error))
1065                         goto leave;
1066                 pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
1067                 encode_reflection_type (assembly, pt, &buf, error);
1068                 if (!is_ok (error))
1069                         goto leave;
1070         }
1071         if (notypes)
1072                 sigbuffer_add_byte (&buf, MONO_TYPE_SENTINEL);
1073         for (i = 0; i < notypes; ++i) {
1074                 MonoReflectionType *pt;
1075
1076                 pt = mono_array_get (mb->opt_types, MonoReflectionType*, i);
1077                 encode_reflection_type (assembly, pt, &buf, error);
1078                 if (!is_ok (error))
1079                         goto leave;
1080         }
1081
1082         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1083 leave:
1084         sigbuffer_free (&buf);
1085         return idx;
1086 }
1087
1088 static guint32
1089 encode_locals (MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, MonoError *error)
1090 {
1091         MONO_REQ_GC_UNSAFE_MODE;
1092
1093         mono_error_init (error);
1094
1095         MonoDynamicTable *table;
1096         guint32 *values;
1097         guint32 idx, sig_idx;
1098         guint nl = mono_array_length (ilgen->locals);
1099         SigBuffer buf;
1100         int i;
1101
1102         sigbuffer_init (&buf, 32);
1103         sigbuffer_add_value (&buf, 0x07);
1104         sigbuffer_add_value (&buf, nl);
1105         for (i = 0; i < nl; ++i) {
1106                 MonoReflectionLocalBuilder *lb = mono_array_get (ilgen->locals, MonoReflectionLocalBuilder*, i);
1107
1108                 if (lb->is_pinned)
1109                         sigbuffer_add_value (&buf, MONO_TYPE_PINNED);
1110
1111                 encode_reflection_type (assembly, (MonoReflectionType*)lb->type, &buf, error);
1112                 if (!is_ok (error)) {
1113                         sigbuffer_free (&buf);
1114                         return 0;
1115                 }
1116         }
1117         sig_idx = sigbuffer_add_to_blob_cached (assembly, &buf);
1118         sigbuffer_free (&buf);
1119
1120         if (assembly->standalonesig_cache == NULL)
1121                 assembly->standalonesig_cache = g_hash_table_new (NULL, NULL);
1122         idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->standalonesig_cache, GUINT_TO_POINTER (sig_idx)));
1123         if (idx)
1124                 return idx;
1125
1126         table = &assembly->tables [MONO_TABLE_STANDALONESIG];
1127         idx = table->next_idx ++;
1128         table->rows ++;
1129         alloc_table (table, table->rows);
1130         values = table->values + idx * MONO_STAND_ALONE_SIGNATURE_SIZE;
1131
1132         values [MONO_STAND_ALONE_SIGNATURE] = sig_idx;
1133
1134         g_hash_table_insert (assembly->standalonesig_cache, GUINT_TO_POINTER (sig_idx), GUINT_TO_POINTER (idx));
1135
1136         return idx;
1137 }
1138
1139 static guint32
1140 method_count_clauses (MonoReflectionILGen *ilgen)
1141 {
1142         MONO_REQ_GC_UNSAFE_MODE;
1143
1144         guint32 num_clauses = 0;
1145         int i;
1146
1147         MonoILExceptionInfo *ex_info;
1148         for (i = 0; i < mono_array_length (ilgen->ex_handlers); ++i) {
1149                 ex_info = (MonoILExceptionInfo*)mono_array_addr (ilgen->ex_handlers, MonoILExceptionInfo, i);
1150                 if (ex_info->handlers)
1151                         num_clauses += mono_array_length (ex_info->handlers);
1152                 else
1153                         num_clauses++;
1154         }
1155
1156         return num_clauses;
1157 }
1158
1159 #ifndef DISABLE_REFLECTION_EMIT
1160 static MonoExceptionClause*
1161 method_encode_clauses (MonoImage *image, MonoDynamicImage *assembly, MonoReflectionILGen *ilgen, guint32 num_clauses, MonoError *error)
1162 {
1163         MONO_REQ_GC_UNSAFE_MODE;
1164
1165         mono_error_init (error);
1166
1167         MonoExceptionClause *clauses;
1168         MonoExceptionClause *clause;
1169         MonoILExceptionInfo *ex_info;
1170         MonoILExceptionBlock *ex_block;
1171         guint32 finally_start;
1172         int i, j, clause_index;;
1173
1174         clauses = image_g_new0 (image, MonoExceptionClause, num_clauses);
1175
1176         clause_index = 0;
1177         for (i = mono_array_length (ilgen->ex_handlers) - 1; i >= 0; --i) {
1178                 ex_info = (MonoILExceptionInfo*)mono_array_addr (ilgen->ex_handlers, MonoILExceptionInfo, i);
1179                 finally_start = ex_info->start + ex_info->len;
1180                 if (!ex_info->handlers)
1181                         continue;
1182                 for (j = 0; j < mono_array_length (ex_info->handlers); ++j) {
1183                         ex_block = (MonoILExceptionBlock*)mono_array_addr (ex_info->handlers, MonoILExceptionBlock, j);
1184                         clause = &(clauses [clause_index]);
1185
1186                         clause->flags = ex_block->type;
1187                         clause->try_offset = ex_info->start;
1188
1189                         if (ex_block->type == MONO_EXCEPTION_CLAUSE_FINALLY)
1190                                 clause->try_len = finally_start - ex_info->start;
1191                         else
1192                                 clause->try_len = ex_info->len;
1193                         clause->handler_offset = ex_block->start;
1194                         clause->handler_len = ex_block->len;
1195                         if (ex_block->extype) {
1196                                 MonoType *extype = mono_reflection_type_get_handle ((MonoReflectionType*)ex_block->extype, error);
1197
1198                                 if (!is_ok (error)) {
1199                                         image_g_free (image, clauses);
1200                                         return NULL;
1201                                 }
1202                                 clause->data.catch_class = mono_class_from_mono_type (extype);
1203                         } else {
1204                                 if (ex_block->type == MONO_EXCEPTION_CLAUSE_FILTER)
1205                                         clause->data.filter_offset = ex_block->filter_offset;
1206                                 else
1207                                         clause->data.filter_offset = 0;
1208                         }
1209                         finally_start = ex_block->start + ex_block->len;
1210
1211                         clause_index ++;
1212                 }
1213         }
1214
1215         return clauses;
1216 }
1217 #endif /* !DISABLE_REFLECTION_EMIT */
1218
1219 /**
1220  * method_encode_code:
1221  *
1222  * @assembly the assembly
1223  * @mb the managed MethodBuilder
1224  * @error set on error
1225  *
1226  * Note that the return value is not sensible if @error is set.
1227  */
1228 static guint32
1229 method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb, MonoError *error)
1230 {
1231         MONO_REQ_GC_UNSAFE_MODE;
1232
1233         char flags = 0;
1234         guint32 idx;
1235         guint32 code_size;
1236         gint32 max_stack, i;
1237         gint32 num_locals = 0;
1238         gint32 num_exception = 0;
1239         gint maybe_small;
1240         guint32 fat_flags;
1241         char fat_header [12];
1242         guint32 int_value;
1243         guint16 short_value;
1244         guint32 local_sig = 0;
1245         guint32 header_size = 12;
1246         MonoArray *code;
1247
1248         mono_error_init (error);
1249
1250         if ((mb->attrs & (METHOD_ATTRIBUTE_PINVOKE_IMPL | METHOD_ATTRIBUTE_ABSTRACT)) ||
1251                         (mb->iattrs & (METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL | METHOD_IMPL_ATTRIBUTE_RUNTIME)))
1252                 return 0;
1253
1254         /*if (mb->name)
1255                 g_print ("Encode method %s\n", mono_string_to_utf8 (mb->name));*/
1256         if (mb->ilgen) {
1257                 code = mb->ilgen->code;
1258                 code_size = mb->ilgen->code_len;
1259                 max_stack = mb->ilgen->max_stack;
1260                 num_locals = mb->ilgen->locals ? mono_array_length (mb->ilgen->locals) : 0;
1261                 if (mb->ilgen->ex_handlers)
1262                         num_exception = method_count_clauses (mb->ilgen);
1263         } else {
1264                 code = mb->code;
1265                 if (code == NULL){
1266                         char *name = mono_string_to_utf8 (mb->name);
1267                         char *str = g_strdup_printf ("Method %s does not have any IL associated", name);
1268                         mono_error_set_argument (error, NULL, "a method does not have any IL associated");
1269                         g_free (str);
1270                         g_free (name);
1271                         return 0;
1272                 }
1273
1274                 code_size = mono_array_length (code);
1275                 max_stack = 8; /* we probably need to run a verifier on the code... */
1276         }
1277
1278         stream_data_align (&assembly->code);
1279
1280         /* check for exceptions, maxstack, locals */
1281         maybe_small = (max_stack <= 8) && (!num_locals) && (!num_exception);
1282         if (maybe_small) {
1283                 if (code_size < 64 && !(code_size & 1)) {
1284                         flags = (code_size << 2) | 0x2;
1285                 } else if (code_size < 32 && (code_size & 1)) {
1286                         flags = (code_size << 2) | 0x6; /* LAMESPEC: see metadata.c */
1287                 } else {
1288                         goto fat_header;
1289                 }
1290                 idx = mono_image_add_stream_data (&assembly->code, &flags, 1);
1291                 /* add to the fixup todo list */
1292                 if (mb->ilgen && mb->ilgen->num_token_fixups)
1293                         mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 1));
1294                 mono_image_add_stream_data (&assembly->code, mono_array_addr (code, char, 0), code_size);
1295                 return assembly->text_rva + idx;
1296         }
1297 fat_header:
1298         if (num_locals) {
1299                 local_sig = MONO_TOKEN_SIGNATURE | encode_locals (assembly, mb->ilgen, error);
1300                 return_val_if_nok (error, 0);
1301         }
1302         /*
1303          * FIXME: need to set also the header size in fat_flags.
1304          * (and more sects and init locals flags)
1305          */
1306         fat_flags =  0x03;
1307         if (num_exception)
1308                 fat_flags |= METHOD_HEADER_MORE_SECTS;
1309         if (mb->init_locals)
1310                 fat_flags |= METHOD_HEADER_INIT_LOCALS;
1311         fat_header [0] = fat_flags;
1312         fat_header [1] = (header_size / 4 ) << 4;
1313         short_value = GUINT16_TO_LE (max_stack);
1314         memcpy (fat_header + 2, &short_value, 2);
1315         int_value = GUINT32_TO_LE (code_size);
1316         memcpy (fat_header + 4, &int_value, 4);
1317         int_value = GUINT32_TO_LE (local_sig);
1318         memcpy (fat_header + 8, &int_value, 4);
1319         idx = mono_image_add_stream_data (&assembly->code, fat_header, 12);
1320         /* add to the fixup todo list */
1321         if (mb->ilgen && mb->ilgen->num_token_fixups)
1322                 mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 12));
1323
1324         mono_image_add_stream_data (&assembly->code, mono_array_addr (code, char, 0), code_size);
1325         if (num_exception) {
1326                 unsigned char sheader [4];
1327                 MonoILExceptionInfo * ex_info;
1328                 MonoILExceptionBlock * ex_block;
1329                 int j;
1330
1331                 stream_data_align (&assembly->code);
1332                 /* always use fat format for now */
1333                 sheader [0] = METHOD_HEADER_SECTION_FAT_FORMAT | METHOD_HEADER_SECTION_EHTABLE;
1334                 num_exception *= 6 * sizeof (guint32);
1335                 num_exception += 4; /* include the size of the header */
1336                 sheader [1] = num_exception & 0xff;
1337                 sheader [2] = (num_exception >> 8) & 0xff;
1338                 sheader [3] = (num_exception >> 16) & 0xff;
1339                 mono_image_add_stream_data (&assembly->code, (char*)sheader, 4);
1340                 /* fat header, so we are already aligned */
1341                 /* reverse order */
1342                 for (i = mono_array_length (mb->ilgen->ex_handlers) - 1; i >= 0; --i) {
1343                         ex_info = (MonoILExceptionInfo *)mono_array_addr (mb->ilgen->ex_handlers, MonoILExceptionInfo, i);
1344                         if (ex_info->handlers) {
1345                                 int finally_start = ex_info->start + ex_info->len;
1346                                 for (j = 0; j < mono_array_length (ex_info->handlers); ++j) {
1347                                         guint32 val;
1348                                         ex_block = (MonoILExceptionBlock*)mono_array_addr (ex_info->handlers, MonoILExceptionBlock, j);
1349                                         /* the flags */
1350                                         val = GUINT32_TO_LE (ex_block->type);
1351                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1352                                         /* try offset */
1353                                         val = GUINT32_TO_LE (ex_info->start);
1354                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1355                                         /* need fault, too, probably */
1356                                         if (ex_block->type == MONO_EXCEPTION_CLAUSE_FINALLY)
1357                                                 val = GUINT32_TO_LE (finally_start - ex_info->start);
1358                                         else
1359                                                 val = GUINT32_TO_LE (ex_info->len);
1360                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1361                                         /* handler offset */
1362                                         val = GUINT32_TO_LE (ex_block->start);
1363                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1364                                         /* handler len */
1365                                         val = GUINT32_TO_LE (ex_block->len);
1366                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1367                                         finally_start = ex_block->start + ex_block->len;
1368                                         if (ex_block->extype) {
1369                                                 MonoType *extype = mono_reflection_type_get_handle ((MonoReflectionType*)ex_block->extype, error);
1370                                                 return_val_if_nok (error, 0);
1371
1372                                                 val = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, extype));
1373                                         } else {
1374                                                 if (ex_block->type == MONO_EXCEPTION_CLAUSE_FILTER)
1375                                                         val = ex_block->filter_offset;
1376                                                 else
1377                                                         val = 0;
1378                                         }
1379                                         val = GUINT32_TO_LE (val);
1380                                         mono_image_add_stream_data (&assembly->code, (char*)&val, sizeof (guint32));
1381                                         /*g_print ("out clause %d: from %d len=%d, handler at %d, %d, finally_start=%d, ex_info->start=%d, ex_info->len=%d, ex_block->type=%d, j=%d, i=%d\n",
1382                                                         clause.flags, clause.try_offset, clause.try_len, clause.handler_offset, clause.handler_len, finally_start, ex_info->start, ex_info->len, ex_block->type, j, i);*/
1383                                 }
1384                         } else {
1385                                 g_error ("No clauses for ex info block %d", i);
1386                         }
1387                 }
1388         }
1389         return assembly->text_rva + idx;
1390 }
1391
1392 static guint32
1393 find_index_in_table (MonoDynamicImage *assembly, int table_idx, int col, guint32 token)
1394 {
1395         MONO_REQ_GC_NEUTRAL_MODE;
1396
1397         int i;
1398         MonoDynamicTable *table;
1399         guint32 *values;
1400
1401         table = &assembly->tables [table_idx];
1402
1403         g_assert (col < table->columns);
1404
1405         values = table->values + table->columns;
1406         for (i = 1; i <= table->rows; ++i) {
1407                 if (values [col] == token)
1408                         return i;
1409                 values += table->columns;
1410         }
1411         return 0;
1412 }
1413
1414 /*
1415  * LOCKING: Acquires the loader lock.
1416  */
1417 static MonoCustomAttrInfo*
1418 lookup_custom_attr (MonoImage *image, gpointer member)
1419 {
1420         MONO_REQ_GC_NEUTRAL_MODE;
1421
1422         MonoCustomAttrInfo* res;
1423
1424         res = (MonoCustomAttrInfo *)mono_image_property_lookup (image, member, MONO_PROP_DYNAMIC_CATTR);
1425
1426         if (!res)
1427                 return NULL;
1428
1429         res = (MonoCustomAttrInfo *)g_memdup (res, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * res->num_attrs);
1430         res->cached = 0;
1431         return res;
1432 }
1433
1434 static gboolean
1435 custom_attr_visible (MonoImage *image, MonoReflectionCustomAttr *cattr)
1436 {
1437         MONO_REQ_GC_UNSAFE_MODE;
1438
1439         /* FIXME: Need to do more checks */
1440         if (cattr->ctor->method && (cattr->ctor->method->klass->image != image)) {
1441                 int visibility = cattr->ctor->method->klass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
1442
1443                 if ((visibility != TYPE_ATTRIBUTE_PUBLIC) && (visibility != TYPE_ATTRIBUTE_NESTED_PUBLIC))
1444                         return FALSE;
1445         }
1446
1447         return TRUE;
1448 }
1449
1450 static MonoCustomAttrInfo*
1451 mono_custom_attrs_from_builders (MonoImage *alloc_img, MonoImage *image, MonoArray *cattrs)
1452 {
1453         MONO_REQ_GC_UNSAFE_MODE;
1454
1455         int i, index, count, not_visible;
1456         MonoCustomAttrInfo *ainfo;
1457         MonoReflectionCustomAttr *cattr;
1458
1459         if (!cattrs)
1460                 return NULL;
1461         /* FIXME: check in assembly the Run flag is set */
1462
1463         count = mono_array_length (cattrs);
1464
1465         /* Skip nonpublic attributes since MS.NET seems to do the same */
1466         /* FIXME: This needs to be done more globally */
1467         not_visible = 0;
1468         for (i = 0; i < count; ++i) {
1469                 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
1470                 if (!custom_attr_visible (image, cattr))
1471                         not_visible ++;
1472         }
1473         count -= not_visible;
1474
1475         ainfo = (MonoCustomAttrInfo *)image_g_malloc0 (alloc_img, MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * count);
1476
1477         ainfo->image = image;
1478         ainfo->num_attrs = count;
1479         ainfo->cached = alloc_img != NULL;
1480         index = 0;
1481         for (i = 0; i < count; ++i) {
1482                 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
1483                 if (custom_attr_visible (image, cattr)) {
1484                         unsigned char *saved = (unsigned char *)mono_image_alloc (image, mono_array_length (cattr->data));
1485                         memcpy (saved, mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
1486                         ainfo->attrs [index].ctor = cattr->ctor->method;
1487                         ainfo->attrs [index].data = saved;
1488                         ainfo->attrs [index].data_size = mono_array_length (cattr->data);
1489                         index ++;
1490                 }
1491         }
1492
1493         return ainfo;
1494 }
1495
1496 #ifndef DISABLE_REFLECTION_EMIT
1497 /*
1498  * LOCKING: Acquires the loader lock.
1499  */
1500 static void
1501 mono_save_custom_attrs (MonoImage *image, void *obj, MonoArray *cattrs)
1502 {
1503         MONO_REQ_GC_UNSAFE_MODE;
1504
1505         MonoCustomAttrInfo *ainfo, *tmp;
1506
1507         if (!cattrs || !mono_array_length (cattrs))
1508                 return;
1509
1510         ainfo = mono_custom_attrs_from_builders (image, image, cattrs);
1511
1512         mono_loader_lock ();
1513         tmp = (MonoCustomAttrInfo *)mono_image_property_lookup (image, obj, MONO_PROP_DYNAMIC_CATTR);
1514         if (tmp)
1515                 mono_custom_attrs_free (tmp);
1516         mono_image_property_insert (image, obj, MONO_PROP_DYNAMIC_CATTR, ainfo);
1517         mono_loader_unlock ();
1518
1519 }
1520 #endif
1521
1522 void
1523 mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
1524 {
1525         MONO_REQ_GC_NEUTRAL_MODE;
1526
1527         if (ainfo && !ainfo->cached)
1528                 g_free (ainfo);
1529 }
1530
1531 /*
1532  * idx is the table index of the object
1533  * type is one of MONO_CUSTOM_ATTR_*
1534  */
1535 static gboolean
1536 mono_image_add_cattrs (MonoDynamicImage *assembly, guint32 idx, guint32 type, MonoArray *cattrs, MonoError *error)
1537 {
1538         MONO_REQ_GC_UNSAFE_MODE;
1539
1540         MonoDynamicTable *table;
1541         MonoReflectionCustomAttr *cattr;
1542         guint32 *values;
1543         guint32 count, i, token;
1544         char blob_size [6];
1545         char *p = blob_size;
1546
1547         mono_error_init (error);
1548
1549         /* it is legal to pass a NULL cattrs: we avoid to use the if in a lot of places */
1550         if (!cattrs)
1551                 return TRUE;
1552         count = mono_array_length (cattrs);
1553         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
1554         table->rows += count;
1555         alloc_table (table, table->rows);
1556         values = table->values + table->next_idx * MONO_CUSTOM_ATTR_SIZE;
1557         idx <<= MONO_CUSTOM_ATTR_BITS;
1558         idx |= type;
1559         for (i = 0; i < count; ++i) {
1560                 cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
1561                 values [MONO_CUSTOM_ATTR_PARENT] = idx;
1562                 token = mono_image_create_token (assembly, (MonoObject*)cattr->ctor, FALSE, FALSE, error);
1563                 if (!mono_error_ok (error)) goto fail;
1564                 type = mono_metadata_token_index (token);
1565                 type <<= MONO_CUSTOM_ATTR_TYPE_BITS;
1566                 switch (mono_metadata_token_table (token)) {
1567                 case MONO_TABLE_METHOD:
1568                         type |= MONO_CUSTOM_ATTR_TYPE_METHODDEF;
1569                         /*
1570                          * fixup_cattrs () needs to fix this up. We can't use image->tokens, since it contains the old token for the
1571                          * method, not the one returned by mono_image_create_token ().
1572                          */
1573                         mono_g_hash_table_insert (assembly->remapped_tokens, GUINT_TO_POINTER (token), cattr->ctor);
1574                         break;
1575                 case MONO_TABLE_MEMBERREF:
1576                         type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
1577                         break;
1578                 default:
1579                         g_warning ("got wrong token in custom attr");
1580                         continue;
1581                 }
1582                 values [MONO_CUSTOM_ATTR_TYPE] = type;
1583                 p = blob_size;
1584                 mono_metadata_encode_value (mono_array_length (cattr->data), p, &p);
1585                 values [MONO_CUSTOM_ATTR_VALUE] = add_to_blob_cached (assembly, blob_size, p - blob_size,
1586                         mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
1587                 values += MONO_CUSTOM_ATTR_SIZE;
1588                 ++table->next_idx;
1589         }
1590
1591         return TRUE;
1592
1593 fail:
1594         return FALSE;
1595 }
1596
1597 static void
1598 mono_image_add_decl_security (MonoDynamicImage *assembly, guint32 parent_token, MonoArray *permissions)
1599 {
1600         MONO_REQ_GC_UNSAFE_MODE;
1601
1602         MonoDynamicTable *table;
1603         guint32 *values;
1604         guint32 count, i, idx;
1605         MonoReflectionPermissionSet *perm;
1606
1607         if (!permissions)
1608                 return;
1609
1610         count = mono_array_length (permissions);
1611         table = &assembly->tables [MONO_TABLE_DECLSECURITY];
1612         table->rows += count;
1613         alloc_table (table, table->rows);
1614
1615         for (i = 0; i < mono_array_length (permissions); ++i) {
1616                 perm = (MonoReflectionPermissionSet*)mono_array_addr (permissions, MonoReflectionPermissionSet, i);
1617
1618                 values = table->values + table->next_idx * MONO_DECL_SECURITY_SIZE;
1619
1620                 idx = mono_metadata_token_index (parent_token);
1621                 idx <<= MONO_HAS_DECL_SECURITY_BITS;
1622                 switch (mono_metadata_token_table (parent_token)) {
1623                 case MONO_TABLE_TYPEDEF:
1624                         idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
1625                         break;
1626                 case MONO_TABLE_METHOD:
1627                         idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
1628                         break;
1629                 case MONO_TABLE_ASSEMBLY:
1630                         idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
1631                         break;
1632                 default:
1633                         g_assert_not_reached ();
1634                 }
1635
1636                 values [MONO_DECL_SECURITY_ACTION] = perm->action;
1637                 values [MONO_DECL_SECURITY_PARENT] = idx;
1638                 values [MONO_DECL_SECURITY_PERMISSIONSET] = add_mono_string_to_blob_cached (assembly, perm->pset);
1639
1640                 ++table->next_idx;
1641         }
1642 }
1643
1644 /*
1645  * Fill in the MethodDef and ParamDef tables for a method.
1646  * This is used for both normal methods and constructors.
1647  */
1648 static gboolean
1649 mono_image_basic_method (ReflectionMethodBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
1650 {
1651         MONO_REQ_GC_UNSAFE_MODE;
1652
1653         MonoDynamicTable *table;
1654         guint32 *values;
1655         guint i, count;
1656
1657         mono_error_init (error);
1658
1659         /* room in this table is already allocated */
1660         table = &assembly->tables [MONO_TABLE_METHOD];
1661         *mb->table_idx = table->next_idx ++;
1662         g_hash_table_insert (assembly->method_to_table_idx, mb->mhandle, GUINT_TO_POINTER ((*mb->table_idx)));
1663         values = table->values + *mb->table_idx * MONO_METHOD_SIZE;
1664         values [MONO_METHOD_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name);
1665         values [MONO_METHOD_FLAGS] = mb->attrs;
1666         values [MONO_METHOD_IMPLFLAGS] = mb->iattrs;
1667         values [MONO_METHOD_SIGNATURE] = method_builder_encode_signature (assembly, mb, error);
1668         return_val_if_nok (error, FALSE);
1669         values [MONO_METHOD_RVA] = method_encode_code (assembly, mb, error);
1670         return_val_if_nok (error, FALSE);
1671
1672         table = &assembly->tables [MONO_TABLE_PARAM];
1673         values [MONO_METHOD_PARAMLIST] = table->next_idx;
1674
1675         mono_image_add_decl_security (assembly,
1676                 mono_metadata_make_token (MONO_TABLE_METHOD, *mb->table_idx), mb->permissions);
1677
1678         if (mb->pinfo) {
1679                 MonoDynamicTable *mtable;
1680                 guint32 *mvalues;
1681
1682                 mtable = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
1683                 mvalues = mtable->values + mtable->next_idx * MONO_FIELD_MARSHAL_SIZE;
1684
1685                 count = 0;
1686                 for (i = 0; i < mono_array_length (mb->pinfo); ++i) {
1687                         if (mono_array_get (mb->pinfo, gpointer, i))
1688                                 count++;
1689                 }
1690                 table->rows += count;
1691                 alloc_table (table, table->rows);
1692                 values = table->values + table->next_idx * MONO_PARAM_SIZE;
1693                 for (i = 0; i < mono_array_length (mb->pinfo); ++i) {
1694                         MonoReflectionParamBuilder *pb;
1695                         if ((pb = mono_array_get (mb->pinfo, MonoReflectionParamBuilder*, i))) {
1696                                 values [MONO_PARAM_FLAGS] = pb->attrs;
1697                                 values [MONO_PARAM_SEQUENCE] = i;
1698                                 if (pb->name != NULL) {
1699                                         values [MONO_PARAM_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name);
1700                                 } else {
1701                                         values [MONO_PARAM_NAME] = 0;
1702                                 }
1703                                 values += MONO_PARAM_SIZE;
1704                                 if (pb->marshal_info) {
1705                                         mtable->rows++;
1706                                         alloc_table (mtable, mtable->rows);
1707                                         mvalues = mtable->values + mtable->rows * MONO_FIELD_MARSHAL_SIZE;
1708                                         mvalues [MONO_FIELD_MARSHAL_PARENT] = (table->next_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_PARAMDEF;
1709                                         mvalues [MONO_FIELD_MARSHAL_NATIVE_TYPE] = encode_marshal_blob (assembly, pb->marshal_info, error);
1710                                         return_val_if_nok (error, FALSE);
1711                                 }
1712                                 pb->table_idx = table->next_idx++;
1713                                 if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
1714                                         guint32 field_type = 0;
1715                                         mtable = &assembly->tables [MONO_TABLE_CONSTANT];
1716                                         mtable->rows ++;
1717                                         alloc_table (mtable, mtable->rows);
1718                                         mvalues = mtable->values + mtable->rows * MONO_CONSTANT_SIZE;
1719                                         mvalues [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_PARAM | (pb->table_idx << MONO_HASCONSTANT_BITS);
1720                                         mvalues [MONO_CONSTANT_VALUE] = encode_constant (assembly, pb->def_value, &field_type);
1721                                         mvalues [MONO_CONSTANT_TYPE] = field_type;
1722                                         mvalues [MONO_CONSTANT_PADDING] = 0;
1723                                 }
1724                         }
1725                 }
1726         }
1727
1728         return TRUE;
1729 }
1730
1731 #ifndef DISABLE_REFLECTION_EMIT
1732 static gboolean
1733 reflection_methodbuilder_from_method_builder (ReflectionMethodBuilder *rmb, MonoReflectionMethodBuilder *mb, MonoError *error)
1734 {
1735         MONO_REQ_GC_UNSAFE_MODE;
1736
1737         mono_error_init (error);
1738         memset (rmb, 0, sizeof (ReflectionMethodBuilder));
1739
1740         rmb->ilgen = mb->ilgen;
1741         rmb->rtype = mono_reflection_type_resolve_user_types ((MonoReflectionType*)mb->rtype, error);
1742         return_val_if_nok (error, FALSE);
1743         rmb->parameters = mb->parameters;
1744         rmb->generic_params = mb->generic_params;
1745         rmb->generic_container = mb->generic_container;
1746         rmb->opt_types = NULL;
1747         rmb->pinfo = mb->pinfo;
1748         rmb->attrs = mb->attrs;
1749         rmb->iattrs = mb->iattrs;
1750         rmb->call_conv = mb->call_conv;
1751         rmb->code = mb->code;
1752         rmb->type = mb->type;
1753         rmb->name = mb->name;
1754         rmb->table_idx = &mb->table_idx;
1755         rmb->init_locals = mb->init_locals;
1756         rmb->skip_visibility = FALSE;
1757         rmb->return_modreq = mb->return_modreq;
1758         rmb->return_modopt = mb->return_modopt;
1759         rmb->param_modreq = mb->param_modreq;
1760         rmb->param_modopt = mb->param_modopt;
1761         rmb->permissions = mb->permissions;
1762         rmb->mhandle = mb->mhandle;
1763         rmb->nrefs = 0;
1764         rmb->refs = NULL;
1765
1766         if (mb->dll) {
1767                 rmb->charset = mb->charset;
1768                 rmb->extra_flags = mb->extra_flags;
1769                 rmb->native_cc = mb->native_cc;
1770                 rmb->dllentry = mb->dllentry;
1771                 rmb->dll = mb->dll;
1772         }
1773
1774         return TRUE;
1775 }
1776
1777 static gboolean
1778 reflection_methodbuilder_from_ctor_builder (ReflectionMethodBuilder *rmb, MonoReflectionCtorBuilder *mb, MonoError *error)
1779 {
1780         MONO_REQ_GC_UNSAFE_MODE;
1781
1782         const char *name = mb->attrs & METHOD_ATTRIBUTE_STATIC ? ".cctor": ".ctor";
1783
1784         mono_error_init (error);
1785
1786         memset (rmb, 0, sizeof (ReflectionMethodBuilder));
1787
1788         rmb->ilgen = mb->ilgen;
1789         rmb->rtype = mono_type_get_object_checked (mono_domain_get (), &mono_defaults.void_class->byval_arg, error);
1790         return_val_if_nok (error, FALSE);
1791         rmb->parameters = mb->parameters;
1792         rmb->generic_params = NULL;
1793         rmb->generic_container = NULL;
1794         rmb->opt_types = NULL;
1795         rmb->pinfo = mb->pinfo;
1796         rmb->attrs = mb->attrs;
1797         rmb->iattrs = mb->iattrs;
1798         rmb->call_conv = mb->call_conv;
1799         rmb->code = NULL;
1800         rmb->type = mb->type;
1801         rmb->name = mono_string_new (mono_domain_get (), name);
1802         rmb->table_idx = &mb->table_idx;
1803         rmb->init_locals = mb->init_locals;
1804         rmb->skip_visibility = FALSE;
1805         rmb->return_modreq = NULL;
1806         rmb->return_modopt = NULL;
1807         rmb->param_modreq = mb->param_modreq;
1808         rmb->param_modopt = mb->param_modopt;
1809         rmb->permissions = mb->permissions;
1810         rmb->mhandle = mb->mhandle;
1811         rmb->nrefs = 0;
1812         rmb->refs = NULL;
1813
1814         return TRUE;
1815 }
1816
1817 static void
1818 reflection_methodbuilder_from_dynamic_method (ReflectionMethodBuilder *rmb, MonoReflectionDynamicMethod *mb)
1819 {
1820         MONO_REQ_GC_UNSAFE_MODE;
1821
1822         memset (rmb, 0, sizeof (ReflectionMethodBuilder));
1823
1824         rmb->ilgen = mb->ilgen;
1825         rmb->rtype = mb->rtype;
1826         rmb->parameters = mb->parameters;
1827         rmb->generic_params = NULL;
1828         rmb->generic_container = NULL;
1829         rmb->opt_types = NULL;
1830         rmb->pinfo = NULL;
1831         rmb->attrs = mb->attrs;
1832         rmb->iattrs = 0;
1833         rmb->call_conv = mb->call_conv;
1834         rmb->code = NULL;
1835         rmb->type = (MonoObject *) mb->owner;
1836         rmb->name = mb->name;
1837         rmb->table_idx = NULL;
1838         rmb->init_locals = mb->init_locals;
1839         rmb->skip_visibility = mb->skip_visibility;
1840         rmb->return_modreq = NULL;
1841         rmb->return_modopt = NULL;
1842         rmb->param_modreq = NULL;
1843         rmb->param_modopt = NULL;
1844         rmb->permissions = NULL;
1845         rmb->mhandle = mb->mhandle;
1846         rmb->nrefs = 0;
1847         rmb->refs = NULL;
1848 }
1849 #endif
1850
1851 static gboolean
1852 mono_image_add_methodimpl (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, MonoError *error)
1853 {
1854         MONO_REQ_GC_UNSAFE_MODE;
1855
1856         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mb->type;
1857         MonoDynamicTable *table;
1858         guint32 *values;
1859         guint32 tok;
1860         MonoReflectionMethod *m;
1861         int i;
1862
1863         mono_error_init (error);
1864
1865         if (!mb->override_methods)
1866                 return TRUE;
1867
1868         for (i = 0; i < mono_array_length (mb->override_methods); ++i) {
1869                 m = mono_array_get (mb->override_methods, MonoReflectionMethod*, i);
1870
1871                 table = &assembly->tables [MONO_TABLE_METHODIMPL];
1872                 table->rows ++;
1873                 alloc_table (table, table->rows);
1874                 values = table->values + table->rows * MONO_METHODIMPL_SIZE;
1875                 values [MONO_METHODIMPL_CLASS] = tb->table_idx;
1876                 values [MONO_METHODIMPL_BODY] = MONO_METHODDEFORREF_METHODDEF | (mb->table_idx << MONO_METHODDEFORREF_BITS);
1877
1878                 tok = mono_image_create_token (assembly, (MonoObject*)m, FALSE, FALSE, error);
1879                 return_val_if_nok (error, FALSE);
1880
1881                 switch (mono_metadata_token_table (tok)) {
1882                 case MONO_TABLE_MEMBERREF:
1883                         tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODREF;
1884                         break;
1885                 case MONO_TABLE_METHOD:
1886                         tok = (mono_metadata_token_index (tok) << MONO_METHODDEFORREF_BITS ) | MONO_METHODDEFORREF_METHODDEF;
1887                         break;
1888                 default:
1889                         g_assert_not_reached ();
1890                 }
1891                 values [MONO_METHODIMPL_DECLARATION] = tok;
1892         }
1893
1894         return TRUE;
1895 }
1896
1897 #ifndef DISABLE_REFLECTION_EMIT
1898 static gboolean
1899 mono_image_get_method_info (MonoReflectionMethodBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
1900 {
1901         MONO_REQ_GC_UNSAFE_MODE;
1902
1903         MonoDynamicTable *table;
1904         guint32 *values;
1905         ReflectionMethodBuilder rmb;
1906         int i;
1907
1908         mono_error_init (error);
1909
1910         if (!reflection_methodbuilder_from_method_builder (&rmb, mb, error) ||
1911             !mono_image_basic_method (&rmb, assembly, error))
1912                 return FALSE;
1913
1914         mb->table_idx = *rmb.table_idx;
1915
1916         if (mb->dll) { /* It's a P/Invoke method */
1917                 guint32 moduleref;
1918                 /* map CharSet values to on-disk values */
1919                 int ncharset = (mb->charset ? (mb->charset - 1) * 2 : 0);
1920                 int extra_flags = mb->extra_flags;
1921                 table = &assembly->tables [MONO_TABLE_IMPLMAP];
1922                 table->rows ++;
1923                 alloc_table (table, table->rows);
1924                 values = table->values + table->rows * MONO_IMPLMAP_SIZE;
1925
1926                 values [MONO_IMPLMAP_FLAGS] = (mb->native_cc << 8) | ncharset | extra_flags;
1927                 values [MONO_IMPLMAP_MEMBER] = (mb->table_idx << 1) | 1; /* memberforwarded: method */
1928                 if (mb->dllentry)
1929                         values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->dllentry);
1930                 else
1931                         values [MONO_IMPLMAP_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->name);
1932                 moduleref = string_heap_insert_mstring (&assembly->sheap, mb->dll);
1933                 if (!(values [MONO_IMPLMAP_SCOPE] = find_index_in_table (assembly, MONO_TABLE_MODULEREF, MONO_MODULEREF_NAME, moduleref))) {
1934                         table = &assembly->tables [MONO_TABLE_MODULEREF];
1935                         table->rows ++;
1936                         alloc_table (table, table->rows);
1937                         table->values [table->rows * MONO_MODULEREF_SIZE + MONO_MODULEREF_NAME] = moduleref;
1938                         values [MONO_IMPLMAP_SCOPE] = table->rows;
1939                 }
1940         }
1941
1942         if (mb->generic_params) {
1943                 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
1944                 table->rows += mono_array_length (mb->generic_params);
1945                 alloc_table (table, table->rows);
1946                 for (i = 0; i < mono_array_length (mb->generic_params); ++i) {
1947                         guint32 owner = MONO_TYPEORMETHOD_METHOD | (mb->table_idx << MONO_TYPEORMETHOD_BITS);
1948
1949                         mono_image_get_generic_param_info (
1950                                 (MonoReflectionGenericParam *)mono_array_get (mb->generic_params, gpointer, i), owner, assembly);
1951                 }
1952         }
1953
1954         return TRUE;
1955 }
1956
1957 static gboolean
1958 mono_image_get_ctor_info (MonoDomain *domain, MonoReflectionCtorBuilder *mb, MonoDynamicImage *assembly, MonoError *error)
1959 {
1960         MONO_REQ_GC_UNSAFE_MODE;
1961
1962         ReflectionMethodBuilder rmb;
1963
1964         if (!reflection_methodbuilder_from_ctor_builder (&rmb, mb, error))
1965                 return FALSE;
1966
1967         if (!mono_image_basic_method (&rmb, assembly, error))
1968                 return FALSE;
1969
1970         mb->table_idx = *rmb.table_idx;
1971
1972         return TRUE;
1973 }
1974 #endif
1975
1976 static char*
1977 type_get_fully_qualified_name (MonoType *type)
1978 {
1979         MONO_REQ_GC_NEUTRAL_MODE;
1980
1981         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
1982 }
1983
1984 static char*
1985 type_get_qualified_name (MonoType *type, MonoAssembly *ass)
1986 {
1987         MONO_REQ_GC_UNSAFE_MODE;
1988
1989         MonoClass *klass;
1990         MonoAssembly *ta;
1991
1992         klass = mono_class_from_mono_type (type);
1993         if (!klass)
1994                 return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_REFLECTION);
1995         ta = klass->image->assembly;
1996         if (assembly_is_dynamic (ta) || (ta == ass)) {
1997                 if (klass->generic_class || klass->generic_container)
1998                         /* For generic type definitions, we want T, while REFLECTION returns T<K> */
1999                         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_FULL_NAME);
2000                 else
2001                         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_REFLECTION);
2002         }
2003
2004         return mono_type_get_name_full (type, MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED);
2005 }
2006
2007 #ifndef DISABLE_REFLECTION_EMIT
2008 /*field_image is the image to which the eventual custom mods have been encoded against*/
2009 static guint32
2010 fieldref_encode_signature (MonoDynamicImage *assembly, MonoImage *field_image, MonoType *type)
2011 {
2012         MONO_REQ_GC_NEUTRAL_MODE;
2013
2014         SigBuffer buf;
2015         guint32 idx, i, token;
2016
2017         if (!assembly->save)
2018                 return 0;
2019
2020         sigbuffer_init (&buf, 32);
2021
2022         sigbuffer_add_value (&buf, 0x06);
2023         /* encode custom attributes before the type */
2024         if (type->num_mods) {
2025                 for (i = 0; i < type->num_mods; ++i) {
2026                         if (field_image) {
2027                                 MonoError error;
2028                                 MonoClass *klass = mono_class_get_checked (field_image, type->modifiers [i].token, &error);
2029                                 g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
2030
2031                                 token = mono_image_typedef_or_ref (assembly, &klass->byval_arg);
2032                         } else {
2033                                 token = type->modifiers [i].token;
2034                         }
2035
2036                         if (type->modifiers [i].required)
2037                                 sigbuffer_add_byte (&buf, MONO_TYPE_CMOD_REQD);
2038                         else
2039                                 sigbuffer_add_byte (&buf, MONO_TYPE_CMOD_OPT);
2040
2041                         sigbuffer_add_value (&buf, token);
2042                 }
2043         }
2044         encode_type (assembly, type, &buf);
2045         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
2046         sigbuffer_free (&buf);
2047         return idx;
2048 }
2049 #endif
2050
2051 static guint32
2052 field_encode_signature (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb, MonoError *error)
2053 {
2054         MONO_REQ_GC_UNSAFE_MODE;
2055
2056         mono_error_init (error);
2057
2058         SigBuffer buf;
2059         guint32 idx;
2060         guint32 typespec = 0;
2061         MonoType *type;
2062         MonoClass *klass;
2063
2064         init_type_builder_generics (fb->type);
2065
2066         type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
2067         return_val_if_nok (error, 0);
2068         klass = mono_class_from_mono_type (type);
2069
2070         sigbuffer_init (&buf, 32);
2071
2072         sigbuffer_add_value (&buf, 0x06);
2073         encode_custom_modifiers (assembly, fb->modreq, fb->modopt, &buf, error);
2074         if (!is_ok (error))
2075                 goto fail;
2076         /* encode custom attributes before the type */
2077
2078         if (klass->generic_container)
2079                 typespec = create_typespec (assembly, type);
2080
2081         if (typespec) {
2082                 MonoGenericClass *gclass;
2083                 gclass = mono_metadata_lookup_generic_class (klass, klass->generic_container->context.class_inst, TRUE);
2084                 encode_generic_class (assembly, gclass, &buf);
2085         } else {
2086                 encode_type (assembly, type, &buf);
2087         }
2088         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
2089         sigbuffer_free (&buf);
2090         return idx;
2091 fail:
2092         sigbuffer_free (&buf);
2093         return 0;
2094 }
2095
2096 static guint32
2097 encode_constant (MonoDynamicImage *assembly, MonoObject *val, MonoTypeEnum *ret_type)
2098 {
2099         MONO_REQ_GC_UNSAFE_MODE;
2100
2101         char blob_size [64];
2102         char *b = blob_size;
2103         char *box_val;
2104         char* buf;
2105         guint32 idx = 0, len = 0, dummy = 0;
2106
2107         buf = (char *)g_malloc (64);
2108         if (!val) {
2109                 *ret_type = MONO_TYPE_CLASS;
2110                 len = 4;
2111                 box_val = (char*)&dummy;
2112         } else {
2113                 box_val = ((char*)val) + sizeof (MonoObject);
2114                 *ret_type = val->vtable->klass->byval_arg.type;
2115         }
2116 handle_enum:
2117         switch (*ret_type) {
2118         case MONO_TYPE_BOOLEAN:
2119         case MONO_TYPE_U1:
2120         case MONO_TYPE_I1:
2121                 len = 1;
2122                 break;
2123         case MONO_TYPE_CHAR:
2124         case MONO_TYPE_U2:
2125         case MONO_TYPE_I2:
2126                 len = 2;
2127                 break;
2128         case MONO_TYPE_U4:
2129         case MONO_TYPE_I4:
2130         case MONO_TYPE_R4:
2131                 len = 4;
2132                 break;
2133         case MONO_TYPE_U8:
2134         case MONO_TYPE_I8:
2135                 len = 8;
2136                 break;
2137         case MONO_TYPE_R8:
2138                 len = 8;
2139                 break;
2140         case MONO_TYPE_VALUETYPE: {
2141                 MonoClass *klass = val->vtable->klass;
2142
2143                 if (klass->enumtype) {
2144                         *ret_type = mono_class_enum_basetype (klass)->type;
2145                         goto handle_enum;
2146                 } else if (mono_is_corlib_image (klass->image) && strcmp (klass->name_space, "System") == 0 && strcmp (klass->name, "DateTime") == 0) {
2147                         len = 8;
2148                 } else
2149                         g_error ("we can't encode valuetypes, we should have never reached this line");
2150                 break;
2151         }
2152         case MONO_TYPE_CLASS:
2153                 break;
2154         case MONO_TYPE_STRING: {
2155                 MonoString *str = (MonoString*)val;
2156                 /* there is no signature */
2157                 len = str->length * 2;
2158                 mono_metadata_encode_value (len, b, &b);
2159 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
2160                 {
2161                         char *swapped = g_malloc (2 * mono_string_length (str));
2162                         const char *p = (const char*)mono_string_chars (str);
2163
2164                         swap_with_size (swapped, p, 2, mono_string_length (str));
2165                         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, swapped, len);
2166                         g_free (swapped);
2167                 }
2168 #else
2169                 idx = add_to_blob_cached (assembly, blob_size, b-blob_size, (char*)mono_string_chars (str), len);
2170 #endif
2171
2172                 g_free (buf);
2173                 return idx;
2174         }
2175         case MONO_TYPE_GENERICINST:
2176                 *ret_type = val->vtable->klass->generic_class->container_class->byval_arg.type;
2177                 goto handle_enum;
2178         default:
2179                 g_error ("we don't encode constant type 0x%02x yet", *ret_type);
2180         }
2181
2182         /* there is no signature */
2183         mono_metadata_encode_value (len, b, &b);
2184 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
2185         idx = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
2186         swap_with_size (blob_size, box_val, len, 1);
2187         mono_image_add_stream_data (&assembly->blob, blob_size, len);
2188 #else
2189         idx = add_to_blob_cached (assembly, blob_size, b-blob_size, box_val, len);
2190 #endif
2191
2192         g_free (buf);
2193         return idx;
2194 }
2195
2196 static guint32
2197 encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo, MonoError *error)
2198 {
2199         MONO_REQ_GC_UNSAFE_MODE;
2200
2201         mono_error_init (error);
2202
2203         char *str;
2204         SigBuffer buf;
2205         guint32 idx, len;
2206
2207         sigbuffer_init (&buf, 32);
2208
2209         sigbuffer_add_value (&buf, minfo->type);
2210
2211         switch (minfo->type) {
2212         case MONO_NATIVE_BYVALTSTR:
2213         case MONO_NATIVE_BYVALARRAY:
2214                 sigbuffer_add_value (&buf, minfo->count);
2215                 break;
2216         case MONO_NATIVE_LPARRAY:
2217                 if (minfo->eltype || minfo->has_size) {
2218                         sigbuffer_add_value (&buf, minfo->eltype);
2219                         if (minfo->has_size) {
2220                                 sigbuffer_add_value (&buf, minfo->param_num != -1? minfo->param_num: 0);
2221                                 sigbuffer_add_value (&buf, minfo->count != -1? minfo->count: 0);
2222
2223                                 /* LAMESPEC: ElemMult is undocumented */
2224                                 sigbuffer_add_value (&buf, minfo->param_num != -1? 1: 0);
2225                         }
2226                 }
2227                 break;
2228         case MONO_NATIVE_SAFEARRAY:
2229                 if (minfo->eltype)
2230                         sigbuffer_add_value (&buf, minfo->eltype);
2231                 break;
2232         case MONO_NATIVE_CUSTOM:
2233                 if (minfo->guid) {
2234                         str = mono_string_to_utf8 (minfo->guid);
2235                         len = strlen (str);
2236                         sigbuffer_add_value (&buf, len);
2237                         sigbuffer_add_mem (&buf, str, len);
2238                         g_free (str);
2239                 } else {
2240                         sigbuffer_add_value (&buf, 0);
2241                 }
2242                 /* native type name */
2243                 sigbuffer_add_value (&buf, 0);
2244                 /* custom marshaler type name */
2245                 if (minfo->marshaltype || minfo->marshaltyperef) {
2246                         if (minfo->marshaltyperef) {
2247                                 MonoType *marshaltype = mono_reflection_type_get_handle ((MonoReflectionType*)minfo->marshaltyperef, error);
2248                                 if (!is_ok (error)) {
2249                                         sigbuffer_free (&buf);
2250                                         return 0;
2251                                 }
2252                                 str = type_get_fully_qualified_name (marshaltype);
2253                         } else
2254                                 str = mono_string_to_utf8 (minfo->marshaltype);
2255                         len = strlen (str);
2256                         sigbuffer_add_value (&buf, len);
2257                         sigbuffer_add_mem (&buf, str, len);
2258                         g_free (str);
2259                 } else {
2260                         /* FIXME: Actually a bug, since this field is required.  Punting for now ... */
2261                         sigbuffer_add_value (&buf, 0);
2262                 }
2263                 if (minfo->mcookie) {
2264                         str = mono_string_to_utf8 (minfo->mcookie);
2265                         len = strlen (str);
2266                         sigbuffer_add_value (&buf, len);
2267                         sigbuffer_add_mem (&buf, str, len);
2268                         g_free (str);
2269                 } else {
2270                         sigbuffer_add_value (&buf, 0);
2271                 }
2272                 break;
2273         default:
2274                 break;
2275         }
2276         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
2277         sigbuffer_free (&buf);
2278         return idx;
2279 }
2280
2281 static void
2282 mono_image_get_field_info (MonoReflectionFieldBuilder *fb, MonoDynamicImage *assembly, MonoError *error)
2283 {
2284         MONO_REQ_GC_UNSAFE_MODE;
2285
2286         mono_error_init (error);
2287
2288         MonoDynamicTable *table;
2289         guint32 *values;
2290
2291         /* maybe this fixup should be done in the C# code */
2292         if (fb->attrs & FIELD_ATTRIBUTE_LITERAL)
2293                 fb->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
2294         table = &assembly->tables [MONO_TABLE_FIELD];
2295         fb->table_idx = table->next_idx ++;
2296         g_hash_table_insert (assembly->field_to_table_idx, fb->handle, GUINT_TO_POINTER (fb->table_idx));
2297         values = table->values + fb->table_idx * MONO_FIELD_SIZE;
2298         values [MONO_FIELD_NAME] = string_heap_insert_mstring (&assembly->sheap, fb->name);
2299         values [MONO_FIELD_FLAGS] = fb->attrs;
2300         values [MONO_FIELD_SIGNATURE] = field_encode_signature (assembly, fb, error);
2301         return_if_nok (error);
2302
2303
2304         if (fb->offset != -1) {
2305                 table = &assembly->tables [MONO_TABLE_FIELDLAYOUT];
2306                 table->rows ++;
2307                 alloc_table (table, table->rows);
2308                 values = table->values + table->rows * MONO_FIELD_LAYOUT_SIZE;
2309                 values [MONO_FIELD_LAYOUT_FIELD] = fb->table_idx;
2310                 values [MONO_FIELD_LAYOUT_OFFSET] = fb->offset;
2311         }
2312         if (fb->attrs & FIELD_ATTRIBUTE_LITERAL) {
2313                 MonoTypeEnum field_type = (MonoTypeEnum)0;
2314                 table = &assembly->tables [MONO_TABLE_CONSTANT];
2315                 table->rows ++;
2316                 alloc_table (table, table->rows);
2317                 values = table->values + table->rows * MONO_CONSTANT_SIZE;
2318                 values [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_FIEDDEF | (fb->table_idx << MONO_HASCONSTANT_BITS);
2319                 values [MONO_CONSTANT_VALUE] = encode_constant (assembly, fb->def_value, &field_type);
2320                 values [MONO_CONSTANT_TYPE] = field_type;
2321                 values [MONO_CONSTANT_PADDING] = 0;
2322         }
2323         if (fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) {
2324                 guint32 rva_idx;
2325                 table = &assembly->tables [MONO_TABLE_FIELDRVA];
2326                 table->rows ++;
2327                 alloc_table (table, table->rows);
2328                 values = table->values + table->rows * MONO_FIELD_RVA_SIZE;
2329                 values [MONO_FIELD_RVA_FIELD] = fb->table_idx;
2330                 /*
2331                  * We store it in the code section because it's simpler for now.
2332                  */
2333                 if (fb->rva_data) {
2334                         if (mono_array_length (fb->rva_data) >= 10)
2335                                 stream_data_align (&assembly->code);
2336                         rva_idx = mono_image_add_stream_data (&assembly->code, mono_array_addr (fb->rva_data, char, 0), mono_array_length (fb->rva_data));
2337                 } else
2338                         rva_idx = mono_image_add_stream_zero (&assembly->code, mono_class_value_size (fb->handle->parent, NULL));
2339                 values [MONO_FIELD_RVA_RVA] = rva_idx + assembly->text_rva;
2340         }
2341         if (fb->marshal_info) {
2342                 table = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
2343                 table->rows ++;
2344                 alloc_table (table, table->rows);
2345                 values = table->values + table->rows * MONO_FIELD_MARSHAL_SIZE;
2346                 values [MONO_FIELD_MARSHAL_PARENT] = (fb->table_idx << MONO_HAS_FIELD_MARSHAL_BITS) | MONO_HAS_FIELD_MARSHAL_FIELDSREF;
2347                 values [MONO_FIELD_MARSHAL_NATIVE_TYPE] = encode_marshal_blob (assembly, fb->marshal_info, error);
2348                 return_if_nok (error);
2349         }
2350 }
2351
2352 static guint32
2353 property_encode_signature (MonoDynamicImage *assembly, MonoReflectionPropertyBuilder *fb, MonoError *error)
2354 {
2355         MONO_REQ_GC_UNSAFE_MODE;
2356
2357         mono_error_init (error);
2358
2359         SigBuffer buf;
2360         guint32 nparams = 0;
2361         MonoReflectionMethodBuilder *mb = fb->get_method;
2362         MonoReflectionMethodBuilder *smb = fb->set_method;
2363         guint32 idx, i;
2364
2365         if (mb && mb->parameters)
2366                 nparams = mono_array_length (mb->parameters);
2367         if (!mb && smb && smb->parameters)
2368                 nparams = mono_array_length (smb->parameters) - 1;
2369         sigbuffer_init (&buf, 32);
2370         if (fb->call_conv & 0x20)
2371                 sigbuffer_add_byte (&buf, 0x28);
2372         else
2373                 sigbuffer_add_byte (&buf, 0x08);
2374         sigbuffer_add_value (&buf, nparams);
2375         if (mb) {
2376                 encode_reflection_type (assembly, (MonoReflectionType*)mb->rtype, &buf, error);
2377                 if (!is_ok (error))
2378                         goto fail;
2379                 for (i = 0; i < nparams; ++i) {
2380                         MonoReflectionType *pt = mono_array_get (mb->parameters, MonoReflectionType*, i);
2381                         encode_reflection_type (assembly, pt, &buf, error);
2382                         if (!is_ok (error))
2383                                 goto fail;
2384                 }
2385         } else if (smb && smb->parameters) {
2386                 /* the property type is the last param */
2387                 encode_reflection_type (assembly, mono_array_get (smb->parameters, MonoReflectionType*, nparams), &buf, error);
2388                 if (!is_ok (error))
2389                         goto fail;
2390
2391                 for (i = 0; i < nparams; ++i) {
2392                         MonoReflectionType *pt = mono_array_get (smb->parameters, MonoReflectionType*, i);
2393                         encode_reflection_type (assembly, pt, &buf, error);
2394                         if (!is_ok (error))
2395                                 goto fail;
2396                 }
2397         } else {
2398                 encode_reflection_type (assembly, (MonoReflectionType*)fb->type, &buf, error);
2399                 if (!is_ok (error))
2400                         goto fail;
2401         }
2402
2403         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
2404         sigbuffer_free (&buf);
2405         return idx;
2406 fail:
2407         sigbuffer_free (&buf);
2408         return 0;
2409 }
2410
2411 static void
2412 mono_image_get_property_info (MonoReflectionPropertyBuilder *pb, MonoDynamicImage *assembly, MonoError *error)
2413 {
2414         MONO_REQ_GC_UNSAFE_MODE;
2415
2416         mono_error_init (error);
2417
2418         MonoDynamicTable *table;
2419         guint32 *values;
2420         guint num_methods = 0;
2421         guint32 semaidx;
2422
2423         /*
2424          * we need to set things in the following tables:
2425          * PROPERTYMAP (info already filled in _get_type_info ())
2426          * PROPERTY    (rows already preallocated in _get_type_info ())
2427          * METHOD      (method info already done with the generic method code)
2428          * METHODSEMANTICS
2429          * CONSTANT
2430          */
2431         table = &assembly->tables [MONO_TABLE_PROPERTY];
2432         pb->table_idx = table->next_idx ++;
2433         values = table->values + pb->table_idx * MONO_PROPERTY_SIZE;
2434         values [MONO_PROPERTY_NAME] = string_heap_insert_mstring (&assembly->sheap, pb->name);
2435         values [MONO_PROPERTY_FLAGS] = pb->attrs;
2436         values [MONO_PROPERTY_TYPE] = property_encode_signature (assembly, pb, error);
2437         return_if_nok (error);
2438
2439
2440         /* FIXME: we still don't handle 'other' methods */
2441         if (pb->get_method) num_methods ++;
2442         if (pb->set_method) num_methods ++;
2443
2444         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
2445         table->rows += num_methods;
2446         alloc_table (table, table->rows);
2447
2448         if (pb->get_method) {
2449                 semaidx = table->next_idx ++;
2450                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
2451                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_GETTER;
2452                 values [MONO_METHOD_SEMA_METHOD] = pb->get_method->table_idx;
2453                 values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
2454         }
2455         if (pb->set_method) {
2456                 semaidx = table->next_idx ++;
2457                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
2458                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_SETTER;
2459                 values [MONO_METHOD_SEMA_METHOD] = pb->set_method->table_idx;
2460                 values [MONO_METHOD_SEMA_ASSOCIATION] = (pb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_PROPERTY;
2461         }
2462         if (pb->attrs & PROPERTY_ATTRIBUTE_HAS_DEFAULT) {
2463                 MonoTypeEnum field_type = (MonoTypeEnum)0;
2464                 table = &assembly->tables [MONO_TABLE_CONSTANT];
2465                 table->rows ++;
2466                 alloc_table (table, table->rows);
2467                 values = table->values + table->rows * MONO_CONSTANT_SIZE;
2468                 values [MONO_CONSTANT_PARENT] = MONO_HASCONSTANT_PROPERTY | (pb->table_idx << MONO_HASCONSTANT_BITS);
2469                 values [MONO_CONSTANT_VALUE] = encode_constant (assembly, pb->def_value, &field_type);
2470                 values [MONO_CONSTANT_TYPE] = field_type;
2471                 values [MONO_CONSTANT_PADDING] = 0;
2472         }
2473 }
2474
2475 static void
2476 mono_image_get_event_info (MonoReflectionEventBuilder *eb, MonoDynamicImage *assembly, MonoError *error)
2477 {
2478         MONO_REQ_GC_UNSAFE_MODE;
2479
2480         MonoDynamicTable *table;
2481         guint32 *values;
2482         guint num_methods = 0;
2483         guint32 semaidx;
2484
2485         /*
2486          * we need to set things in the following tables:
2487          * EVENTMAP (info already filled in _get_type_info ())
2488          * EVENT    (rows already preallocated in _get_type_info ())
2489          * METHOD      (method info already done with the generic method code)
2490          * METHODSEMANTICS
2491          */
2492         table = &assembly->tables [MONO_TABLE_EVENT];
2493         eb->table_idx = table->next_idx ++;
2494         values = table->values + eb->table_idx * MONO_EVENT_SIZE;
2495         values [MONO_EVENT_NAME] = string_heap_insert_mstring (&assembly->sheap, eb->name);
2496         values [MONO_EVENT_FLAGS] = eb->attrs;
2497         MonoType *ebtype = mono_reflection_type_get_handle (eb->type, error);
2498         return_if_nok (error);
2499         values [MONO_EVENT_TYPE] = mono_image_typedef_or_ref (assembly, ebtype);
2500
2501         /*
2502          * FIXME: we still don't handle 'other' methods
2503          */
2504         if (eb->add_method) num_methods ++;
2505         if (eb->remove_method) num_methods ++;
2506         if (eb->raise_method) num_methods ++;
2507
2508         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
2509         table->rows += num_methods;
2510         alloc_table (table, table->rows);
2511
2512         if (eb->add_method) {
2513                 semaidx = table->next_idx ++;
2514                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
2515                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_ADD_ON;
2516                 values [MONO_METHOD_SEMA_METHOD] = eb->add_method->table_idx;
2517                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
2518         }
2519         if (eb->remove_method) {
2520                 semaidx = table->next_idx ++;
2521                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
2522                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_REMOVE_ON;
2523                 values [MONO_METHOD_SEMA_METHOD] = eb->remove_method->table_idx;
2524                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
2525         }
2526         if (eb->raise_method) {
2527                 semaidx = table->next_idx ++;
2528                 values = table->values + semaidx * MONO_METHOD_SEMA_SIZE;
2529                 values [MONO_METHOD_SEMA_SEMANTICS] = METHOD_SEMANTIC_FIRE;
2530                 values [MONO_METHOD_SEMA_METHOD] = eb->raise_method->table_idx;
2531                 values [MONO_METHOD_SEMA_ASSOCIATION] = (eb->table_idx << MONO_HAS_SEMANTICS_BITS) | MONO_HAS_SEMANTICS_EVENT;
2532         }
2533 }
2534
2535 static void
2536 encode_constraints (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly, MonoError *error)
2537 {
2538         MONO_REQ_GC_UNSAFE_MODE;
2539
2540         mono_error_init (error);
2541
2542         MonoDynamicTable *table;
2543         guint32 num_constraints, i;
2544         guint32 *values;
2545         guint32 table_idx;
2546
2547         table = &assembly->tables [MONO_TABLE_GENERICPARAMCONSTRAINT];
2548         num_constraints = gparam->iface_constraints ?
2549                 mono_array_length (gparam->iface_constraints) : 0;
2550         table->rows += num_constraints;
2551         if (gparam->base_type)
2552                 table->rows++;
2553         alloc_table (table, table->rows);
2554
2555         if (gparam->base_type) {
2556                 table_idx = table->next_idx ++;
2557                 values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE;
2558
2559                 MonoType *gpbasetype = mono_reflection_type_get_handle (gparam->base_type, error);
2560                 return_if_nok (error);
2561                 values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner;
2562                 values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (assembly, gpbasetype);
2563         }
2564
2565         for (i = 0; i < num_constraints; i++) {
2566                 MonoReflectionType *constraint = (MonoReflectionType *)mono_array_get (
2567                         gparam->iface_constraints, gpointer, i);
2568
2569                 table_idx = table->next_idx ++;
2570                 values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE;
2571
2572                 MonoType *constraint_type = mono_reflection_type_get_handle (constraint, error);
2573                 return_if_nok (error);
2574
2575                 values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner;
2576                 values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (assembly, constraint_type);
2577         }
2578 }
2579
2580 static void
2581 mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly)
2582 {
2583         MONO_REQ_GC_UNSAFE_MODE;
2584
2585         GenericParamTableEntry *entry;
2586
2587         /*
2588          * The GenericParam table must be sorted according to the `owner' field.
2589          * We need to do this sorting prior to writing the GenericParamConstraint
2590          * table, since we have to use the final GenericParam table indices there
2591          * and they must also be sorted.
2592          */
2593
2594         entry = g_new0 (GenericParamTableEntry, 1);
2595         entry->owner = owner;
2596         /* FIXME: track where gen_params should be freed and remove the GC root as well */
2597         MONO_GC_REGISTER_ROOT_IF_MOVING (entry->gparam, MONO_ROOT_SOURCE_REFLECTION, "reflection generic parameter");
2598         entry->gparam = gparam;
2599
2600         g_ptr_array_add (assembly->gen_params, entry);
2601 }
2602
2603 static gboolean
2604 write_generic_param_entry (MonoDynamicImage *assembly, GenericParamTableEntry *entry, MonoError *error)
2605 {
2606         MONO_REQ_GC_UNSAFE_MODE;
2607
2608         MonoDynamicTable *table;
2609         MonoGenericParam *param;
2610         guint32 *values;
2611         guint32 table_idx;
2612
2613         mono_error_init (error);
2614
2615         table = &assembly->tables [MONO_TABLE_GENERICPARAM];
2616         table_idx = table->next_idx ++;
2617         values = table->values + table_idx * MONO_GENERICPARAM_SIZE;
2618
2619         MonoType *gparam_type = mono_reflection_type_get_handle ((MonoReflectionType*)entry->gparam, error);
2620         return_val_if_nok (error, FALSE);
2621
2622         param = gparam_type->data.generic_param;
2623
2624         values [MONO_GENERICPARAM_OWNER] = entry->owner;
2625         values [MONO_GENERICPARAM_FLAGS] = entry->gparam->attrs;
2626         values [MONO_GENERICPARAM_NUMBER] = mono_generic_param_num (param);
2627         values [MONO_GENERICPARAM_NAME] = string_heap_insert (&assembly->sheap, mono_generic_param_info (param)->name);
2628
2629         if (!mono_image_add_cattrs (assembly, table_idx, MONO_CUSTOM_ATTR_GENERICPAR, entry->gparam->cattrs, error))
2630                 return FALSE;
2631
2632         encode_constraints (entry->gparam, table_idx, assembly, error);
2633         return_val_if_nok (error, FALSE);
2634
2635         return TRUE;
2636 }
2637
2638 static guint32
2639 resolution_scope_from_image (MonoDynamicImage *assembly, MonoImage *image)
2640 {
2641         MONO_REQ_GC_UNSAFE_MODE;
2642
2643         MonoDynamicTable *table;
2644         guint32 token;
2645         guint32 *values;
2646         guint32 cols [MONO_ASSEMBLY_SIZE];
2647         const char *pubkey;
2648         guint32 publen;
2649
2650         if ((token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, image))))
2651                 return token;
2652
2653         if (assembly_is_dynamic (image->assembly) && (image->assembly == assembly->image.assembly)) {
2654                 table = &assembly->tables [MONO_TABLE_MODULEREF];
2655                 token = table->next_idx ++;
2656                 table->rows ++;
2657                 alloc_table (table, table->rows);
2658                 values = table->values + token * MONO_MODULEREF_SIZE;
2659                 values [MONO_MODULEREF_NAME] = string_heap_insert (&assembly->sheap, image->module_name);
2660
2661                 token <<= MONO_RESOLUTION_SCOPE_BITS;
2662                 token |= MONO_RESOLUTION_SCOPE_MODULEREF;
2663                 g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
2664
2665                 return token;
2666         }
2667
2668         if (assembly_is_dynamic (image->assembly))
2669                 /* FIXME: */
2670                 memset (cols, 0, sizeof (cols));
2671         else {
2672                 /* image->assembly->image is the manifest module */
2673                 image = image->assembly->image;
2674                 mono_metadata_decode_row (&image->tables [MONO_TABLE_ASSEMBLY], 0, cols, MONO_ASSEMBLY_SIZE);
2675         }
2676
2677         table = &assembly->tables [MONO_TABLE_ASSEMBLYREF];
2678         token = table->next_idx ++;
2679         table->rows ++;
2680         alloc_table (table, table->rows);
2681         values = table->values + token * MONO_ASSEMBLYREF_SIZE;
2682         values [MONO_ASSEMBLYREF_NAME] = string_heap_insert (&assembly->sheap, image->assembly_name);
2683         values [MONO_ASSEMBLYREF_MAJOR_VERSION] = cols [MONO_ASSEMBLY_MAJOR_VERSION];
2684         values [MONO_ASSEMBLYREF_MINOR_VERSION] = cols [MONO_ASSEMBLY_MINOR_VERSION];
2685         values [MONO_ASSEMBLYREF_BUILD_NUMBER] = cols [MONO_ASSEMBLY_BUILD_NUMBER];
2686         values [MONO_ASSEMBLYREF_REV_NUMBER] = cols [MONO_ASSEMBLY_REV_NUMBER];
2687         values [MONO_ASSEMBLYREF_FLAGS] = 0;
2688         values [MONO_ASSEMBLYREF_CULTURE] = 0;
2689         values [MONO_ASSEMBLYREF_HASH_VALUE] = 0;
2690
2691         if (strcmp ("", image->assembly->aname.culture)) {
2692                 values [MONO_ASSEMBLYREF_CULTURE] = string_heap_insert (&assembly->sheap,
2693                                 image->assembly->aname.culture);
2694         }
2695
2696         if ((pubkey = mono_image_get_public_key (image, &publen))) {
2697                 guchar pubtoken [9];
2698                 pubtoken [0] = 8;
2699                 mono_digest_get_public_token (pubtoken + 1, (guchar*)pubkey, publen);
2700                 values [MONO_ASSEMBLYREF_PUBLIC_KEY] = mono_image_add_stream_data (&assembly->blob, (char*)pubtoken, 9);
2701         } else {
2702                 values [MONO_ASSEMBLYREF_PUBLIC_KEY] = 0;
2703         }
2704         token <<= MONO_RESOLUTION_SCOPE_BITS;
2705         token |= MONO_RESOLUTION_SCOPE_ASSEMBLYREF;
2706         g_hash_table_insert (assembly->handleref, image, GUINT_TO_POINTER (token));
2707         return token;
2708 }
2709
2710 static guint32
2711 create_typespec (MonoDynamicImage *assembly, MonoType *type)
2712 {
2713         MONO_REQ_GC_NEUTRAL_MODE;
2714
2715         MonoDynamicTable *table;
2716         guint32 *values;
2717         guint32 token;
2718         SigBuffer buf;
2719
2720         if ((token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typespec, type))))
2721                 return token;
2722
2723         sigbuffer_init (&buf, 32);
2724         switch (type->type) {
2725         case MONO_TYPE_FNPTR:
2726         case MONO_TYPE_PTR:
2727         case MONO_TYPE_SZARRAY:
2728         case MONO_TYPE_ARRAY:
2729         case MONO_TYPE_VAR:
2730         case MONO_TYPE_MVAR:
2731         case MONO_TYPE_GENERICINST:
2732                 encode_type (assembly, type, &buf);
2733                 break;
2734         case MONO_TYPE_CLASS:
2735         case MONO_TYPE_VALUETYPE: {
2736                 MonoClass *k = mono_class_from_mono_type (type);
2737                 if (!k || !k->generic_container) {
2738                         sigbuffer_free (&buf);
2739                         return 0;
2740                 }
2741                 encode_type (assembly, type, &buf);
2742                 break;
2743         }
2744         default:
2745                 sigbuffer_free (&buf);
2746                 return 0;
2747         }
2748
2749         table = &assembly->tables [MONO_TABLE_TYPESPEC];
2750         if (assembly->save) {
2751                 token = sigbuffer_add_to_blob_cached (assembly, &buf);
2752                 alloc_table (table, table->rows + 1);
2753                 values = table->values + table->next_idx * MONO_TYPESPEC_SIZE;
2754                 values [MONO_TYPESPEC_SIGNATURE] = token;
2755         }
2756         sigbuffer_free (&buf);
2757
2758         token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
2759         g_hash_table_insert (assembly->typespec, type, GUINT_TO_POINTER(token));
2760         table->next_idx ++;
2761         return token;
2762 }
2763
2764 static guint32
2765 mono_image_typedef_or_ref_full (MonoDynamicImage *assembly, MonoType *type, gboolean try_typespec)
2766 {
2767         MONO_REQ_GC_UNSAFE_MODE;
2768
2769         MonoDynamicTable *table;
2770         guint32 *values;
2771         guint32 token, scope, enclosing;
2772         MonoClass *klass;
2773
2774         /* if the type requires a typespec, we must try that first*/
2775         if (try_typespec && (token = create_typespec (assembly, type)))
2776                 return token;
2777         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typeref, type));
2778         if (token)
2779                 return token;
2780         klass = mono_class_from_mono_type (type);
2781         if (!klass)
2782                 klass = mono_class_from_mono_type (type);
2783
2784         /*
2785          * If it's in the same module and not a generic type parameter:
2786          */
2787         if ((klass->image == &assembly->image) && (type->type != MONO_TYPE_VAR) &&
2788                         (type->type != MONO_TYPE_MVAR)) {
2789                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
2790                 token = MONO_TYPEDEFORREF_TYPEDEF | (tb->table_idx << MONO_TYPEDEFORREF_BITS);
2791                 register_dyn_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
2792                 return token;
2793         }
2794
2795         if (klass->nested_in) {
2796                 enclosing = mono_image_typedef_or_ref_full (assembly, &klass->nested_in->byval_arg, FALSE);
2797                 /* get the typeref idx of the enclosing type */
2798                 enclosing >>= MONO_TYPEDEFORREF_BITS;
2799                 scope = (enclosing << MONO_RESOLUTION_SCOPE_BITS) | MONO_RESOLUTION_SCOPE_TYPEREF;
2800         } else {
2801                 scope = resolution_scope_from_image (assembly, klass->image);
2802         }
2803         table = &assembly->tables [MONO_TABLE_TYPEREF];
2804         if (assembly->save) {
2805                 alloc_table (table, table->rows + 1);
2806                 values = table->values + table->next_idx * MONO_TYPEREF_SIZE;
2807                 values [MONO_TYPEREF_SCOPE] = scope;
2808                 values [MONO_TYPEREF_NAME] = string_heap_insert (&assembly->sheap, klass->name);
2809                 values [MONO_TYPEREF_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
2810         }
2811         token = MONO_TYPEDEFORREF_TYPEREF | (table->next_idx << MONO_TYPEDEFORREF_BITS); /* typeref */
2812         g_hash_table_insert (assembly->typeref, type, GUINT_TO_POINTER(token));
2813         table->next_idx ++;
2814         register_dyn_token (assembly, token, (MonoObject *)mono_class_get_ref_info (klass));
2815         return token;
2816 }
2817
2818 /*
2819  * Despite the name, we handle also TypeSpec (with the above helper).
2820  */
2821 static guint32
2822 mono_image_typedef_or_ref (MonoDynamicImage *assembly, MonoType *type)
2823 {
2824         return mono_image_typedef_or_ref_full (assembly, type, TRUE);
2825 }
2826
2827 #ifndef DISABLE_REFLECTION_EMIT
2828 static guint32
2829 mono_image_add_memberef_row (MonoDynamicImage *assembly, guint32 parent, const char *name, guint32 sig)
2830 {
2831         MONO_REQ_GC_NEUTRAL_MODE;
2832
2833         MonoDynamicTable *table;
2834         guint32 *values;
2835         guint32 token, pclass;
2836
2837         switch (parent & MONO_TYPEDEFORREF_MASK) {
2838         case MONO_TYPEDEFORREF_TYPEREF:
2839                 pclass = MONO_MEMBERREF_PARENT_TYPEREF;
2840                 break;
2841         case MONO_TYPEDEFORREF_TYPESPEC:
2842                 pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
2843                 break;
2844         case MONO_TYPEDEFORREF_TYPEDEF:
2845                 pclass = MONO_MEMBERREF_PARENT_TYPEDEF;
2846                 break;
2847         default:
2848                 g_warning ("unknown typeref or def token 0x%08x for %s", parent, name);
2849                 return 0;
2850         }
2851         /* extract the index */
2852         parent >>= MONO_TYPEDEFORREF_BITS;
2853
2854         table = &assembly->tables [MONO_TABLE_MEMBERREF];
2855
2856         if (assembly->save) {
2857                 alloc_table (table, table->rows + 1);
2858                 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
2859                 values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
2860                 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
2861                 values [MONO_MEMBERREF_SIGNATURE] = sig;
2862         }
2863
2864         token = MONO_TOKEN_MEMBER_REF | table->next_idx;
2865         table->next_idx ++;
2866
2867         return token;
2868 }
2869
2870 /*
2871  * Insert a memberef row into the metadata: the token that point to the memberref
2872  * is returned. Caching is done in the caller (mono_image_get_methodref_token() or
2873  * mono_image_get_fieldref_token()).
2874  * The sig param is an index to an already built signature.
2875  */
2876 static guint32
2877 mono_image_get_memberref_token (MonoDynamicImage *assembly, MonoType *type, const char *name, guint32 sig)
2878 {
2879         MONO_REQ_GC_NEUTRAL_MODE;
2880
2881         guint32 parent = mono_image_typedef_or_ref (assembly, type);
2882         return mono_image_add_memberef_row (assembly, parent, name, sig);
2883 }
2884
2885
2886 static guint32
2887 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec)
2888 {
2889         MONO_REQ_GC_NEUTRAL_MODE;
2890
2891         guint32 token;
2892         MonoMethodSignature *sig;
2893
2894         create_typespec = create_typespec && method->is_generic && method->klass->image != &assembly->image;
2895
2896         if (create_typespec) {
2897                 token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, GUINT_TO_POINTER (GPOINTER_TO_UINT (method) + 1)));
2898                 if (token)
2899                         return token;
2900         }
2901
2902         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
2903         if (token && !create_typespec)
2904                 return token;
2905
2906         g_assert (!method->is_inflated);
2907         if (!token) {
2908                 /*
2909                  * A methodref signature can't contain an unmanaged calling convention.
2910                  */
2911                 sig = mono_metadata_signature_dup (mono_method_signature (method));
2912                 if ((sig->call_convention != MONO_CALL_DEFAULT) && (sig->call_convention != MONO_CALL_VARARG))
2913                         sig->call_convention = MONO_CALL_DEFAULT;
2914                 token = mono_image_get_memberref_token (assembly, &method->klass->byval_arg,
2915                         method->name,  method_encode_signature (assembly, sig));
2916                 g_free (sig);
2917                 g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
2918         }
2919
2920         if (create_typespec) {
2921                 MonoDynamicTable *table = &assembly->tables [MONO_TABLE_METHODSPEC];
2922                 g_assert (mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF);
2923                 token = (mono_metadata_token_index (token) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
2924
2925                 if (assembly->save) {
2926                         guint32 *values;
2927
2928                         alloc_table (table, table->rows + 1);
2929                         values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
2930                         values [MONO_METHODSPEC_METHOD] = token;
2931                         values [MONO_METHODSPEC_SIGNATURE] = encode_generic_method_sig (assembly, &mono_method_get_generic_container (method)->context);
2932                 }
2933
2934                 token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
2935                 table->next_idx ++;
2936                 /*methodspec and memberef tokens are diferent, */
2937                 g_hash_table_insert (assembly->handleref, GUINT_TO_POINTER (GPOINTER_TO_UINT (method) + 1), GUINT_TO_POINTER (token));
2938                 return token;
2939         }
2940         return token;
2941 }
2942
2943 static guint32
2944 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method, MonoError *error)
2945 {
2946         guint32 token, parent, sig;
2947         ReflectionMethodBuilder rmb;
2948         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)method->type;
2949
2950         mono_error_init (error);
2951         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
2952         if (token)
2953                 return token;
2954
2955         if (!reflection_methodbuilder_from_method_builder (&rmb, method, error))
2956                 return 0;
2957
2958         /*
2959          * A methodref signature can't contain an unmanaged calling convention.
2960          * Since some flags are encoded as part of call_conv, we need to check against it.
2961         */
2962         if ((rmb.call_conv & ~0x60) != MONO_CALL_DEFAULT && (rmb.call_conv & ~0x60) != MONO_CALL_VARARG)
2963                 rmb.call_conv = (rmb.call_conv & 0x60) | MONO_CALL_DEFAULT;
2964
2965         sig = method_builder_encode_signature (assembly, &rmb, error);
2966         return_val_if_nok (error, 0);
2967
2968         if (tb->generic_params) {
2969                 parent = create_generic_typespec (assembly, tb, error);
2970                 return_val_if_nok (error, 0);
2971         } else {
2972                 MonoType *t = mono_reflection_type_get_handle ((MonoReflectionType*)rmb.type, error);
2973                 return_val_if_nok (error, 0);
2974
2975                 parent = mono_image_typedef_or_ref (assembly, t);
2976         }
2977
2978         char *name = mono_string_to_utf8 (method->name);
2979
2980         token = mono_image_add_memberef_row (assembly, parent, name, sig);
2981         g_free (name);
2982
2983         g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
2984
2985         return token;
2986 }
2987
2988 static guint32
2989 mono_image_get_varargs_method_token (MonoDynamicImage *assembly, guint32 original,
2990                                      const gchar *name, guint32 sig)
2991 {
2992         MonoDynamicTable *table;
2993         guint32 token;
2994         guint32 *values;
2995
2996         table = &assembly->tables [MONO_TABLE_MEMBERREF];
2997
2998         if (assembly->save) {
2999                 alloc_table (table, table->rows + 1);
3000                 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
3001                 values [MONO_MEMBERREF_CLASS] = original;
3002                 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
3003                 values [MONO_MEMBERREF_SIGNATURE] = sig;
3004         }
3005
3006         token = MONO_TOKEN_MEMBER_REF | table->next_idx;
3007         table->next_idx ++;
3008
3009         return token;
3010 }
3011
3012 static guint32
3013 encode_generic_method_definition_sig (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb)
3014 {
3015         SigBuffer buf;
3016         int i;
3017         guint32 nparams = mono_array_length (mb->generic_params);
3018         guint32 idx;
3019
3020         if (!assembly->save)
3021                 return 0;
3022
3023         sigbuffer_init (&buf, 32);
3024
3025         sigbuffer_add_value (&buf, 0xa);
3026         sigbuffer_add_value (&buf, nparams);
3027
3028         for (i = 0; i < nparams; i++) {
3029                 sigbuffer_add_value (&buf, MONO_TYPE_MVAR);
3030                 sigbuffer_add_value (&buf, i);
3031         }
3032
3033         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
3034         sigbuffer_free (&buf);
3035         return idx;
3036 }
3037
3038 static guint32
3039 mono_image_get_methodspec_token_for_generic_method_definition (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, MonoError *error)
3040 {
3041         MonoDynamicTable *table;
3042         guint32 *values;
3043         guint32 token, mtoken = 0;
3044
3045         mono_error_init (error);
3046         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->methodspec, mb));
3047         if (token)
3048                 return token;
3049
3050         table = &assembly->tables [MONO_TABLE_METHODSPEC];
3051
3052         mtoken = mono_image_get_methodref_token_for_methodbuilder (assembly, mb, error);
3053         if (!mono_error_ok (error))
3054                 return 0;
3055
3056         switch (mono_metadata_token_table (mtoken)) {
3057         case MONO_TABLE_MEMBERREF:
3058                 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
3059                 break;
3060         case MONO_TABLE_METHOD:
3061                 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODDEF;
3062                 break;
3063         default:
3064                 g_assert_not_reached ();
3065         }
3066
3067         if (assembly->save) {
3068                 alloc_table (table, table->rows + 1);
3069                 values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
3070                 values [MONO_METHODSPEC_METHOD] = mtoken;
3071                 values [MONO_METHODSPEC_SIGNATURE] = encode_generic_method_definition_sig (assembly, mb);
3072         }
3073
3074         token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
3075         table->next_idx ++;
3076
3077         mono_g_hash_table_insert (assembly->methodspec, mb, GUINT_TO_POINTER(token));
3078         return token;
3079 }
3080
3081 static guint32
3082 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_methodspec, MonoError *error)
3083 {
3084         guint32 token;
3085
3086         mono_error_init (error);
3087
3088         if (mb->generic_params && create_methodspec)
3089                 return mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb, error);
3090
3091         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, mb));
3092         if (token)
3093                 return token;
3094
3095         token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb, error);
3096         if (!mono_error_ok (error))
3097                 return 0;
3098         mono_g_hash_table_insert (assembly->handleref_managed, mb, GUINT_TO_POINTER(token));
3099         return token;
3100 }
3101
3102 static guint32
3103 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *mb, MonoError *error)
3104 {
3105         guint32 token, parent, sig;
3106         ReflectionMethodBuilder rmb;
3107         char *name;
3108         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mb->type;
3109
3110         mono_error_init (error);
3111
3112         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, mb));
3113         if (token)
3114                 return token;
3115
3116         if (!reflection_methodbuilder_from_ctor_builder (&rmb, mb, error))
3117                 return 0;
3118
3119         if (tb->generic_params) {
3120                 parent = create_generic_typespec (assembly, tb, error);
3121                 return_val_if_nok (error, 0);
3122         } else {
3123                 MonoType * type = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error);
3124                 return_val_if_nok (error, 0);
3125                 parent = mono_image_typedef_or_ref (assembly, type);
3126         }
3127
3128         name = mono_string_to_utf8 (rmb.name);
3129         sig = method_builder_encode_signature (assembly, &rmb, error);
3130         return_val_if_nok (error, 0);
3131
3132         token = mono_image_add_memberef_row (assembly, parent, name, sig);
3133
3134         g_free (name);
3135         mono_g_hash_table_insert (assembly->handleref_managed, mb, GUINT_TO_POINTER(token));
3136         return token;
3137 }
3138 #endif
3139
3140 static gboolean
3141 is_field_on_inst (MonoClassField *field)
3142 {
3143         return (field->parent->generic_class && field->parent->generic_class->is_dynamic && ((MonoDynamicGenericClass*)field->parent->generic_class)->fields);
3144 }
3145
3146 /*
3147  * If FIELD is a field of a MonoDynamicGenericClass, return its non-inflated type.
3148  */
3149 static MonoType*
3150 get_field_on_inst_generic_type (MonoClassField *field)
3151 {
3152         MonoClass *klass, *gtd;
3153         MonoDynamicGenericClass *dgclass;
3154         int field_index;
3155
3156         g_assert (is_field_on_inst (field));
3157
3158         dgclass = (MonoDynamicGenericClass*)field->parent->generic_class;
3159
3160         if (field >= dgclass->fields && field - dgclass->fields < dgclass->count_fields) {
3161                 field_index = field - dgclass->fields;
3162                 return dgclass->field_generic_types [field_index];
3163         }
3164
3165         klass = field->parent;
3166         gtd = klass->generic_class->container_class;
3167
3168         if (field >= klass->fields && field - klass->fields < klass->field.count) {
3169                 field_index = field - klass->fields;
3170                 return gtd->fields [field_index].type;
3171         }
3172
3173         g_assert_not_reached ();
3174         return 0;
3175 }
3176
3177 #ifndef DISABLE_REFLECTION_EMIT
3178 static guint32
3179 mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoObject *f, MonoClassField *field)
3180 {
3181         MonoType *type;
3182         guint32 token;
3183
3184         g_assert (field);
3185         g_assert (field->parent);
3186
3187         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, f));
3188         if (token)
3189                 return token;
3190
3191         if (field->parent->generic_class && field->parent->generic_class->container_class && field->parent->generic_class->container_class->fields) {
3192                 int index = field - field->parent->fields;
3193                 type = mono_field_get_type (&field->parent->generic_class->container_class->fields [index]);
3194         } else {
3195                 if (is_field_on_inst (field))
3196                         type = get_field_on_inst_generic_type (field);
3197                 else
3198                         type = mono_field_get_type (field);
3199         }
3200         token = mono_image_get_memberref_token (assembly, &field->parent->byval_arg,
3201                                                                                         mono_field_get_name (field),
3202                                                                                         fieldref_encode_signature (assembly, field->parent->image, type));
3203         mono_g_hash_table_insert (assembly->handleref_managed, f, GUINT_TO_POINTER(token));
3204         return token;
3205 }
3206
3207 static guint32
3208 mono_image_get_field_on_inst_token (MonoDynamicImage *assembly, MonoReflectionFieldOnTypeBuilderInst *f, MonoError *error)
3209 {
3210         guint32 token;
3211         MonoClass *klass;
3212         MonoGenericClass *gclass;
3213         MonoType *type;
3214         char *name;
3215
3216         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, f));
3217         if (token)
3218                 return token;
3219         if (is_sre_field_builder (mono_object_class (f->fb))) {
3220                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)f->fb;
3221                 type = mono_reflection_type_get_handle ((MonoReflectionType*)f->inst, error);
3222                 return_val_if_nok (error, 0);
3223                 klass = mono_class_from_mono_type (type);
3224                 gclass = type->data.generic_class;
3225                 g_assert (gclass->is_dynamic);
3226
3227                 guint32 sig_token = field_encode_signature (assembly, fb, error);
3228                 return_val_if_nok (error, 0);
3229                 name = mono_string_to_utf8 (fb->name);
3230                 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig_token);
3231                 g_free (name);
3232         } else if (is_sr_mono_field (mono_object_class (f->fb))) {
3233                 guint32 sig;
3234                 MonoClassField *field = ((MonoReflectionField *)f->fb)->field;
3235
3236                 type = mono_reflection_type_get_handle ((MonoReflectionType*)f->inst, error);
3237                 return_val_if_nok (error, 0);
3238                 klass = mono_class_from_mono_type (type);
3239
3240                 sig = fieldref_encode_signature (assembly, field->parent->image, field->type);
3241                 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, field->name, sig);
3242         } else {
3243                 char *name = mono_type_get_full_name (mono_object_class (f->fb));
3244                 g_error ("mono_image_get_field_on_inst_token: don't know how to handle %s", name);
3245         }
3246
3247         mono_g_hash_table_insert (assembly->handleref_managed, f, GUINT_TO_POINTER (token));
3248         return token;
3249 }
3250
3251 static guint32
3252 mono_image_get_ctor_on_inst_token (MonoDynamicImage *assembly, MonoReflectionCtorOnTypeBuilderInst *c, gboolean create_methodspec, MonoError *error)
3253 {
3254         guint32 sig, token;
3255         MonoClass *klass;
3256         MonoGenericClass *gclass;
3257         MonoType *type;
3258
3259         mono_error_init (error);
3260
3261         /* A ctor cannot be a generic method, so we can ignore create_methodspec */
3262
3263         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, c));
3264         if (token)
3265                 return token;
3266
3267         if (is_sre_ctor_builder (mono_object_class (c->cb))) {
3268                 MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder *)c->cb;
3269                 ReflectionMethodBuilder rmb;
3270                 char *name;
3271
3272                 type = mono_reflection_type_get_handle ((MonoReflectionType*)c->inst, error);
3273                 return_val_if_nok (error, 0);
3274                 klass = mono_class_from_mono_type (type);
3275
3276                 gclass = type->data.generic_class;
3277                 g_assert (gclass->is_dynamic);
3278
3279                 if (!reflection_methodbuilder_from_ctor_builder (&rmb, cb, error))
3280                         return 0;
3281
3282                 sig = method_builder_encode_signature (assembly, &rmb, error);
3283                 return_val_if_nok (error, 0);
3284
3285                 name = mono_string_to_utf8 (rmb.name);
3286
3287                 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig);
3288                 g_free (name);
3289         } else if (is_sr_mono_cmethod (mono_object_class (c->cb))) {
3290                 MonoMethod *mm = ((MonoReflectionMethod *)c->cb)->method;
3291
3292                 type = mono_reflection_type_get_handle ((MonoReflectionType*)c->inst, error);
3293                 return_val_if_nok (error, 0);
3294                 klass = mono_class_from_mono_type (type);
3295
3296                 sig = method_encode_signature (assembly, mono_method_signature (mm));
3297                 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, mm->name, sig);
3298         } else {
3299                 char *name = mono_type_get_full_name (mono_object_class (c->cb));
3300                 g_error ("mono_image_get_method_on_inst_token: don't know how to handle %s", name);
3301         }
3302
3303
3304         mono_g_hash_table_insert (assembly->handleref_managed, c, GUINT_TO_POINTER (token));
3305         return token;
3306 }
3307
3308 static MonoMethod*
3309 mono_reflection_method_on_tb_inst_get_handle (MonoReflectionMethodOnTypeBuilderInst *m, MonoError *error)
3310 {
3311         MonoClass *klass;
3312         MonoGenericContext tmp_context;
3313         MonoType **type_argv;
3314         MonoGenericInst *ginst;
3315         MonoMethod *method, *inflated;
3316         int count, i;
3317
3318         mono_error_init (error);
3319
3320         init_type_builder_generics ((MonoObject*)m->inst);
3321
3322         method = inflate_method (m->inst, (MonoObject*)m->mb, error);
3323         return_val_if_nok (error, NULL);
3324
3325         klass = method->klass;
3326
3327         if (m->method_args == NULL)
3328                 return method;
3329
3330         if (method->is_inflated)
3331                 method = ((MonoMethodInflated *) method)->declaring;
3332
3333         count = mono_array_length (m->method_args);
3334
3335         type_argv = g_new0 (MonoType *, count);
3336         for (i = 0; i < count; i++) {
3337                 MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (m->method_args, gpointer, i);
3338                 type_argv [i] = mono_reflection_type_get_handle (garg, error);
3339                 return_val_if_nok (error, NULL);
3340         }
3341         ginst = mono_metadata_get_generic_inst (count, type_argv);
3342         g_free (type_argv);
3343
3344         tmp_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL;
3345         tmp_context.method_inst = ginst;
3346
3347         inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, error);
3348         mono_error_assert_ok (error);
3349         return inflated;
3350 }
3351
3352 static guint32
3353 mono_image_get_method_on_inst_token (MonoDynamicImage *assembly, MonoReflectionMethodOnTypeBuilderInst *m, gboolean create_methodspec, MonoError *error)
3354 {
3355         guint32 sig, token = 0;
3356         MonoType *type;
3357         MonoClass *klass;
3358
3359         mono_error_init (error);
3360
3361         if (m->method_args) {
3362                 MonoMethod *inflated;
3363
3364                 inflated = mono_reflection_method_on_tb_inst_get_handle (m, error);
3365                 return_val_if_nok (error, 0);
3366
3367                 if (create_methodspec)
3368                         token = mono_image_get_methodspec_token (assembly, inflated);
3369                 else
3370                         token = mono_image_get_inflated_method_token (assembly, inflated);
3371                 return token;
3372         }
3373
3374         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, m));
3375         if (token)
3376                 return token;
3377
3378         if (is_sre_method_builder (mono_object_class (m->mb))) {
3379                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)m->mb;
3380                 MonoGenericClass *gclass;
3381                 ReflectionMethodBuilder rmb;
3382                 char *name;
3383
3384                 type = mono_reflection_type_get_handle ((MonoReflectionType*)m->inst, error);
3385                 return_val_if_nok (error, 0);
3386                 klass = mono_class_from_mono_type (type);
3387                 gclass = type->data.generic_class;
3388                 g_assert (gclass->is_dynamic);
3389
3390                 if (!reflection_methodbuilder_from_method_builder (&rmb, mb, error))
3391                         return 0;
3392
3393                 sig = method_builder_encode_signature (assembly, &rmb, error);
3394                 return_val_if_nok (error, 0);
3395
3396                 name = mono_string_to_utf8 (rmb.name);
3397
3398                 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig);
3399                 g_free (name);
3400         } else if (is_sr_mono_method (mono_object_class (m->mb))) {
3401                 MonoMethod *mm = ((MonoReflectionMethod *)m->mb)->method;
3402
3403                 type = mono_reflection_type_get_handle ((MonoReflectionType*)m->inst, error);
3404                 return_val_if_nok (error, 0);
3405                 klass = mono_class_from_mono_type (type);
3406
3407                 sig = method_encode_signature (assembly, mono_method_signature (mm));
3408                 token = mono_image_get_memberref_token (assembly, &klass->byval_arg, mm->name, sig);
3409         } else {
3410                 char *name = mono_type_get_full_name (mono_object_class (m->mb));
3411                 g_error ("mono_image_get_method_on_inst_token: don't know how to handle %s", name);
3412         }
3413
3414         mono_g_hash_table_insert (assembly->handleref_managed, m, GUINT_TO_POINTER (token));
3415         return token;
3416 }
3417
3418 static guint32
3419 encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericContext *context)
3420 {
3421         SigBuffer buf;
3422         int i;
3423         guint32 nparams = context->method_inst->type_argc;
3424         guint32 idx;
3425
3426         if (!assembly->save)
3427                 return 0;
3428
3429         sigbuffer_init (&buf, 32);
3430         /*
3431          * FIXME: vararg, explicit_this, differenc call_conv values...
3432          */
3433         sigbuffer_add_value (&buf, 0xa); /* FIXME FIXME FIXME */
3434         sigbuffer_add_value (&buf, nparams);
3435
3436         for (i = 0; i < nparams; i++)
3437                 encode_type (assembly, context->method_inst->type_argv [i], &buf);
3438
3439         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
3440         sigbuffer_free (&buf);
3441         return idx;
3442 }
3443
3444 static guint32
3445 method_encode_methodspec (MonoDynamicImage *assembly, MonoMethod *method)
3446 {
3447         MonoDynamicTable *table;
3448         guint32 *values;
3449         guint32 token, mtoken = 0, sig;
3450         MonoMethodInflated *imethod;
3451         MonoMethod *declaring;
3452
3453         table = &assembly->tables [MONO_TABLE_METHODSPEC];
3454
3455         g_assert (method->is_inflated);
3456         imethod = (MonoMethodInflated *) method;
3457         declaring = imethod->declaring;
3458
3459         sig = method_encode_signature (assembly, mono_method_signature (declaring));
3460         mtoken = mono_image_get_memberref_token (assembly, &method->klass->byval_arg, declaring->name, sig);
3461
3462         if (!mono_method_signature (declaring)->generic_param_count)
3463                 return mtoken;
3464
3465         switch (mono_metadata_token_table (mtoken)) {
3466         case MONO_TABLE_MEMBERREF:
3467                 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODREF;
3468                 break;
3469         case MONO_TABLE_METHOD:
3470                 mtoken = (mono_metadata_token_index (mtoken) << MONO_METHODDEFORREF_BITS) | MONO_METHODDEFORREF_METHODDEF;
3471                 break;
3472         default:
3473                 g_assert_not_reached ();
3474         }
3475
3476         sig = encode_generic_method_sig (assembly, mono_method_get_context (method));
3477
3478         if (assembly->save) {
3479                 alloc_table (table, table->rows + 1);
3480                 values = table->values + table->next_idx * MONO_METHODSPEC_SIZE;
3481                 values [MONO_METHODSPEC_METHOD] = mtoken;
3482                 values [MONO_METHODSPEC_SIGNATURE] = sig;
3483         }
3484
3485         token = MONO_TOKEN_METHOD_SPEC | table->next_idx;
3486         table->next_idx ++;
3487
3488         return token;
3489 }
3490
3491 static guint32
3492 mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *method)
3493 {
3494         MonoMethodInflated *imethod;
3495         guint32 token;
3496
3497         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method));
3498         if (token)
3499                 return token;
3500
3501         g_assert (method->is_inflated);
3502         imethod = (MonoMethodInflated *) method;
3503
3504         if (mono_method_signature (imethod->declaring)->generic_param_count) {
3505                 token = method_encode_methodspec (assembly, method);
3506         } else {
3507                 guint32 sig = method_encode_signature (
3508                         assembly, mono_method_signature (imethod->declaring));
3509                 token = mono_image_get_memberref_token (
3510                         assembly, &method->klass->byval_arg, method->name, sig);
3511         }
3512
3513         g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token));
3514         return token;
3515 }
3516
3517 static guint32
3518 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m)
3519 {
3520         MonoMethodInflated *imethod = (MonoMethodInflated *) m;
3521         guint32 sig, token;
3522
3523         sig = method_encode_signature (assembly, mono_method_signature (imethod->declaring));
3524         token = mono_image_get_memberref_token (
3525                 assembly, &m->klass->byval_arg, m->name, sig);
3526
3527         return token;
3528 }
3529
3530 static guint32
3531 create_generic_typespec (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb, MonoError *error)
3532 {
3533         MonoDynamicTable *table;
3534         MonoClass *klass;
3535         MonoType *type;
3536         guint32 *values;
3537         guint32 token;
3538         SigBuffer buf;
3539         int count, i;
3540
3541         /*
3542          * We're creating a TypeSpec for the TypeBuilder of a generic type declaration,
3543          * ie. what we'd normally use as the generic type in a TypeSpec signature.
3544          * Because of this, we must not insert it into the `typeref' hash table.
3545          */
3546         type = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error);
3547         return_val_if_nok (error, 0);
3548         token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typespec, type));
3549         if (token)
3550                 return token;
3551
3552         sigbuffer_init (&buf, 32);
3553
3554         g_assert (tb->generic_params);
3555         klass = mono_class_from_mono_type (type);
3556
3557         if (tb->generic_container)
3558                 mono_reflection_create_generic_class (tb);
3559
3560         sigbuffer_add_value (&buf, MONO_TYPE_GENERICINST);
3561         g_assert (klass->generic_container);
3562         sigbuffer_add_value (&buf, klass->byval_arg.type);
3563         sigbuffer_add_value (&buf, mono_image_typedef_or_ref_full (assembly, &klass->byval_arg, FALSE));
3564
3565         count = mono_array_length (tb->generic_params);
3566         sigbuffer_add_value (&buf, count);
3567         for (i = 0; i < count; i++) {
3568                 MonoReflectionGenericParam *gparam;
3569
3570                 gparam = mono_array_get (tb->generic_params, MonoReflectionGenericParam *, i);
3571                 MonoType *gparam_type = mono_reflection_type_get_handle ((MonoReflectionType*)gparam, error);
3572                 if (!is_ok (error))
3573                         goto fail;
3574
3575                 encode_type (assembly, gparam_type, &buf);
3576         }
3577
3578         table = &assembly->tables [MONO_TABLE_TYPESPEC];
3579
3580         if (assembly->save) {
3581                 token = sigbuffer_add_to_blob_cached (assembly, &buf);
3582                 alloc_table (table, table->rows + 1);
3583                 values = table->values + table->next_idx * MONO_TYPESPEC_SIZE;
3584                 values [MONO_TYPESPEC_SIGNATURE] = token;
3585         }
3586         sigbuffer_free (&buf);
3587
3588         token = MONO_TYPEDEFORREF_TYPESPEC | (table->next_idx << MONO_TYPEDEFORREF_BITS);
3589         g_hash_table_insert (assembly->typespec, type, GUINT_TO_POINTER(token));
3590         table->next_idx ++;
3591         return token;
3592 fail:
3593         sigbuffer_free (&buf);
3594         return 0;
3595 }
3596
3597 /*
3598  * Return a copy of TYPE, adding the custom modifiers in MODREQ and MODOPT.
3599  */
3600 static MonoType*
3601 add_custom_modifiers (MonoDynamicImage *assembly, MonoType *type, MonoArray *modreq, MonoArray *modopt, MonoError *error)
3602 {
3603         int i, count, len, pos;
3604         MonoType *t;
3605
3606         mono_error_init (error);
3607
3608         count = 0;
3609         if (modreq)
3610                 count += mono_array_length (modreq);
3611         if (modopt)
3612                 count += mono_array_length (modopt);
3613
3614         if (count == 0)
3615                 return mono_metadata_type_dup (NULL, type);
3616
3617         len = MONO_SIZEOF_TYPE + ((gint32)count) * sizeof (MonoCustomMod);
3618         t = (MonoType *)g_malloc (len);
3619         memcpy (t, type, MONO_SIZEOF_TYPE);
3620
3621         t->num_mods = count;
3622         pos = 0;
3623         if (modreq) {
3624                 for (i = 0; i < mono_array_length (modreq); ++i) {
3625                         MonoType *mod = mono_type_array_get_and_resolve (modreq, i, error);
3626                         if (!is_ok (error))
3627                                 goto fail;
3628                         t->modifiers [pos].required = 1;
3629                         t->modifiers [pos].token = mono_image_typedef_or_ref (assembly, mod);
3630                         pos ++;
3631                 }
3632         }
3633         if (modopt) {
3634                 for (i = 0; i < mono_array_length (modopt); ++i) {
3635                         MonoType *mod = mono_type_array_get_and_resolve (modopt, i, error);
3636                         if (!is_ok (error))
3637                                 goto fail;
3638                         t->modifiers [pos].required = 0;
3639                         t->modifiers [pos].token = mono_image_typedef_or_ref (assembly, mod);
3640                         pos ++;
3641                 }
3642         }
3643
3644         return t;
3645 fail:
3646         g_free (t);
3647         return NULL;
3648 }
3649
3650 static void
3651 init_type_builder_generics (MonoObject *type)
3652 {
3653         MonoReflectionTypeBuilder *tb;
3654
3655         if (!is_sre_type_builder(mono_object_class (type)))
3656                 return;
3657         tb = (MonoReflectionTypeBuilder *)type;
3658
3659         if (tb && tb->generic_container)
3660                 mono_reflection_create_generic_class (tb);
3661 }
3662
3663 static guint32
3664 mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb, MonoError *error)
3665 {
3666         MonoDynamicTable *table;
3667         MonoType *custom = NULL, *type;
3668         guint32 *values;
3669         guint32 token, pclass, parent, sig;
3670         gchar *name;
3671
3672         mono_error_init (error);
3673
3674         token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, fb));
3675         if (token)
3676                 return token;
3677
3678         MonoType *typeb = mono_reflection_type_get_handle (fb->typeb, error);
3679         return_val_if_nok (error, 0);
3680         /* FIXME: is this call necessary? */
3681         mono_class_from_mono_type (typeb);
3682
3683         /*FIXME this is one more layer of ugliness due how types are created.*/
3684         init_type_builder_generics (fb->type);
3685
3686         /* fb->type does not include the custom modifiers */
3687         /* FIXME: We should do this in one place when a fieldbuilder is created */
3688         type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
3689         return_val_if_nok (error, 0);
3690
3691         if (fb->modreq || fb->modopt) {
3692                 type = custom = add_custom_modifiers (assembly, type, fb->modreq, fb->modopt, error);
3693                 return_val_if_nok (error, 0);
3694         }
3695
3696         sig = fieldref_encode_signature (assembly, NULL, type);
3697         g_free (custom);
3698
3699         parent = create_generic_typespec (assembly, (MonoReflectionTypeBuilder *) fb->typeb, error);
3700         return_val_if_nok (error, 0);
3701         g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC);
3702
3703         pclass = MONO_MEMBERREF_PARENT_TYPESPEC;
3704         parent >>= MONO_TYPEDEFORREF_BITS;
3705
3706         table = &assembly->tables [MONO_TABLE_MEMBERREF];
3707
3708         name = mono_string_to_utf8 (fb->name);
3709
3710         if (assembly->save) {
3711                 alloc_table (table, table->rows + 1);
3712                 values = table->values + table->next_idx * MONO_MEMBERREF_SIZE;
3713                 values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS);
3714                 values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name);
3715                 values [MONO_MEMBERREF_SIGNATURE] = sig;
3716         }
3717
3718         token = MONO_TOKEN_MEMBER_REF | table->next_idx;
3719         table->next_idx ++;
3720         mono_g_hash_table_insert (assembly->handleref_managed, fb, GUINT_TO_POINTER(token));
3721         g_free (name);
3722         return token;
3723 }
3724
3725 static guint32
3726 mono_reflection_encode_sighelper (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error)
3727 {
3728         SigBuffer buf;
3729         guint32 nargs;
3730         guint32 i, idx;
3731
3732         mono_error_init (error);
3733
3734         if (!assembly->save)
3735                 return 0;
3736
3737         /* FIXME: this means SignatureHelper.SignatureHelpType.HELPER_METHOD */
3738         g_assert (helper->type == 2);
3739
3740         if (helper->arguments)
3741                 nargs = mono_array_length (helper->arguments);
3742         else
3743                 nargs = 0;
3744
3745         sigbuffer_init (&buf, 32);
3746
3747         /* Encode calling convention */
3748         /* Change Any to Standard */
3749         if ((helper->call_conv & 0x03) == 0x03)
3750                 helper->call_conv = 0x01;
3751         /* explicit_this implies has_this */
3752         if (helper->call_conv & 0x40)
3753                 helper->call_conv &= 0x20;
3754
3755         if (helper->call_conv == 0) { /* Unmanaged */
3756                 idx = helper->unmanaged_call_conv - 1;
3757         } else {
3758                 /* Managed */
3759                 idx = helper->call_conv & 0x60; /* has_this + explicit_this */
3760                 if (helper->call_conv & 0x02) /* varargs */
3761                         idx += 0x05;
3762         }
3763
3764         sigbuffer_add_byte (&buf, idx);
3765         sigbuffer_add_value (&buf, nargs);
3766         encode_reflection_type (assembly, helper->return_type, &buf, error);
3767         if (!is_ok (error))
3768                 goto fail;
3769         for (i = 0; i < nargs; ++i) {
3770                 MonoArray *modreqs = NULL;
3771                 MonoArray *modopts = NULL;
3772                 MonoReflectionType *pt;
3773
3774                 if (helper->modreqs && (i < mono_array_length (helper->modreqs)))
3775                         modreqs = mono_array_get (helper->modreqs, MonoArray*, i);
3776                 if (helper->modopts && (i < mono_array_length (helper->modopts)))
3777                         modopts = mono_array_get (helper->modopts, MonoArray*, i);
3778
3779                 encode_custom_modifiers (assembly, modreqs, modopts, &buf, error);
3780                 if (!is_ok (error))
3781                         goto fail;
3782                 pt = mono_array_get (helper->arguments, MonoReflectionType*, i);
3783                 encode_reflection_type (assembly, pt, &buf, error);
3784                 if (!is_ok (error))
3785                         goto fail;
3786         }
3787         idx = sigbuffer_add_to_blob_cached (assembly, &buf);
3788         sigbuffer_free (&buf);
3789
3790         return idx;
3791 fail:
3792         sigbuffer_free (&buf);
3793         return 0;
3794 }
3795
3796 static guint32
3797 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error)
3798 {
3799         guint32 idx;
3800         MonoDynamicTable *table;
3801         guint32 *values;
3802
3803         mono_error_init (error);
3804
3805         table = &assembly->tables [MONO_TABLE_STANDALONESIG];
3806         idx = table->next_idx ++;
3807         table->rows ++;
3808         alloc_table (table, table->rows);
3809         values = table->values + idx * MONO_STAND_ALONE_SIGNATURE_SIZE;
3810
3811         values [MONO_STAND_ALONE_SIGNATURE] =
3812                 mono_reflection_encode_sighelper (assembly, helper, error);
3813         return_val_if_nok (error, 0);
3814
3815         return idx;
3816 }
3817
3818 static int
3819 reflection_cc_to_file (int call_conv) {
3820         switch (call_conv & 0x3) {
3821         case 0:
3822         case 1: return MONO_CALL_DEFAULT;
3823         case 2: return MONO_CALL_VARARG;
3824         default:
3825                 g_assert_not_reached ();
3826         }
3827         return 0;
3828 }
3829 #endif /* !DISABLE_REFLECTION_EMIT */
3830
3831 typedef struct {
3832         MonoType *parent;
3833         MonoMethodSignature *sig;
3834         char *name;
3835         guint32 token;
3836 } ArrayMethod;
3837
3838 #ifndef DISABLE_REFLECTION_EMIT
3839 static guint32
3840 mono_image_get_array_token (MonoDynamicImage *assembly, MonoReflectionArrayMethod *m, MonoError *error)
3841 {
3842         guint32 nparams, i;
3843         GList *tmp;
3844         char *name = NULL;
3845         MonoMethodSignature *sig;
3846         ArrayMethod *am = NULL;
3847         MonoType *mtype;
3848
3849         mono_error_init (error);
3850
3851         nparams = mono_array_length (m->parameters);
3852         sig = (MonoMethodSignature *)g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * nparams);
3853         sig->hasthis = 1;
3854         sig->sentinelpos = -1;
3855         sig->call_convention = reflection_cc_to_file (m->call_conv);
3856         sig->param_count = nparams;
3857         if (m->ret) {
3858                 sig->ret = mono_reflection_type_get_handle (m->ret, error);
3859                 if (!is_ok (error))
3860                         goto fail;
3861         } else
3862                 sig->ret = &mono_defaults.void_class->byval_arg;
3863
3864         mtype = mono_reflection_type_get_handle (m->parent, error);
3865         if (!is_ok (error))
3866                 goto fail;
3867
3868         for (i = 0; i < nparams; ++i) {
3869                 sig->params [i] = mono_type_array_get_and_resolve (m->parameters, i, error);
3870                 if (!is_ok (error))
3871                         goto fail;
3872         }
3873
3874         name = mono_string_to_utf8 (m->name);
3875         for (tmp = assembly->array_methods; tmp; tmp = tmp->next) {
3876                 am = (ArrayMethod *)tmp->data;
3877                 if (strcmp (name, am->name) == 0 &&
3878                                 mono_metadata_type_equal (am->parent, mtype) &&
3879                                 mono_metadata_signature_equal (am->sig, sig)) {
3880                         g_free (name);
3881                         g_free (sig);
3882                         m->table_idx = am->token & 0xffffff;
3883                         return am->token;
3884                 }
3885         }
3886         am = g_new0 (ArrayMethod, 1);
3887         am->name = name;
3888         am->sig = sig;
3889         am->parent = mtype;
3890         am->token = mono_image_get_memberref_token (assembly, am->parent, name,
3891                 method_encode_signature (assembly, sig));
3892         assembly->array_methods = g_list_prepend (assembly->array_methods, am);
3893         m->table_idx = am->token & 0xffffff;
3894         return am->token;
3895 fail:
3896         g_free (am);
3897         g_free (name);
3898         g_free (sig);
3899         return 0;
3900
3901 }
3902
3903 /*
3904  * Insert into the metadata tables all the info about the TypeBuilder tb.
3905  * Data in the tables is inserted in a predefined order, since some tables need to be sorted.
3906  */
3907 static gboolean
3908 mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, MonoDynamicImage *assembly, MonoError *error)
3909 {
3910         MonoDynamicTable *table;
3911         guint *values;
3912         int i, is_object = 0, is_system = 0;
3913         char *n;
3914
3915         mono_error_init (error);
3916
3917         table = &assembly->tables [MONO_TABLE_TYPEDEF];
3918         values = table->values + tb->table_idx * MONO_TYPEDEF_SIZE;
3919         values [MONO_TYPEDEF_FLAGS] = tb->attrs;
3920         n = mono_string_to_utf8 (tb->name);
3921         if (strcmp (n, "Object") == 0)
3922                 is_object++;
3923         values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, n);
3924         g_free (n);
3925         n = mono_string_to_utf8 (tb->nspace);
3926         if (strcmp (n, "System") == 0)
3927                 is_system++;
3928         values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, n);
3929         g_free (n);
3930         if (tb->parent && !(is_system && is_object) &&
3931                         !(tb->attrs & TYPE_ATTRIBUTE_INTERFACE)) { /* interfaces don't have a parent */
3932                 MonoType *parent_type = mono_reflection_type_get_handle ((MonoReflectionType*)tb->parent, error);
3933                 return_val_if_nok (error, FALSE);
3934                 values [MONO_TYPEDEF_EXTENDS] = mono_image_typedef_or_ref (assembly, parent_type);
3935         } else {
3936                 values [MONO_TYPEDEF_EXTENDS] = 0;
3937         }
3938         values [MONO_TYPEDEF_FIELD_LIST] = assembly->tables [MONO_TABLE_FIELD].next_idx;
3939         values [MONO_TYPEDEF_METHOD_LIST] = assembly->tables [MONO_TABLE_METHOD].next_idx;
3940
3941         /*
3942          * if we have explicitlayout or sequentiallayouts, output data in the
3943          * ClassLayout table.
3944          */
3945         if (((tb->attrs & TYPE_ATTRIBUTE_LAYOUT_MASK) != TYPE_ATTRIBUTE_AUTO_LAYOUT) &&
3946                         ((tb->class_size > 0) || (tb->packing_size > 0))) {
3947                 table = &assembly->tables [MONO_TABLE_CLASSLAYOUT];
3948                 table->rows++;
3949                 alloc_table (table, table->rows);
3950                 values = table->values + table->rows * MONO_CLASS_LAYOUT_SIZE;
3951                 values [MONO_CLASS_LAYOUT_PARENT] = tb->table_idx;
3952                 values [MONO_CLASS_LAYOUT_CLASS_SIZE] = tb->class_size;
3953                 values [MONO_CLASS_LAYOUT_PACKING_SIZE] = tb->packing_size;
3954         }
3955
3956         /* handle interfaces */
3957         if (tb->interfaces) {
3958                 table = &assembly->tables [MONO_TABLE_INTERFACEIMPL];
3959                 i = table->rows;
3960                 table->rows += mono_array_length (tb->interfaces);
3961                 alloc_table (table, table->rows);
3962                 values = table->values + (i + 1) * MONO_INTERFACEIMPL_SIZE;
3963                 for (i = 0; i < mono_array_length (tb->interfaces); ++i) {
3964                         MonoReflectionType* iface = (MonoReflectionType*) mono_array_get (tb->interfaces, gpointer, i);
3965                         MonoType *iface_type = mono_reflection_type_get_handle (iface, error);
3966                         return_val_if_nok (error, FALSE);
3967                         values [MONO_INTERFACEIMPL_CLASS] = tb->table_idx;
3968                         values [MONO_INTERFACEIMPL_INTERFACE] = mono_image_typedef_or_ref (assembly, iface_type);
3969                         values += MONO_INTERFACEIMPL_SIZE;
3970                 }
3971         }
3972
3973         /* handle fields */
3974         if (tb->fields) {
3975                 table = &assembly->tables [MONO_TABLE_FIELD];
3976                 table->rows += tb->num_fields;
3977                 alloc_table (table, table->rows);
3978                 for (i = 0; i < tb->num_fields; ++i) {
3979                         mono_image_get_field_info (
3980                                 mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i), assembly, error);
3981                         return_val_if_nok (error, FALSE);
3982                 }
3983         }
3984
3985         /* handle constructors */
3986         if (tb->ctors) {
3987                 table = &assembly->tables [MONO_TABLE_METHOD];
3988                 table->rows += mono_array_length (tb->ctors);
3989                 alloc_table (table, table->rows);
3990                 for (i = 0; i < mono_array_length (tb->ctors); ++i) {
3991                         if (!mono_image_get_ctor_info (domain,
3992                                                        mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i),
3993                                                        assembly, error))
3994                                 return FALSE;
3995                 }
3996         }
3997
3998         /* handle methods */
3999         if (tb->methods) {
4000                 table = &assembly->tables [MONO_TABLE_METHOD];
4001                 table->rows += tb->num_methods;
4002                 alloc_table (table, table->rows);
4003                 for (i = 0; i < tb->num_methods; ++i) {
4004                         if (!mono_image_get_method_info (
4005                                     mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i), assembly, error))
4006                                 return FALSE;
4007                 }
4008         }
4009
4010         /* Do the same with properties etc.. */
4011         if (tb->events && mono_array_length (tb->events)) {
4012                 table = &assembly->tables [MONO_TABLE_EVENT];
4013                 table->rows += mono_array_length (tb->events);
4014                 alloc_table (table, table->rows);
4015                 table = &assembly->tables [MONO_TABLE_EVENTMAP];
4016                 table->rows ++;
4017                 alloc_table (table, table->rows);
4018                 values = table->values + table->rows * MONO_EVENT_MAP_SIZE;
4019                 values [MONO_EVENT_MAP_PARENT] = tb->table_idx;
4020                 values [MONO_EVENT_MAP_EVENTLIST] = assembly->tables [MONO_TABLE_EVENT].next_idx;
4021                 for (i = 0; i < mono_array_length (tb->events); ++i) {
4022                         mono_image_get_event_info (
4023                                 mono_array_get (tb->events, MonoReflectionEventBuilder*, i), assembly, error);
4024                         return_val_if_nok (error, FALSE);
4025                 }
4026         }
4027         if (tb->properties && mono_array_length (tb->properties)) {
4028                 table = &assembly->tables [MONO_TABLE_PROPERTY];
4029                 table->rows += mono_array_length (tb->properties);
4030                 alloc_table (table, table->rows);
4031                 table = &assembly->tables [MONO_TABLE_PROPERTYMAP];
4032                 table->rows ++;
4033                 alloc_table (table, table->rows);
4034                 values = table->values + table->rows * MONO_PROPERTY_MAP_SIZE;
4035                 values [MONO_PROPERTY_MAP_PARENT] = tb->table_idx;
4036                 values [MONO_PROPERTY_MAP_PROPERTY_LIST] = assembly->tables [MONO_TABLE_PROPERTY].next_idx;
4037                 for (i = 0; i < mono_array_length (tb->properties); ++i) {
4038                         mono_image_get_property_info (
4039                                 mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i), assembly, error);
4040                         return_val_if_nok (error, FALSE);
4041                 }
4042         }
4043
4044         /* handle generic parameters */
4045         if (tb->generic_params) {
4046                 table = &assembly->tables [MONO_TABLE_GENERICPARAM];
4047                 table->rows += mono_array_length (tb->generic_params);
4048                 alloc_table (table, table->rows);
4049                 for (i = 0; i < mono_array_length (tb->generic_params); ++i) {
4050                         guint32 owner = MONO_TYPEORMETHOD_TYPE | (tb->table_idx << MONO_TYPEORMETHOD_BITS);
4051
4052                         mono_image_get_generic_param_info (
4053                                 mono_array_get (tb->generic_params, MonoReflectionGenericParam*, i), owner, assembly);
4054                 }
4055         }
4056
4057         mono_image_add_decl_security (assembly,
4058                 mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx), tb->permissions);
4059
4060         if (tb->subtypes) {
4061                 MonoDynamicTable *ntable;
4062
4063                 ntable = &assembly->tables [MONO_TABLE_NESTEDCLASS];
4064                 ntable->rows += mono_array_length (tb->subtypes);
4065                 alloc_table (ntable, ntable->rows);
4066                 values = ntable->values + ntable->next_idx * MONO_NESTED_CLASS_SIZE;
4067
4068                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
4069                         MonoReflectionTypeBuilder *subtype = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
4070
4071                         values [MONO_NESTED_CLASS_NESTED] = subtype->table_idx;
4072                         values [MONO_NESTED_CLASS_ENCLOSING] = tb->table_idx;
4073                         /*g_print ("nesting %s (%d) in %s (%d) (rows %d/%d)\n",
4074                                 mono_string_to_utf8 (subtype->name), subtype->table_idx,
4075                                 mono_string_to_utf8 (tb->name), tb->table_idx,
4076                                 ntable->next_idx, ntable->rows);*/
4077                         values += MONO_NESTED_CLASS_SIZE;
4078                         ntable->next_idx++;
4079                 }
4080         }
4081
4082         return TRUE;
4083 }
4084 #endif
4085
4086 static void
4087 collect_types (MonoPtrArray *types, MonoReflectionTypeBuilder *type)
4088 {
4089         int i;
4090
4091         mono_ptr_array_append (*types, type);
4092
4093         if (!type->subtypes)
4094                 return;
4095
4096         for (i = 0; i < mono_array_length (type->subtypes); ++i) {
4097                 MonoReflectionTypeBuilder *subtype = mono_array_get (type->subtypes, MonoReflectionTypeBuilder*, i);
4098                 collect_types (types, subtype);
4099         }
4100 }
4101
4102 static gint
4103 compare_types_by_table_idx (MonoReflectionTypeBuilder **type1, MonoReflectionTypeBuilder **type2)
4104 {
4105         if ((*type1)->table_idx < (*type2)->table_idx)
4106                 return -1;
4107         else
4108                 if ((*type1)->table_idx > (*type2)->table_idx)
4109                         return 1;
4110         else
4111                 return 0;
4112 }
4113
4114 static gboolean
4115 params_add_cattrs (MonoDynamicImage *assembly, MonoArray *pinfo, MonoError *error) {
4116         int i;
4117
4118         mono_error_init (error);
4119         if (!pinfo)
4120                 return TRUE;
4121         for (i = 0; i < mono_array_length (pinfo); ++i) {
4122                 MonoReflectionParamBuilder *pb;
4123                 pb = mono_array_get (pinfo, MonoReflectionParamBuilder *, i);
4124                 if (!pb)
4125                         continue;
4126                 if (!mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PARAMDEF, pb->cattrs, error))
4127                         return FALSE;
4128         }
4129
4130         return TRUE;
4131 }
4132
4133 static gboolean
4134 type_add_cattrs (MonoDynamicImage *assembly, MonoReflectionTypeBuilder *tb, MonoError *error) {
4135         int i;
4136
4137         mono_error_init (error);
4138
4139         if (!mono_image_add_cattrs (assembly, tb->table_idx, MONO_CUSTOM_ATTR_TYPEDEF, tb->cattrs, error))
4140                 return FALSE;
4141         if (tb->fields) {
4142                 for (i = 0; i < tb->num_fields; ++i) {
4143                         MonoReflectionFieldBuilder* fb;
4144                         fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, i);
4145                         if (!mono_image_add_cattrs (assembly, fb->table_idx, MONO_CUSTOM_ATTR_FIELDDEF, fb->cattrs, error))
4146                                 return FALSE;
4147                 }
4148         }
4149         if (tb->events) {
4150                 for (i = 0; i < mono_array_length (tb->events); ++i) {
4151                         MonoReflectionEventBuilder* eb;
4152                         eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
4153                         if (!mono_image_add_cattrs (assembly, eb->table_idx, MONO_CUSTOM_ATTR_EVENT, eb->cattrs, error))
4154                                 return FALSE;
4155                 }
4156         }
4157         if (tb->properties) {
4158                 for (i = 0; i < mono_array_length (tb->properties); ++i) {
4159                         MonoReflectionPropertyBuilder* pb;
4160                         pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
4161                         if (!mono_image_add_cattrs (assembly, pb->table_idx, MONO_CUSTOM_ATTR_PROPERTY, pb->cattrs, error))
4162                                 return FALSE;
4163                 }
4164         }
4165         if (tb->ctors) {
4166                 for (i = 0; i < mono_array_length (tb->ctors); ++i) {
4167                         MonoReflectionCtorBuilder* cb;
4168                         cb = mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i);
4169                         if (!mono_image_add_cattrs (assembly, cb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, cb->cattrs, error) ||
4170                             !params_add_cattrs (assembly, cb->pinfo, error))
4171                                 return FALSE;
4172                 }
4173         }
4174
4175         if (tb->methods) {
4176                 for (i = 0; i < tb->num_methods; ++i) {
4177                         MonoReflectionMethodBuilder* mb;
4178                         mb = mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
4179                         if (!mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, mb->cattrs, error) ||
4180                             !params_add_cattrs (assembly, mb->pinfo, error))
4181                                 return FALSE;
4182                 }
4183         }
4184
4185         if (tb->subtypes) {
4186                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
4187                         if (!type_add_cattrs (assembly, mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i), error))
4188                                 return FALSE;
4189                 }
4190         }
4191
4192         return TRUE;
4193 }
4194
4195 static gboolean
4196 module_add_cattrs (MonoDynamicImage *assembly, MonoReflectionModuleBuilder *moduleb, MonoError *error)
4197 {
4198         int i;
4199
4200         mono_error_init (error);
4201
4202         if (!mono_image_add_cattrs (assembly, moduleb->table_idx, MONO_CUSTOM_ATTR_MODULE, moduleb->cattrs, error))
4203                 return FALSE;
4204
4205         if (moduleb->global_methods) {
4206                 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
4207                         MonoReflectionMethodBuilder* mb = mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i);
4208                         if (!mono_image_add_cattrs (assembly, mb->table_idx, MONO_CUSTOM_ATTR_METHODDEF, mb->cattrs, error) ||
4209                             !params_add_cattrs (assembly, mb->pinfo, error))
4210                                 return FALSE;
4211                 }
4212         }
4213
4214         if (moduleb->global_fields) {
4215                 for (i = 0; i < mono_array_length (moduleb->global_fields); ++i) {
4216                         MonoReflectionFieldBuilder *fb = mono_array_get (moduleb->global_fields, MonoReflectionFieldBuilder*, i);
4217                         if (!mono_image_add_cattrs (assembly, fb->table_idx, MONO_CUSTOM_ATTR_FIELDDEF, fb->cattrs, error))
4218                                 return FALSE;
4219                 }
4220         }
4221
4222         if (moduleb->types) {
4223                 for (i = 0; i < moduleb->num_types; ++i) {
4224                         if (!type_add_cattrs (assembly, mono_array_get (moduleb->types, MonoReflectionTypeBuilder*, i), error))
4225                                 return FALSE;
4226                 }
4227         }
4228
4229         return TRUE;
4230 }
4231
4232 static void
4233 mono_image_fill_file_table (MonoDomain *domain, MonoReflectionModule *module, MonoDynamicImage *assembly)
4234 {
4235         MonoDynamicTable *table;
4236         guint32 *values;
4237         char blob_size [6];
4238         guchar hash [20];
4239         char *b = blob_size;
4240         char *dir, *path;
4241
4242         table = &assembly->tables [MONO_TABLE_FILE];
4243         table->rows++;
4244         alloc_table (table, table->rows);
4245         values = table->values + table->next_idx * MONO_FILE_SIZE;
4246         values [MONO_FILE_FLAGS] = FILE_CONTAINS_METADATA;
4247         values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, module->image->module_name);
4248         if (image_is_dynamic (module->image)) {
4249                 /* This depends on the fact that the main module is emitted last */
4250                 dir = mono_string_to_utf8 (((MonoReflectionModuleBuilder*)module)->assemblyb->dir);
4251                 path = g_strdup_printf ("%s%c%s", dir, G_DIR_SEPARATOR, module->image->module_name);
4252         } else {
4253                 dir = NULL;
4254                 path = g_strdup (module->image->name);
4255         }
4256         mono_sha1_get_digest_from_file (path, hash);
4257         g_free (dir);
4258         g_free (path);
4259         mono_metadata_encode_value (20, b, &b);
4260         values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
4261         mono_image_add_stream_data (&assembly->blob, (char*)hash, 20);
4262         table->next_idx ++;
4263 }
4264
4265 static void
4266 mono_image_fill_module_table (MonoDomain *domain, MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly)
4267 {
4268         MonoDynamicTable *table;
4269         int i;
4270
4271         table = &assembly->tables [MONO_TABLE_MODULE];
4272         mb->table_idx = table->next_idx ++;
4273         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_NAME] = string_heap_insert_mstring (&assembly->sheap, mb->module.name);
4274         i = mono_image_add_stream_data (&assembly->guid, mono_array_addr (mb->guid, char, 0), 16);
4275         i /= 16;
4276         ++i;
4277         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_GENERATION] = 0;
4278         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_MVID] = i;
4279         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_ENC] = 0;
4280         table->values [mb->table_idx * MONO_MODULE_SIZE + MONO_MODULE_ENCBASE] = 0;
4281 }
4282
4283 static guint32
4284 mono_image_fill_export_table_from_class (MonoDomain *domain, MonoClass *klass,
4285         guint32 module_index, guint32 parent_index, MonoDynamicImage *assembly)
4286 {
4287         MonoDynamicTable *table;
4288         guint32 *values;
4289         guint32 visib, res;
4290
4291         visib = klass->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK;
4292         if (! ((visib & TYPE_ATTRIBUTE_PUBLIC) || (visib & TYPE_ATTRIBUTE_NESTED_PUBLIC)))
4293                 return 0;
4294
4295         table = &assembly->tables [MONO_TABLE_EXPORTEDTYPE];
4296         table->rows++;
4297         alloc_table (table, table->rows);
4298         values = table->values + table->next_idx * MONO_EXP_TYPE_SIZE;
4299
4300         values [MONO_EXP_TYPE_FLAGS] = klass->flags;
4301         values [MONO_EXP_TYPE_TYPEDEF] = klass->type_token;
4302         if (klass->nested_in)
4303                 values [MONO_EXP_TYPE_IMPLEMENTATION] = (parent_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_EXP_TYPE;
4304         else
4305                 values [MONO_EXP_TYPE_IMPLEMENTATION] = (module_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_FILE;
4306         values [MONO_EXP_TYPE_NAME] = string_heap_insert (&assembly->sheap, klass->name);
4307         values [MONO_EXP_TYPE_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
4308
4309         res = table->next_idx;
4310
4311         table->next_idx ++;
4312
4313         /* Emit nested types */
4314         if (klass->ext && klass->ext->nested_classes) {
4315                 GList *tmp;
4316
4317                 for (tmp = klass->ext->nested_classes; tmp; tmp = tmp->next)
4318                         mono_image_fill_export_table_from_class (domain, (MonoClass *)tmp->data, module_index, table->next_idx - 1, assembly);
4319         }
4320
4321         return res;
4322 }
4323
4324 static void
4325 mono_image_fill_export_table (MonoDomain *domain, MonoReflectionTypeBuilder *tb,
4326                               guint32 module_index, guint32 parent_index, MonoDynamicImage *assembly,
4327                               MonoError *error)
4328 {
4329         MonoClass *klass;
4330         guint32 idx, i;
4331
4332         mono_error_init (error);
4333
4334         MonoType *t = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error);
4335         return_if_nok (error);
4336
4337         klass = mono_class_from_mono_type (t);
4338
4339         klass->type_token = mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx);
4340
4341         idx = mono_image_fill_export_table_from_class (domain, klass, module_index,
4342                                                                                                    parent_index, assembly);
4343
4344         /*
4345          * Emit nested types
4346          * We need to do this ourselves since klass->nested_classes is not set up.
4347          */
4348         if (tb->subtypes) {
4349                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
4350                         mono_image_fill_export_table (domain, mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i), module_index, idx, assembly, error);
4351                         return_if_nok (error);
4352                 }
4353         }
4354 }
4355
4356 static void
4357 mono_image_fill_export_table_from_module (MonoDomain *domain, MonoReflectionModule *module,
4358         guint32 module_index, MonoDynamicImage *assembly)
4359 {
4360         MonoImage *image = module->image;
4361         MonoTableInfo  *t;
4362         guint32 i;
4363
4364         t = &image->tables [MONO_TABLE_TYPEDEF];
4365
4366         for (i = 0; i < t->rows; ++i) {
4367                 MonoError error;
4368                 MonoClass *klass = mono_class_get_checked (image, mono_metadata_make_token (MONO_TABLE_TYPEDEF, i + 1), &error);
4369                 g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
4370
4371                 if (klass->flags & TYPE_ATTRIBUTE_PUBLIC)
4372                         mono_image_fill_export_table_from_class (domain, klass, module_index, 0, assembly);
4373         }
4374 }
4375
4376 static void
4377 add_exported_type (MonoReflectionAssemblyBuilder *assemblyb, MonoDynamicImage *assembly, MonoClass *klass, guint32 parent_index)
4378 {
4379         MonoDynamicTable *table;
4380         guint32 *values;
4381         guint32 scope, scope_idx, impl, current_idx;
4382         gboolean forwarder = TRUE;
4383         gpointer iter = NULL;
4384         MonoClass *nested;
4385
4386         if (klass->nested_in) {
4387                 impl = (parent_index << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_EXP_TYPE;
4388                 forwarder = FALSE;
4389         } else {
4390                 scope = resolution_scope_from_image (assembly, klass->image);
4391                 g_assert ((scope & MONO_RESOLUTION_SCOPE_MASK) == MONO_RESOLUTION_SCOPE_ASSEMBLYREF);
4392                 scope_idx = scope >> MONO_RESOLUTION_SCOPE_BITS;
4393                 impl = (scope_idx << MONO_IMPLEMENTATION_BITS) + MONO_IMPLEMENTATION_ASSEMBLYREF;
4394         }
4395
4396         table = &assembly->tables [MONO_TABLE_EXPORTEDTYPE];
4397
4398         table->rows++;
4399         alloc_table (table, table->rows);
4400         current_idx = table->next_idx;
4401         values = table->values + current_idx * MONO_EXP_TYPE_SIZE;
4402
4403         values [MONO_EXP_TYPE_FLAGS] = forwarder ? TYPE_ATTRIBUTE_FORWARDER : 0;
4404         values [MONO_EXP_TYPE_TYPEDEF] = 0;
4405         values [MONO_EXP_TYPE_IMPLEMENTATION] = impl;
4406         values [MONO_EXP_TYPE_NAME] = string_heap_insert (&assembly->sheap, klass->name);
4407         values [MONO_EXP_TYPE_NAMESPACE] = string_heap_insert (&assembly->sheap, klass->name_space);
4408
4409         table->next_idx++;
4410
4411         while ((nested = mono_class_get_nested_types (klass, &iter)))
4412                 add_exported_type (assemblyb, assembly, nested, current_idx);
4413 }
4414
4415 static void
4416 mono_image_fill_export_table_from_type_forwarders (MonoReflectionAssemblyBuilder *assemblyb, MonoDynamicImage *assembly)
4417 {
4418         MonoError error;
4419         MonoClass *klass;
4420         int i;
4421
4422         if (!assemblyb->type_forwarders)
4423                 return;
4424
4425         for (i = 0; i < mono_array_length (assemblyb->type_forwarders); ++i) {
4426                 MonoReflectionType *t = mono_array_get (assemblyb->type_forwarders, MonoReflectionType *, i);
4427                 MonoType *type;
4428                 if (!t)
4429                         continue;
4430
4431                 type = mono_reflection_type_get_handle (t, &error);
4432                 mono_error_assert_ok (&error);
4433                 g_assert (type);
4434
4435                 klass = mono_class_from_mono_type (type);
4436
4437                 add_exported_type (assemblyb, assembly, klass, 0);
4438         }
4439 }
4440
4441 #define align_pointer(base,p)\
4442         do {\
4443                 guint32 __diff = (unsigned char*)(p)-(unsigned char*)(base);\
4444                 if (__diff & 3)\
4445                         (p) += 4 - (__diff & 3);\
4446         } while (0)
4447
4448 static int
4449 compare_constants (const void *a, const void *b)
4450 {
4451         const guint32 *a_values = (const guint32 *)a;
4452         const guint32 *b_values = (const guint32 *)b;
4453         return a_values [MONO_CONSTANT_PARENT] - b_values [MONO_CONSTANT_PARENT];
4454 }
4455
4456 static int
4457 compare_semantics (const void *a, const void *b)
4458 {
4459         const guint32 *a_values = (const guint32 *)a;
4460         const guint32 *b_values = (const guint32 *)b;
4461         int assoc = a_values [MONO_METHOD_SEMA_ASSOCIATION] - b_values [MONO_METHOD_SEMA_ASSOCIATION];
4462         if (assoc)
4463                 return assoc;
4464         return a_values [MONO_METHOD_SEMA_SEMANTICS] - b_values [MONO_METHOD_SEMA_SEMANTICS];
4465 }
4466
4467 static int
4468 compare_custom_attrs (const void *a, const void *b)
4469 {
4470         const guint32 *a_values = (const guint32 *)a;
4471         const guint32 *b_values = (const guint32 *)b;
4472
4473         return a_values [MONO_CUSTOM_ATTR_PARENT] - b_values [MONO_CUSTOM_ATTR_PARENT];
4474 }
4475
4476 static int
4477 compare_field_marshal (const void *a, const void *b)
4478 {
4479         const guint32 *a_values = (const guint32 *)a;
4480         const guint32 *b_values = (const guint32 *)b;
4481
4482         return a_values [MONO_FIELD_MARSHAL_PARENT] - b_values [MONO_FIELD_MARSHAL_PARENT];
4483 }
4484
4485 static int
4486 compare_nested (const void *a, const void *b)
4487 {
4488         const guint32 *a_values = (const guint32 *)a;
4489         const guint32 *b_values = (const guint32 *)b;
4490
4491         return a_values [MONO_NESTED_CLASS_NESTED] - b_values [MONO_NESTED_CLASS_NESTED];
4492 }
4493
4494 static int
4495 compare_genericparam (const void *a, const void *b)
4496 {
4497         MonoError error;
4498         const GenericParamTableEntry **a_entry = (const GenericParamTableEntry **) a;
4499         const GenericParamTableEntry **b_entry = (const GenericParamTableEntry **) b;
4500
4501         if ((*b_entry)->owner == (*a_entry)->owner) {
4502                 MonoType *a_type = mono_reflection_type_get_handle ((MonoReflectionType*)(*a_entry)->gparam, &error);
4503                 mono_error_assert_ok (&error);
4504                 MonoType *b_type = mono_reflection_type_get_handle ((MonoReflectionType*)(*b_entry)->gparam, &error);
4505                 mono_error_assert_ok (&error);
4506                 return
4507                         mono_type_get_generic_param_num (a_type) -
4508                         mono_type_get_generic_param_num (b_type);
4509         } else
4510                 return (*a_entry)->owner - (*b_entry)->owner;
4511 }
4512
4513 static int
4514 compare_declsecurity_attrs (const void *a, const void *b)
4515 {
4516         const guint32 *a_values = (const guint32 *)a;
4517         const guint32 *b_values = (const guint32 *)b;
4518
4519         return a_values [MONO_DECL_SECURITY_PARENT] - b_values [MONO_DECL_SECURITY_PARENT];
4520 }
4521
4522 static int
4523 compare_interface_impl (const void *a, const void *b)
4524 {
4525         const guint32 *a_values = (const guint32 *)a;
4526         const guint32 *b_values = (const guint32 *)b;
4527
4528         int klass = a_values [MONO_INTERFACEIMPL_CLASS] - b_values [MONO_INTERFACEIMPL_CLASS];
4529         if (klass)
4530                 return klass;
4531
4532         return a_values [MONO_INTERFACEIMPL_INTERFACE] - b_values [MONO_INTERFACEIMPL_INTERFACE];
4533 }
4534
4535 static void
4536 pad_heap (MonoDynamicStream *sh)
4537 {
4538         if (sh->index & 3) {
4539                 int sz = 4 - (sh->index & 3);
4540                 memset (sh->data + sh->index, 0, sz);
4541                 sh->index += sz;
4542         }
4543 }
4544
4545 struct StreamDesc {
4546         const char *name;
4547         MonoDynamicStream *stream;
4548 };
4549
4550 /*
4551  * build_compressed_metadata() fills in the blob of data that represents the
4552  * raw metadata as it will be saved in the PE file. The five streams are output
4553  * and the metadata tables are comnpressed from the guint32 array representation,
4554  * to the compressed on-disk format.
4555  */
4556 static gboolean
4557 build_compressed_metadata (MonoDynamicImage *assembly, MonoError *error)
4558 {
4559         MonoDynamicTable *table;
4560         int i;
4561         guint64 valid_mask = 0;
4562         guint64 sorted_mask;
4563         guint32 heapt_size = 0;
4564         guint32 meta_size = 256; /* allow for header and other stuff */
4565         guint32 table_offset;
4566         guint32 ntables = 0;
4567         guint64 *int64val;
4568         guint32 *int32val;
4569         guint16 *int16val;
4570         MonoImage *meta;
4571         unsigned char *p;
4572         struct StreamDesc stream_desc [5];
4573
4574         mono_error_init (error);
4575
4576         qsort (assembly->gen_params->pdata, assembly->gen_params->len, sizeof (gpointer), compare_genericparam);
4577         for (i = 0; i < assembly->gen_params->len; i++) {
4578                 GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (assembly->gen_params, i);
4579                 if (!write_generic_param_entry (assembly, entry, error))
4580                         return FALSE;
4581         }
4582
4583         stream_desc [0].name  = "#~";
4584         stream_desc [0].stream = &assembly->tstream;
4585         stream_desc [1].name  = "#Strings";
4586         stream_desc [1].stream = &assembly->sheap;
4587         stream_desc [2].name  = "#US";
4588         stream_desc [2].stream = &assembly->us;
4589         stream_desc [3].name  = "#Blob";
4590         stream_desc [3].stream = &assembly->blob;
4591         stream_desc [4].name  = "#GUID";
4592         stream_desc [4].stream = &assembly->guid;
4593
4594         /* tables that are sorted */
4595         sorted_mask = ((guint64)1 << MONO_TABLE_CONSTANT) | ((guint64)1 << MONO_TABLE_FIELDMARSHAL)
4596                 | ((guint64)1 << MONO_TABLE_METHODSEMANTICS) | ((guint64)1 << MONO_TABLE_CLASSLAYOUT)
4597                 | ((guint64)1 << MONO_TABLE_FIELDLAYOUT) | ((guint64)1 << MONO_TABLE_FIELDRVA)
4598                 | ((guint64)1 << MONO_TABLE_IMPLMAP) | ((guint64)1 << MONO_TABLE_NESTEDCLASS)
4599                 | ((guint64)1 << MONO_TABLE_METHODIMPL) | ((guint64)1 << MONO_TABLE_CUSTOMATTRIBUTE)
4600                 | ((guint64)1 << MONO_TABLE_DECLSECURITY) | ((guint64)1 << MONO_TABLE_GENERICPARAM)
4601                 | ((guint64)1 << MONO_TABLE_INTERFACEIMPL);
4602
4603         /* Compute table sizes */
4604         /* the MonoImage has already been created in mono_image_basic_init() */
4605         meta = &assembly->image;
4606
4607         /* sizes should be multiple of 4 */
4608         pad_heap (&assembly->blob);
4609         pad_heap (&assembly->guid);
4610         pad_heap (&assembly->sheap);
4611         pad_heap (&assembly->us);
4612
4613         /* Setup the info used by compute_sizes () */
4614         meta->idx_blob_wide = assembly->blob.index >= 65536 ? 1 : 0;
4615         meta->idx_guid_wide = assembly->guid.index >= 65536 ? 1 : 0;
4616         meta->idx_string_wide = assembly->sheap.index >= 65536 ? 1 : 0;
4617
4618         meta_size += assembly->blob.index;
4619         meta_size += assembly->guid.index;
4620         meta_size += assembly->sheap.index;
4621         meta_size += assembly->us.index;
4622
4623         for (i=0; i < MONO_TABLE_NUM; ++i)
4624                 meta->tables [i].rows = assembly->tables [i].rows;
4625
4626         for (i = 0; i < MONO_TABLE_NUM; i++){
4627                 if (meta->tables [i].rows == 0)
4628                         continue;
4629                 valid_mask |= (guint64)1 << i;
4630                 ntables ++;
4631                 meta->tables [i].row_size = mono_metadata_compute_size (
4632                         meta, i, &meta->tables [i].size_bitfield);
4633                 heapt_size += meta->tables [i].row_size * meta->tables [i].rows;
4634         }
4635         heapt_size += 24; /* #~ header size */
4636         heapt_size += ntables * 4;
4637         /* make multiple of 4 */
4638         heapt_size += 3;
4639         heapt_size &= ~3;
4640         meta_size += heapt_size;
4641         meta->raw_metadata = (char *)g_malloc0 (meta_size);
4642         p = (unsigned char*)meta->raw_metadata;
4643         /* the metadata signature */
4644         *p++ = 'B'; *p++ = 'S'; *p++ = 'J'; *p++ = 'B';
4645         /* version numbers and 4 bytes reserved */
4646         int16val = (guint16*)p;
4647         *int16val++ = GUINT16_TO_LE (meta->md_version_major);
4648         *int16val = GUINT16_TO_LE (meta->md_version_minor);
4649         p += 8;
4650         /* version string */
4651         int32val = (guint32*)p;
4652         *int32val = GUINT32_TO_LE ((strlen (meta->version) + 3) & (~3)); /* needs to be multiple of 4 */
4653         p += 4;
4654         memcpy (p, meta->version, strlen (meta->version));
4655         p += GUINT32_FROM_LE (*int32val);
4656         align_pointer (meta->raw_metadata, p);
4657         int16val = (guint16*)p;
4658         *int16val++ = GUINT16_TO_LE (0); /* flags must be 0 */
4659         *int16val = GUINT16_TO_LE (5); /* number of streams */
4660         p += 4;
4661
4662         /*
4663          * write the stream info.
4664          */
4665         table_offset = (p - (unsigned char*)meta->raw_metadata) + 5 * 8 + 40; /* room needed for stream headers */
4666         table_offset += 3; table_offset &= ~3;
4667
4668         assembly->tstream.index = heapt_size;
4669         for (i = 0; i < 5; ++i) {
4670                 int32val = (guint32*)p;
4671                 stream_desc [i].stream->offset = table_offset;
4672                 *int32val++ = GUINT32_TO_LE (table_offset);
4673                 *int32val = GUINT32_TO_LE (stream_desc [i].stream->index);
4674                 table_offset += GUINT32_FROM_LE (*int32val);
4675                 table_offset += 3; table_offset &= ~3;
4676                 p += 8;
4677                 strcpy ((char*)p, stream_desc [i].name);
4678                 p += strlen (stream_desc [i].name) + 1;
4679                 align_pointer (meta->raw_metadata, p);
4680         }
4681         /*
4682          * now copy the data, the table stream header and contents goes first.
4683          */
4684         g_assert ((p - (unsigned char*)meta->raw_metadata) < assembly->tstream.offset);
4685         p = (guchar*)meta->raw_metadata + assembly->tstream.offset;
4686         int32val = (guint32*)p;
4687         *int32val = GUINT32_TO_LE (0); /* reserved */
4688         p += 4;
4689
4690         *p++ = 2; /* version */
4691         *p++ = 0;
4692
4693         if (meta->idx_string_wide)
4694                 *p |= 0x01;
4695         if (meta->idx_guid_wide)
4696                 *p |= 0x02;
4697         if (meta->idx_blob_wide)
4698                 *p |= 0x04;
4699         ++p;
4700         *p++ = 1; /* reserved */
4701         int64val = (guint64*)p;
4702         *int64val++ = GUINT64_TO_LE (valid_mask);
4703         *int64val++ = GUINT64_TO_LE (valid_mask & sorted_mask); /* bitvector of sorted tables  */
4704         p += 16;
4705         int32val = (guint32*)p;
4706         for (i = 0; i < MONO_TABLE_NUM; i++){
4707                 if (meta->tables [i].rows == 0)
4708                         continue;
4709                 *int32val++ = GUINT32_TO_LE (meta->tables [i].rows);
4710         }
4711         p = (unsigned char*)int32val;
4712
4713         /* sort the tables that still need sorting */
4714         table = &assembly->tables [MONO_TABLE_CONSTANT];
4715         if (table->rows)
4716                 qsort (table->values + MONO_CONSTANT_SIZE, table->rows, sizeof (guint32) * MONO_CONSTANT_SIZE, compare_constants);
4717         table = &assembly->tables [MONO_TABLE_METHODSEMANTICS];
4718         if (table->rows)
4719                 qsort (table->values + MONO_METHOD_SEMA_SIZE, table->rows, sizeof (guint32) * MONO_METHOD_SEMA_SIZE, compare_semantics);
4720         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
4721         if (table->rows)
4722                 qsort (table->values + MONO_CUSTOM_ATTR_SIZE, table->rows, sizeof (guint32) * MONO_CUSTOM_ATTR_SIZE, compare_custom_attrs);
4723         table = &assembly->tables [MONO_TABLE_FIELDMARSHAL];
4724         if (table->rows)
4725                 qsort (table->values + MONO_FIELD_MARSHAL_SIZE, table->rows, sizeof (guint32) * MONO_FIELD_MARSHAL_SIZE, compare_field_marshal);
4726         table = &assembly->tables [MONO_TABLE_NESTEDCLASS];
4727         if (table->rows)
4728                 qsort (table->values + MONO_NESTED_CLASS_SIZE, table->rows, sizeof (guint32) * MONO_NESTED_CLASS_SIZE, compare_nested);
4729         /* Section 21.11 DeclSecurity in Partition II doesn't specify this to be sorted by MS implementation requires it */
4730         table = &assembly->tables [MONO_TABLE_DECLSECURITY];
4731         if (table->rows)
4732                 qsort (table->values + MONO_DECL_SECURITY_SIZE, table->rows, sizeof (guint32) * MONO_DECL_SECURITY_SIZE, compare_declsecurity_attrs);
4733         table = &assembly->tables [MONO_TABLE_INTERFACEIMPL];
4734         if (table->rows)
4735                 qsort (table->values + MONO_INTERFACEIMPL_SIZE, table->rows, sizeof (guint32) * MONO_INTERFACEIMPL_SIZE, compare_interface_impl);
4736
4737         /* compress the tables */
4738         for (i = 0; i < MONO_TABLE_NUM; i++){
4739                 int row, col;
4740                 guint32 *values;
4741                 guint32 bitfield = meta->tables [i].size_bitfield;
4742                 if (!meta->tables [i].rows)
4743                         continue;
4744                 if (assembly->tables [i].columns != mono_metadata_table_count (bitfield))
4745                         g_error ("col count mismatch in %d: %d %d", i, assembly->tables [i].columns, mono_metadata_table_count (bitfield));
4746                 meta->tables [i].base = (char*)p;
4747                 for (row = 1; row <= meta->tables [i].rows; ++row) {
4748                         values = assembly->tables [i].values + row * assembly->tables [i].columns;
4749                         for (col = 0; col < assembly->tables [i].columns; ++col) {
4750                                 switch (mono_metadata_table_size (bitfield, col)) {
4751                                 case 1:
4752                                         *p++ = values [col];
4753                                         break;
4754                                 case 2:
4755                                         *p++ = values [col] & 0xff;
4756                                         *p++ = (values [col] >> 8) & 0xff;
4757                                         break;
4758                                 case 4:
4759                                         *p++ = values [col] & 0xff;
4760                                         *p++ = (values [col] >> 8) & 0xff;
4761                                         *p++ = (values [col] >> 16) & 0xff;
4762                                         *p++ = (values [col] >> 24) & 0xff;
4763                                         break;
4764                                 default:
4765                                         g_assert_not_reached ();
4766                                 }
4767                         }
4768                 }
4769                 g_assert ((p - (const unsigned char*)meta->tables [i].base) == (meta->tables [i].rows * meta->tables [i].row_size));
4770         }
4771
4772         g_assert (assembly->guid.offset + assembly->guid.index < meta_size);
4773         memcpy (meta->raw_metadata + assembly->sheap.offset, assembly->sheap.data, assembly->sheap.index);
4774         memcpy (meta->raw_metadata + assembly->us.offset, assembly->us.data, assembly->us.index);
4775         memcpy (meta->raw_metadata + assembly->blob.offset, assembly->blob.data, assembly->blob.index);
4776         memcpy (meta->raw_metadata + assembly->guid.offset, assembly->guid.data, assembly->guid.index);
4777
4778         assembly->meta_size = assembly->guid.offset + assembly->guid.index;
4779
4780         return TRUE;
4781 }
4782
4783 /*
4784  * Some tables in metadata need to be sorted according to some criteria, but
4785  * when methods and fields are first created with reflection, they may be assigned a token
4786  * that doesn't correspond to the final token they will get assigned after the sorting.
4787  * ILGenerator.cs keeps a fixup table that maps the position of tokens in the IL code stream
4788  * with the reflection objects that represent them. Once all the tables are set up, the
4789  * reflection objects will contains the correct table index. fixup_method() will fixup the
4790  * tokens for the method with ILGenerator @ilgen.
4791  */
4792 static void
4793 fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *assembly)
4794 {
4795         guint32 code_idx = GPOINTER_TO_UINT (value);
4796         MonoReflectionILTokenInfo *iltoken;
4797         MonoReflectionFieldBuilder *field;
4798         MonoReflectionCtorBuilder *ctor;
4799         MonoReflectionMethodBuilder *method;
4800         MonoReflectionTypeBuilder *tb;
4801         MonoReflectionArrayMethod *am;
4802         guint32 i, idx = 0;
4803         unsigned char *target;
4804
4805         for (i = 0; i < ilgen->num_token_fixups; ++i) {
4806                 iltoken = (MonoReflectionILTokenInfo *)mono_array_addr_with_size (ilgen->token_fixups, sizeof (MonoReflectionILTokenInfo), i);
4807                 target = (guchar*)assembly->code.data + code_idx + iltoken->code_pos;
4808                 switch (target [3]) {
4809                 case MONO_TABLE_FIELD:
4810                         if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
4811                                 field = (MonoReflectionFieldBuilder *)iltoken->member;
4812                                 idx = field->table_idx;
4813                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) {
4814                                 MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field;
4815                                 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->field_to_table_idx, f));
4816                         } else {
4817                                 g_assert_not_reached ();
4818                         }
4819                         break;
4820                 case MONO_TABLE_METHOD:
4821                         if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) {
4822                                 method = (MonoReflectionMethodBuilder *)iltoken->member;
4823                                 idx = method->table_idx;
4824                         } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) {
4825                                 ctor = (MonoReflectionCtorBuilder *)iltoken->member;
4826                                 idx = ctor->table_idx;
4827                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
4828                                            !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) {
4829                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
4830                                 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
4831                         } else {
4832                                 g_assert_not_reached ();
4833                         }
4834                         break;
4835                 case MONO_TABLE_TYPEDEF:
4836                         if (strcmp (iltoken->member->vtable->klass->name, "TypeBuilder"))
4837                                 g_assert_not_reached ();
4838                         tb = (MonoReflectionTypeBuilder *)iltoken->member;
4839                         idx = tb->table_idx;
4840                         break;
4841                 case MONO_TABLE_MEMBERREF:
4842                         if (!strcmp (iltoken->member->vtable->klass->name, "MonoArrayMethod")) {
4843                                 am = (MonoReflectionArrayMethod*)iltoken->member;
4844                                 idx = am->table_idx;
4845                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") ||
4846                                    !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod") ||
4847                                    !strcmp (iltoken->member->vtable->klass->name, "MonoGenericMethod") ||
4848                                    !strcmp (iltoken->member->vtable->klass->name, "MonoGenericCMethod")) {
4849                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
4850                                 g_assert (m->klass->generic_class || m->klass->generic_container);
4851                                 continue;
4852                         } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) {
4853                                 continue;
4854                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) {
4855                                 MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field;
4856                                 g_assert (is_field_on_inst (f));
4857                                 continue;
4858                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder") ||
4859                                         !strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) {
4860                                 continue;
4861                         } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldOnTypeBuilderInst")) {
4862                                 continue;
4863                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodOnTypeBuilderInst")) {
4864                                 continue;
4865                         } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorOnTypeBuilderInst")) {
4866                                 continue;
4867                         } else {
4868                                 g_assert_not_reached ();
4869                         }
4870                         break;
4871                 case MONO_TABLE_METHODSPEC:
4872                         if (!strcmp (iltoken->member->vtable->klass->name, "MonoGenericMethod")) {
4873                                 MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method;
4874                                 g_assert (mono_method_signature (m)->generic_param_count);
4875                                 continue;
4876                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) {
4877                                 continue;
4878                         } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodOnTypeBuilderInst")) {
4879                                 continue;
4880                         } else {
4881                                 g_assert_not_reached ();
4882                         }
4883                         break;
4884                 default:
4885                         g_error ("got unexpected table 0x%02x in fixup", target [3]);
4886                 }
4887                 target [0] = idx & 0xff;
4888                 target [1] = (idx >> 8) & 0xff;
4889                 target [2] = (idx >> 16) & 0xff;
4890         }
4891 }
4892
4893 /*
4894  * fixup_cattrs:
4895  *
4896  *   The CUSTOM_ATTRIBUTE table might contain METHODDEF tokens whose final
4897  * value is not known when the table is emitted.
4898  */
4899 static void
4900 fixup_cattrs (MonoDynamicImage *assembly)
4901 {
4902         MonoDynamicTable *table;
4903         guint32 *values;
4904         guint32 type, i, idx, token;
4905         MonoObject *ctor;
4906
4907         table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE];
4908
4909         for (i = 0; i < table->rows; ++i) {
4910                 values = table->values + ((i + 1) * MONO_CUSTOM_ATTR_SIZE);
4911
4912                 type = values [MONO_CUSTOM_ATTR_TYPE];
4913                 if ((type & MONO_CUSTOM_ATTR_TYPE_MASK) == MONO_CUSTOM_ATTR_TYPE_METHODDEF) {
4914                         idx = type >> MONO_CUSTOM_ATTR_TYPE_BITS;
4915                         token = mono_metadata_make_token (MONO_TABLE_METHOD, idx);
4916                         ctor = (MonoObject *)mono_g_hash_table_lookup (assembly->remapped_tokens, GUINT_TO_POINTER (token));
4917                         g_assert (ctor);
4918
4919                         if (!strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
4920                                 MonoMethod *m = ((MonoReflectionMethod*)ctor)->method;
4921                                 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
4922                                 values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
4923                         } else if (!strcmp (ctor->vtable->klass->name, "ConstructorBuilder")) {
4924                                 MonoMethod *m = ((MonoReflectionCtorBuilder*)ctor)->mhandle;
4925                                 idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, m));
4926                                 values [MONO_CUSTOM_ATTR_TYPE] = (idx << MONO_CUSTOM_ATTR_TYPE_BITS) | MONO_CUSTOM_ATTR_TYPE_METHODDEF;
4927                         }
4928                 }
4929         }
4930 }
4931
4932 static void
4933 assembly_add_resource_manifest (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc, guint32 implementation)
4934 {
4935         MonoDynamicTable *table;
4936         guint32 *values;
4937
4938         table = &assembly->tables [MONO_TABLE_MANIFESTRESOURCE];
4939         table->rows++;
4940         alloc_table (table, table->rows);
4941         values = table->values + table->next_idx * MONO_MANIFEST_SIZE;
4942         values [MONO_MANIFEST_OFFSET] = rsrc->offset;
4943         values [MONO_MANIFEST_FLAGS] = rsrc->attrs;
4944         values [MONO_MANIFEST_NAME] = string_heap_insert_mstring (&assembly->sheap, rsrc->name);
4945         values [MONO_MANIFEST_IMPLEMENTATION] = implementation;
4946         table->next_idx++;
4947 }
4948
4949 static void
4950 assembly_add_resource (MonoReflectionModuleBuilder *mb, MonoDynamicImage *assembly, MonoReflectionResource *rsrc)
4951 {
4952         MonoDynamicTable *table;
4953         guint32 *values;
4954         char blob_size [6];
4955         guchar hash [20];
4956         char *b = blob_size;
4957         char *name, *sname;
4958         guint32 idx, offset;
4959
4960         if (rsrc->filename) {
4961                 name = mono_string_to_utf8 (rsrc->filename);
4962                 sname = g_path_get_basename (name);
4963
4964                 table = &assembly->tables [MONO_TABLE_FILE];
4965                 table->rows++;
4966                 alloc_table (table, table->rows);
4967                 values = table->values + table->next_idx * MONO_FILE_SIZE;
4968                 values [MONO_FILE_FLAGS] = FILE_CONTAINS_NO_METADATA;
4969                 values [MONO_FILE_NAME] = string_heap_insert (&assembly->sheap, sname);
4970                 g_free (sname);
4971
4972                 mono_sha1_get_digest_from_file (name, hash);
4973                 mono_metadata_encode_value (20, b, &b);
4974                 values [MONO_FILE_HASH_VALUE] = mono_image_add_stream_data (&assembly->blob, blob_size, b-blob_size);
4975                 mono_image_add_stream_data (&assembly->blob, (char*)hash, 20);
4976                 g_free (name);
4977                 idx = table->next_idx++;
4978                 rsrc->offset = 0;
4979                 idx = MONO_IMPLEMENTATION_FILE | (idx << MONO_IMPLEMENTATION_BITS);
4980         } else {
4981                 char sizebuf [4];
4982                 char *data;
4983                 guint len;
4984                 if (rsrc->data) {
4985                         data = mono_array_addr (rsrc->data, char, 0);
4986                         len = mono_array_length (rsrc->data);
4987                 } else {
4988                         data = NULL;
4989                         len = 0;
4990                 }
4991                 offset = len;
4992                 sizebuf [0] = offset; sizebuf [1] = offset >> 8;
4993                 sizebuf [2] = offset >> 16; sizebuf [3] = offset >> 24;
4994                 rsrc->offset = mono_image_add_stream_data (&assembly->resources, sizebuf, 4);
4995                 mono_image_add_stream_data (&assembly->resources, data, len);
4996
4997                 if (!mb->is_main)
4998                         /*
4999                          * The entry should be emitted into the MANIFESTRESOURCE table of
5000                          * the main module, but that needs to reference the FILE table
5001                          * which isn't emitted yet.
5002                          */
5003                         return;
5004                 else
5005                         idx = 0;
5006         }
5007
5008         assembly_add_resource_manifest (mb, assembly, rsrc, idx);
5009 }
5010
5011 static void
5012 set_version_from_string (MonoString *version, guint32 *values)
5013 {
5014         gchar *ver, *p, *str;
5015         guint32 i;
5016
5017         values [MONO_ASSEMBLY_MAJOR_VERSION] = 0;
5018         values [MONO_ASSEMBLY_MINOR_VERSION] = 0;
5019         values [MONO_ASSEMBLY_REV_NUMBER] = 0;
5020         values [MONO_ASSEMBLY_BUILD_NUMBER] = 0;
5021         if (!version)
5022                 return;
5023         ver = str = mono_string_to_utf8 (version);
5024         for (i = 0; i < 4; ++i) {
5025                 values [MONO_ASSEMBLY_MAJOR_VERSION + i] = strtol (ver, &p, 10);
5026                 switch (*p) {
5027                 case '.':
5028                         p++;
5029                         break;
5030                 case '*':
5031                         /* handle Revision and Build */
5032                         p++;
5033                         break;
5034                 }
5035                 ver = p;
5036         }
5037         g_free (str);
5038 }
5039
5040 static guint32
5041 load_public_key (MonoArray *pkey, MonoDynamicImage *assembly) {
5042         gsize len;
5043         guint32 token = 0;
5044         char blob_size [6];
5045         char *b = blob_size;
5046
5047         if (!pkey)
5048                 return token;
5049
5050         len = mono_array_length (pkey);
5051         mono_metadata_encode_value (len, b, &b);
5052         token = mono_image_add_stream_data (&assembly->blob, blob_size, b - blob_size);
5053         mono_image_add_stream_data (&assembly->blob, mono_array_addr (pkey, char, 0), len);
5054
5055         assembly->public_key = (guint8 *)g_malloc (len);
5056         memcpy (assembly->public_key, mono_array_addr (pkey, char, 0), len);
5057         assembly->public_key_len = len;
5058
5059         /* Special case: check for ECMA key (16 bytes) */
5060         if ((len == MONO_ECMA_KEY_LENGTH) && mono_is_ecma_key (mono_array_addr (pkey, char, 0), len)) {
5061                 /* In this case we must reserve 128 bytes (1024 bits) for the signature */
5062                 assembly->strong_name_size = MONO_DEFAULT_PUBLIC_KEY_LENGTH;
5063         } else if (len >= MONO_PUBLIC_KEY_HEADER_LENGTH + MONO_MINIMUM_PUBLIC_KEY_LENGTH) {
5064                 /* minimum key size (in 2.0) is 384 bits */
5065                 assembly->strong_name_size = len - MONO_PUBLIC_KEY_HEADER_LENGTH;
5066         } else {
5067                 /* FIXME - verifier */
5068                 g_warning ("Invalid public key length: %d bits (total: %d)", (int)MONO_PUBLIC_KEY_BIT_SIZE (len), (int)len);
5069                 assembly->strong_name_size = MONO_DEFAULT_PUBLIC_KEY_LENGTH; /* to be safe */
5070         }
5071         assembly->strong_name = (char *)g_malloc0 (assembly->strong_name_size);
5072
5073         return token;
5074 }
5075
5076 static void
5077 mono_image_emit_manifest (MonoReflectionModuleBuilder *moduleb, MonoError *error)
5078 {
5079         MonoDynamicTable *table;
5080         MonoDynamicImage *assembly;
5081         MonoReflectionAssemblyBuilder *assemblyb;
5082         MonoDomain *domain;
5083         guint32 *values;
5084         int i;
5085         guint32 module_index;
5086
5087         mono_error_init (error);
5088
5089         assemblyb = moduleb->assemblyb;
5090         assembly = moduleb->dynamic_image;
5091         domain = mono_object_domain (assemblyb);
5092
5093         /* Emit ASSEMBLY table */
5094         table = &assembly->tables [MONO_TABLE_ASSEMBLY];
5095         alloc_table (table, 1);
5096         values = table->values + MONO_ASSEMBLY_SIZE;
5097         values [MONO_ASSEMBLY_HASH_ALG] = assemblyb->algid? assemblyb->algid: ASSEMBLY_HASH_SHA1;
5098         values [MONO_ASSEMBLY_NAME] = string_heap_insert_mstring (&assembly->sheap, assemblyb->name);
5099         if (assemblyb->culture) {
5100                 values [MONO_ASSEMBLY_CULTURE] = string_heap_insert_mstring (&assembly->sheap, assemblyb->culture);
5101         } else {
5102                 values [MONO_ASSEMBLY_CULTURE] = string_heap_insert (&assembly->sheap, "");
5103         }
5104         values [MONO_ASSEMBLY_PUBLIC_KEY] = load_public_key (assemblyb->public_key, assembly);
5105         values [MONO_ASSEMBLY_FLAGS] = assemblyb->flags;
5106         set_version_from_string (assemblyb->version, values);
5107
5108         /* Emit FILE + EXPORTED_TYPE table */
5109         module_index = 0;
5110         for (i = 0; i < mono_array_length (assemblyb->modules); ++i) {
5111                 int j;
5112                 MonoReflectionModuleBuilder *file_module =
5113                         mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
5114                 if (file_module != moduleb) {
5115                         mono_image_fill_file_table (domain, (MonoReflectionModule*)file_module, assembly);
5116                         module_index ++;
5117                         if (file_module->types) {
5118                                 for (j = 0; j < file_module->num_types; ++j) {
5119                                         MonoReflectionTypeBuilder *tb = mono_array_get (file_module->types, MonoReflectionTypeBuilder*, j);
5120                                         mono_image_fill_export_table (domain, tb, module_index, 0, assembly, error);
5121                                         return_if_nok (error);
5122                                 }
5123                         }
5124                 }
5125         }
5126         if (assemblyb->loaded_modules) {
5127                 for (i = 0; i < mono_array_length (assemblyb->loaded_modules); ++i) {
5128                         MonoReflectionModule *file_module =
5129                                 mono_array_get (assemblyb->loaded_modules, MonoReflectionModule*, i);
5130                         mono_image_fill_file_table (domain, file_module, assembly);
5131                         module_index ++;
5132                         mono_image_fill_export_table_from_module (domain, file_module, module_index, assembly);
5133                 }
5134         }
5135         if (assemblyb->type_forwarders)
5136                 mono_image_fill_export_table_from_type_forwarders (assemblyb, assembly);
5137
5138         /* Emit MANIFESTRESOURCE table */
5139         module_index = 0;
5140         for (i = 0; i < mono_array_length (assemblyb->modules); ++i) {
5141                 int j;
5142                 MonoReflectionModuleBuilder *file_module =
5143                         mono_array_get (assemblyb->modules, MonoReflectionModuleBuilder*, i);
5144                 /* The table for the main module is emitted later */
5145                 if (file_module != moduleb) {
5146                         module_index ++;
5147                         if (file_module->resources) {
5148                                 int len = mono_array_length (file_module->resources);
5149                                 for (j = 0; j < len; ++j) {
5150                                         MonoReflectionResource* res = (MonoReflectionResource*)mono_array_addr (file_module->resources, MonoReflectionResource, j);
5151                                         assembly_add_resource_manifest (file_module, assembly, res, MONO_IMPLEMENTATION_FILE | (module_index << MONO_IMPLEMENTATION_BITS));
5152                                 }
5153                         }
5154                 }
5155         }
5156 }
5157
5158 #ifndef DISABLE_REFLECTION_EMIT_SAVE
5159
5160 /*
5161  * mono_image_build_metadata() will fill the info in all the needed metadata tables
5162  * for the modulebuilder @moduleb.
5163  * At the end of the process, method and field tokens are fixed up and the
5164  * on-disk compressed metadata representation is created.
5165  * Return TRUE on success, or FALSE on failure and sets @error
5166  */
5167 gboolean
5168 mono_image_build_metadata (MonoReflectionModuleBuilder *moduleb, MonoError *error)
5169 {
5170         MonoDynamicTable *table;
5171         MonoDynamicImage *assembly;
5172         MonoReflectionAssemblyBuilder *assemblyb;
5173         MonoDomain *domain;
5174         MonoPtrArray types;
5175         guint32 *values;
5176         int i, j;
5177
5178         mono_error_init (error);
5179
5180         assemblyb = moduleb->assemblyb;
5181         assembly = moduleb->dynamic_image;
5182         domain = mono_object_domain (assemblyb);
5183
5184         if (assembly->text_rva)
5185                 return TRUE;
5186
5187         assembly->text_rva = START_TEXT_RVA;
5188
5189         if (moduleb->is_main) {
5190                 mono_image_emit_manifest (moduleb, error);
5191                 return_val_if_nok (error, FALSE);
5192         }
5193
5194         table = &assembly->tables [MONO_TABLE_TYPEDEF];
5195         table->rows = 1; /* .<Module> */
5196         table->next_idx++;
5197         alloc_table (table, table->rows);
5198         /*
5199          * Set the first entry.
5200          */
5201         values = table->values + table->columns;
5202         values [MONO_TYPEDEF_FLAGS] = 0;
5203         values [MONO_TYPEDEF_NAME] = string_heap_insert (&assembly->sheap, "<Module>") ;
5204         values [MONO_TYPEDEF_NAMESPACE] = string_heap_insert (&assembly->sheap, "") ;
5205         values [MONO_TYPEDEF_EXTENDS] = 0;
5206         values [MONO_TYPEDEF_FIELD_LIST] = 1;
5207         values [MONO_TYPEDEF_METHOD_LIST] = 1;
5208
5209         /*
5210          * handle global methods
5211          * FIXME: test what to do when global methods are defined in multiple modules.
5212          */
5213         if (moduleb->global_methods) {
5214                 table = &assembly->tables [MONO_TABLE_METHOD];
5215                 table->rows += mono_array_length (moduleb->global_methods);
5216                 alloc_table (table, table->rows);
5217                 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
5218                         if (!mono_image_get_method_info (
5219                                     mono_array_get (moduleb->global_methods, MonoReflectionMethodBuilder*, i), assembly, error))
5220                                 goto leave;
5221                 }
5222         }
5223         if (moduleb->global_fields) {
5224                 table = &assembly->tables [MONO_TABLE_FIELD];
5225                 table->rows += mono_array_length (moduleb->global_fields);
5226                 alloc_table (table, table->rows);
5227                 for (i = 0; i < mono_array_length (moduleb->global_fields); ++i) {
5228                         mono_image_get_field_info (
5229                                 mono_array_get (moduleb->global_fields, MonoReflectionFieldBuilder*, i), assembly,
5230                                 error);
5231                         if (!is_ok (error))
5232                                 goto leave;
5233                 }
5234         }
5235
5236         table = &assembly->tables [MONO_TABLE_MODULE];
5237         alloc_table (table, 1);
5238         mono_image_fill_module_table (domain, moduleb, assembly);
5239
5240         /* Collect all types into a list sorted by their table_idx */
5241         mono_ptr_array_init (types, moduleb->num_types, MONO_ROOT_SOURCE_REFLECTION, "dynamic module types list");
5242
5243         if (moduleb->types)
5244                 for (i = 0; i < moduleb->num_types; ++i) {
5245                         MonoReflectionTypeBuilder *type = mono_array_get (moduleb->types, MonoReflectionTypeBuilder*, i);
5246                         collect_types (&types, type);
5247                 }
5248
5249         mono_ptr_array_sort (types, (int (*)(const void *, const void *))compare_types_by_table_idx);
5250         table = &assembly->tables [MONO_TABLE_TYPEDEF];
5251         table->rows += mono_ptr_array_size (types);
5252         alloc_table (table, table->rows);
5253
5254         /*
5255          * Emit type names + namespaces at one place inside the string heap,
5256          * so load_class_names () needs to touch fewer pages.
5257          */
5258         for (i = 0; i < mono_ptr_array_size (types); ++i) {
5259                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
5260                 string_heap_insert_mstring (&assembly->sheap, tb->nspace);
5261         }
5262         for (i = 0; i < mono_ptr_array_size (types); ++i) {
5263                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
5264                 string_heap_insert_mstring (&assembly->sheap, tb->name);
5265         }
5266
5267         for (i = 0; i < mono_ptr_array_size (types); ++i) {
5268                 MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
5269                 if (!mono_image_get_type_info (domain, type, assembly, error))
5270                         goto leave_types;
5271         }
5272
5273         /*
5274          * table->rows is already set above and in mono_image_fill_module_table.
5275          */
5276         /* add all the custom attributes at the end, once all the indexes are stable */
5277         if (!mono_image_add_cattrs (assembly, 1, MONO_CUSTOM_ATTR_ASSEMBLY, assemblyb->cattrs, error))
5278                 goto leave_types;
5279
5280         /* CAS assembly permissions */
5281         if (assemblyb->permissions_minimum)
5282                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_minimum);
5283         if (assemblyb->permissions_optional)
5284                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_optional);
5285         if (assemblyb->permissions_refused)
5286                 mono_image_add_decl_security (assembly, mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1), assemblyb->permissions_refused);
5287
5288         if (!module_add_cattrs (assembly, moduleb, error))
5289                 goto leave_types;
5290
5291         /* fixup tokens */
5292         mono_g_hash_table_foreach (assembly->token_fixups, (GHFunc)fixup_method, assembly);
5293
5294         /* Create the MethodImpl table.  We do this after emitting all methods so we already know
5295          * the final tokens and don't need another fixup pass. */
5296
5297         if (moduleb->global_methods) {
5298                 for (i = 0; i < mono_array_length (moduleb->global_methods); ++i) {
5299                         MonoReflectionMethodBuilder *mb = mono_array_get (
5300                                 moduleb->global_methods, MonoReflectionMethodBuilder*, i);
5301                         if (!mono_image_add_methodimpl (assembly, mb, error))
5302                                 goto leave_types;
5303                 }
5304         }
5305
5306         for (i = 0; i < mono_ptr_array_size (types); ++i) {
5307                 MonoReflectionTypeBuilder *type = (MonoReflectionTypeBuilder *)mono_ptr_array_get (types, i);
5308                 if (type->methods) {
5309                         for (j = 0; j < type->num_methods; ++j) {
5310                                 MonoReflectionMethodBuilder *mb = mono_array_get (
5311                                         type->methods, MonoReflectionMethodBuilder*, j);
5312
5313                                 if (!mono_image_add_methodimpl (assembly, mb, error))
5314                                         goto leave_types;
5315                         }
5316                 }
5317         }
5318
5319         fixup_cattrs (assembly);
5320
5321 leave_types:
5322         mono_ptr_array_destroy (types);
5323 leave:
5324
5325         return mono_error_ok (error);
5326 }
5327
5328 #else /* DISABLE_REFLECTION_EMIT_SAVE */
5329
5330 gboolean
5331 mono_image_build_metadata (MonoReflectionModuleBuilder *moduleb, MonoError *error)
5332 {
5333         g_error ("This mono runtime was configured with --enable-minimal=reflection_emit_save, so saving of dynamic assemblies is not supported.");
5334 }
5335
5336 #endif /* DISABLE_REFLECTION_EMIT_SAVE */
5337
5338
5339 typedef struct {
5340         guint32 import_lookup_table;
5341         guint32 timestamp;
5342         guint32 forwarder;
5343         guint32 name_rva;
5344         guint32 import_address_table_rva;
5345 } MonoIDT;
5346
5347 typedef struct {
5348         guint32 name_rva;
5349         guint32 flags;
5350 } MonoILT;
5351
5352 #ifndef DISABLE_REFLECTION_EMIT
5353
5354 /*
5355  * mono_image_insert_string:
5356  * @module: module builder object
5357  * @str: a string
5358  *
5359  * Insert @str into the user string stream of @module.
5360  */
5361 guint32
5362 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str)
5363 {
5364         MonoDynamicImage *assembly;
5365         guint32 idx;
5366         char buf [16];
5367         char *b = buf;
5368
5369         if (!module->dynamic_image)
5370                 mono_image_module_basic_init (module);
5371
5372         assembly = module->dynamic_image;
5373
5374         if (assembly->save) {
5375                 mono_metadata_encode_value (1 | (str->length * 2), b, &b);
5376                 idx = mono_image_add_stream_data (&assembly->us, buf, b-buf);
5377 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
5378         {
5379                 char *swapped = g_malloc (2 * mono_string_length (str));
5380                 const char *p = (const char*)mono_string_chars (str);
5381
5382                 swap_with_size (swapped, p, 2, mono_string_length (str));
5383                 mono_image_add_stream_data (&assembly->us, swapped, str->length * 2);
5384                 g_free (swapped);
5385         }
5386 #else
5387                 mono_image_add_stream_data (&assembly->us, (const char*)mono_string_chars (str), str->length * 2);
5388 #endif
5389                 mono_image_add_stream_data (&assembly->us, "", 1);
5390         } else {
5391                 idx = assembly->us.index ++;
5392         }
5393
5394         register_dyn_token (assembly, MONO_TOKEN_STRING | idx, (MonoObject*)str);
5395
5396         return MONO_TOKEN_STRING | idx;
5397 }
5398
5399 guint32
5400 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types, MonoError *error)
5401 {
5402         MonoClass *klass;
5403         guint32 token = 0;
5404         MonoMethodSignature *sig;
5405
5406         mono_error_init (error);
5407
5408         klass = obj->vtable->klass;
5409         if (strcmp (klass->name, "MonoMethod") == 0 || strcmp (klass->name, "MonoCMethod") == 0) {
5410                 MonoMethod *method = ((MonoReflectionMethod *)obj)->method;
5411                 MonoMethodSignature *old;
5412                 guint32 sig_token, parent;
5413                 int nargs, i;
5414
5415                 g_assert (opt_param_types && (mono_method_signature (method)->sentinelpos >= 0));
5416
5417                 nargs = mono_array_length (opt_param_types);
5418                 old = mono_method_signature (method);
5419                 sig = mono_metadata_signature_alloc ( &assembly->image, old->param_count + nargs);
5420
5421                 sig->hasthis = old->hasthis;
5422                 sig->explicit_this = old->explicit_this;
5423                 sig->call_convention = old->call_convention;
5424                 sig->generic_param_count = old->generic_param_count;
5425                 sig->param_count = old->param_count + nargs;
5426                 sig->sentinelpos = old->param_count;
5427                 sig->ret = old->ret;
5428
5429                 for (i = 0; i < old->param_count; i++)
5430                         sig->params [i] = old->params [i];
5431
5432                 for (i = 0; i < nargs; i++) {
5433                         MonoReflectionType *rt = mono_array_get (opt_param_types, MonoReflectionType *, i);
5434                         sig->params [old->param_count + i] = mono_reflection_type_get_handle (rt, error);
5435                         if (!is_ok (error)) goto fail;
5436                 }
5437
5438                 parent = mono_image_typedef_or_ref (assembly, &method->klass->byval_arg);
5439                 g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_MEMBERREF_PARENT_TYPEREF);
5440                 parent >>= MONO_TYPEDEFORREF_BITS;
5441
5442                 parent <<= MONO_MEMBERREF_PARENT_BITS;
5443                 parent |= MONO_MEMBERREF_PARENT_TYPEREF;
5444
5445                 sig_token = method_encode_signature (assembly, sig);
5446                 token = mono_image_get_varargs_method_token (assembly, parent, method->name, sig_token);
5447         } else if (strcmp (klass->name, "MethodBuilder") == 0) {
5448                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
5449                 ReflectionMethodBuilder rmb;
5450                 guint32 parent, sig_token;
5451                 int nopt_args, nparams, ngparams, i;
5452
5453                 if (!reflection_methodbuilder_from_method_builder (&rmb, mb, error))
5454                         goto fail;
5455
5456                 rmb.opt_types = opt_param_types;
5457                 nopt_args = mono_array_length (opt_param_types);
5458
5459                 nparams = rmb.parameters ? mono_array_length (rmb.parameters): 0;
5460                 ngparams = rmb.generic_params ? mono_array_length (rmb.generic_params): 0;
5461                 sig = mono_metadata_signature_alloc (&assembly->image, nparams + nopt_args);
5462
5463                 sig->hasthis = !(rmb.attrs & METHOD_ATTRIBUTE_STATIC);
5464                 sig->explicit_this = (rmb.call_conv & 0x40) == 0x40;
5465                 sig->call_convention = rmb.call_conv;
5466                 sig->generic_param_count = ngparams;
5467                 sig->param_count = nparams + nopt_args;
5468                 sig->sentinelpos = nparams;
5469                 sig->ret = mono_reflection_type_get_handle (rmb.rtype, error);
5470                 if (!is_ok (error)) goto fail;
5471
5472                 for (i = 0; i < nparams; i++) {
5473                         MonoReflectionType *rt = mono_array_get (rmb.parameters, MonoReflectionType *, i);
5474                         sig->params [i] = mono_reflection_type_get_handle (rt, error);
5475                         if (!is_ok (error)) goto fail;
5476                 }
5477
5478                 for (i = 0; i < nopt_args; i++) {
5479                         MonoReflectionType *rt = mono_array_get (opt_param_types, MonoReflectionType *, i);
5480                         sig->params [nparams + i] = mono_reflection_type_get_handle (rt, error);
5481                         if (!is_ok (error)) goto fail;
5482                 }
5483
5484                 sig_token = method_builder_encode_signature (assembly, &rmb, error);
5485                 if (!is_ok (error))
5486                         goto fail;
5487
5488                 parent = mono_image_create_token (assembly, obj, TRUE, TRUE, error);
5489                 if (!mono_error_ok (error))
5490                         goto fail;
5491                 g_assert (mono_metadata_token_table (parent) == MONO_TABLE_METHOD);
5492
5493                 parent = mono_metadata_token_index (parent) << MONO_MEMBERREF_PARENT_BITS;
5494                 parent |= MONO_MEMBERREF_PARENT_METHODDEF;
5495
5496                 char *name = mono_string_to_utf8 (rmb.name);
5497                 token = mono_image_get_varargs_method_token (
5498                         assembly, parent, name, sig_token);
5499                 g_free (name);
5500         } else {
5501                 g_error ("requested method token for %s\n", klass->name);
5502         }
5503
5504         g_hash_table_insert (assembly->vararg_aux_hash, GUINT_TO_POINTER (token), sig);
5505         register_dyn_token (assembly, token, obj);
5506         return token;
5507 fail:
5508         g_assert (!mono_error_ok (error));
5509         return 0;
5510 }
5511
5512 /*
5513  * mono_image_create_token:
5514  * @assembly: a dynamic assembly
5515  * @obj:
5516  * @register_token: Whenever to register the token in the assembly->tokens hash.
5517  *
5518  * Get a token to insert in the IL code stream for the given MemberInfo.
5519  * The metadata emission routines need to pass FALSE as REGISTER_TOKEN, since by that time,
5520  * the table_idx-es were recomputed, so registering the token would overwrite an existing
5521  * entry.
5522  */
5523 guint32
5524 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj,
5525                          gboolean create_open_instance, gboolean register_token,
5526                          MonoError *error)
5527 {
5528         MonoClass *klass;
5529         guint32 token = 0;
5530
5531         mono_error_init (error);
5532
5533         klass = obj->vtable->klass;
5534
5535         /* Check for user defined reflection objects */
5536         /* TypeDelegator is the only corlib type which doesn't look like a MonoReflectionType */
5537         if (klass->image != mono_defaults.corlib || (strcmp (klass->name, "TypeDelegator") == 0)) {
5538                 mono_error_set_not_supported (error, "User defined subclasses of System.Type are not yet supported");
5539                 return 0;
5540         }
5541
5542         if (strcmp (klass->name, "MethodBuilder") == 0) {
5543                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
5544                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type;
5545
5546                 if (tb->module->dynamic_image == assembly && !tb->generic_params && !mb->generic_params)
5547                         token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
5548                 else {
5549                         token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance, error);
5550                         if (!mono_error_ok (error))
5551                                 return 0;
5552                 }
5553                 /*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
5554         } else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
5555                 MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
5556                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type;
5557
5558                 if (tb->module->dynamic_image == assembly && !tb->generic_params)
5559                         token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
5560                 else {
5561                         token = mono_image_get_ctorbuilder_token (assembly, mb, error);
5562                         if (!mono_error_ok (error))
5563                                 return 0;
5564                 }
5565                 /*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/
5566         } else if (strcmp (klass->name, "FieldBuilder") == 0) {
5567                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
5568                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)fb->typeb;
5569                 if (tb->generic_params) {
5570                         token = mono_image_get_generic_field_token (assembly, fb, error);
5571                         return_val_if_nok (error, 0);
5572                 } else {
5573                         if (tb->module->dynamic_image == assembly) {
5574                                 token = fb->table_idx | MONO_TOKEN_FIELD_DEF;
5575                         } else {
5576                                 token = mono_image_get_fieldref_token (assembly, (MonoObject*)fb, fb->handle);
5577                         }
5578                 }
5579         } else if (strcmp (klass->name, "TypeBuilder") == 0) {
5580                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
5581                 if (create_open_instance && tb->generic_params) {
5582                         MonoType *type;
5583                         init_type_builder_generics (obj);
5584                         type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
5585                         return_val_if_nok (error, 0);
5586                         token = mono_image_typedef_or_ref_full (assembly, type, TRUE);
5587                         token = mono_metadata_token_from_dor (token);
5588                 } else if (tb->module->dynamic_image == assembly) {
5589                         token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
5590                 } else {
5591                         MonoType *type;
5592                         type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
5593                         return_val_if_nok (error, 0);
5594                         token = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, type));
5595                 }
5596         } else if (strcmp (klass->name, "MonoType") == 0) {
5597                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
5598                 return_val_if_nok (error, 0);
5599                 MonoClass *mc = mono_class_from_mono_type (type);
5600                 token = mono_metadata_token_from_dor (
5601                         mono_image_typedef_or_ref_full (assembly, type, mc->generic_container == NULL || create_open_instance));
5602         } else if (strcmp (klass->name, "GenericTypeParameterBuilder") == 0) {
5603                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
5604                 return_val_if_nok (error, 0);
5605                 token = mono_metadata_token_from_dor (
5606                         mono_image_typedef_or_ref (assembly, type));
5607         } else if (strcmp (klass->name, "MonoGenericClass") == 0) {
5608                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
5609                 return_val_if_nok (error, 0);
5610                 token = mono_metadata_token_from_dor (
5611                         mono_image_typedef_or_ref (assembly, type));
5612         } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
5613                    strcmp (klass->name, "MonoMethod") == 0 ||
5614                    strcmp (klass->name, "MonoGenericMethod") == 0 ||
5615                    strcmp (klass->name, "MonoGenericCMethod") == 0) {
5616                 MonoReflectionMethod *m = (MonoReflectionMethod *)obj;
5617                 if (m->method->is_inflated) {
5618                         if (create_open_instance)
5619                                 token = mono_image_get_methodspec_token (assembly, m->method);
5620                         else
5621                                 token = mono_image_get_inflated_method_token (assembly, m->method);
5622                 } else if ((m->method->klass->image == &assembly->image) &&
5623                          !m->method->klass->generic_class) {
5624                         static guint32 method_table_idx = 0xffffff;
5625                         if (m->method->klass->wastypebuilder) {
5626                                 /* we use the same token as the one that was assigned
5627                                  * to the Methodbuilder.
5628                                  * FIXME: do the equivalent for Fields.
5629                                  */
5630                                 token = m->method->token;
5631                         } else {
5632                                 /*
5633                                  * Each token should have a unique index, but the indexes are
5634                                  * assigned by managed code, so we don't know about them. An
5635                                  * easy solution is to count backwards...
5636                                  */
5637                                 method_table_idx --;
5638                                 token = MONO_TOKEN_METHOD_DEF | method_table_idx;
5639                         }
5640                 } else {
5641                         token = mono_image_get_methodref_token (assembly, m->method, create_open_instance);
5642                 }
5643                 /*g_print ("got token 0x%08x for %s\n", token, m->method->name);*/
5644         } else if (strcmp (klass->name, "MonoField") == 0) {
5645                 MonoReflectionField *f = (MonoReflectionField *)obj;
5646                 if ((f->field->parent->image == &assembly->image) && !is_field_on_inst (f->field)) {
5647                         static guint32 field_table_idx = 0xffffff;
5648                         field_table_idx --;
5649                         token = MONO_TOKEN_FIELD_DEF | field_table_idx;
5650                 } else {
5651                         token = mono_image_get_fieldref_token (assembly, (MonoObject*)f, f->field);
5652                 }
5653                 /*g_print ("got token 0x%08x for %s\n", token, f->field->name);*/
5654         } else if (strcmp (klass->name, "MonoArrayMethod") == 0) {
5655                 MonoReflectionArrayMethod *m = (MonoReflectionArrayMethod *)obj;
5656                 token = mono_image_get_array_token (assembly, m, error);
5657                 return_val_if_nok (error, 0);
5658         } else if (strcmp (klass->name, "SignatureHelper") == 0) {
5659                 MonoReflectionSigHelper *s = (MonoReflectionSigHelper*)obj;
5660                 token = MONO_TOKEN_SIGNATURE | mono_image_get_sighelper_token (assembly, s, error);
5661                 return_val_if_nok (error, 0);
5662         } else if (strcmp (klass->name, "EnumBuilder") == 0) {
5663                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
5664                 return_val_if_nok (error, 0);
5665                 token = mono_metadata_token_from_dor (
5666                         mono_image_typedef_or_ref (assembly, type));
5667         } else if (strcmp (klass->name, "FieldOnTypeBuilderInst") == 0) {
5668                 MonoReflectionFieldOnTypeBuilderInst *f = (MonoReflectionFieldOnTypeBuilderInst*)obj;
5669                 token = mono_image_get_field_on_inst_token (assembly, f, error);
5670                 return_val_if_nok (error, 0);
5671         } else if (strcmp (klass->name, "ConstructorOnTypeBuilderInst") == 0) {
5672                 MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)obj;
5673                 token = mono_image_get_ctor_on_inst_token (assembly, c, create_open_instance, error);
5674                 if (!mono_error_ok (error))
5675                         return 0;
5676         } else if (strcmp (klass->name, "MethodOnTypeBuilderInst") == 0) {
5677                 MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj;
5678                 token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance, error);
5679                 if (!mono_error_ok (error))
5680                         return 0;
5681         } else if (is_sre_array (klass) || is_sre_byref (klass) || is_sre_pointer (klass)) {
5682                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
5683                 return_val_if_nok (error, 0);
5684                 token = mono_metadata_token_from_dor (
5685                                 mono_image_typedef_or_ref (assembly, type));
5686         } else {
5687                 g_error ("requested token for %s\n", klass->name);
5688         }
5689
5690         if (register_token)
5691                 mono_image_register_token (assembly, token, obj);
5692
5693         return token;
5694 }
5695
5696 /*
5697  * mono_image_register_token:
5698  *
5699  *   Register the TOKEN->OBJ mapping in the mapping table in ASSEMBLY. This is required for
5700  * the Module.ResolveXXXToken () methods to work.
5701  */
5702 void
5703 mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj)
5704 {
5705         MonoObject *prev;
5706
5707         dynamic_image_lock (assembly);
5708         prev = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
5709         if (prev) {
5710                 /* There could be multiple MethodInfo objects with the same token */
5711                 //g_assert (prev == obj);
5712         } else {
5713                 mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), obj);
5714         }
5715         dynamic_image_unlock (assembly);
5716 }
5717
5718 static MonoDynamicImage*
5719 create_dynamic_mono_image (MonoDynamicAssembly *assembly, char *assembly_name, char *module_name)
5720 {
5721         static const guchar entrycode [16] = {0xff, 0x25, 0};
5722         MonoDynamicImage *image;
5723         int i;
5724
5725         const char *version;
5726
5727         if (!strcmp (mono_get_runtime_info ()->framework_version, "2.1"))
5728                 version = "v2.0.50727"; /* HACK: SL 2 enforces the .net 2 metadata version */
5729         else
5730                 version = mono_get_runtime_info ()->runtime_version;
5731
5732 #if HAVE_BOEHM_GC
5733         /* The MonoGHashTable's need GC tracking */
5734         image = (MonoDynamicImage *)GC_MALLOC (sizeof (MonoDynamicImage));
5735 #else
5736         image = g_new0 (MonoDynamicImage, 1);
5737 #endif
5738
5739         mono_profiler_module_event (&image->image, MONO_PROFILE_START_LOAD);
5740
5741         /*g_print ("created image %p\n", image);*/
5742         /* keep in sync with image.c */
5743         image->image.name = assembly_name;
5744         image->image.assembly_name = image->image.name; /* they may be different */
5745         image->image.module_name = module_name;
5746         image->image.version = g_strdup (version);
5747         image->image.md_version_major = 1;
5748         image->image.md_version_minor = 1;
5749         image->image.dynamic = TRUE;
5750
5751         image->image.references = g_new0 (MonoAssembly*, 1);
5752         image->image.references [0] = NULL;
5753
5754         mono_image_init (&image->image);
5755
5756         image->token_fixups = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_REFLECTION, "dynamic module token fixups table");
5757         image->method_to_table_idx = g_hash_table_new (NULL, NULL);
5758         image->field_to_table_idx = g_hash_table_new (NULL, NULL);
5759         image->method_aux_hash = g_hash_table_new (NULL, NULL);
5760         image->vararg_aux_hash = g_hash_table_new (NULL, NULL);
5761         image->handleref = g_hash_table_new (NULL, NULL);
5762         image->handleref_managed = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_REFLECTION, "dynamic module reference-to-token table");
5763         image->tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, "dynamic module tokens table");
5764         image->generic_def_objects = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, "dynamic module generic definitions table");
5765         image->methodspec = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_REFLECTION, "dynamic module method specifications table");
5766         image->typespec = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
5767         image->typeref = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
5768         image->blob_cache = g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal);
5769         image->gen_params = g_ptr_array_new ();
5770         image->remapped_tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, "dynamic module remapped tokens table");
5771
5772         /*g_print ("string heap create for image %p (%s)\n", image, module_name);*/
5773         string_heap_init (&image->sheap);
5774         mono_image_add_stream_data (&image->us, "", 1);
5775         add_to_blob_cached (image, (char*) "", 1, NULL, 0);
5776         /* import tables... */
5777         mono_image_add_stream_data (&image->code, (char*)entrycode, sizeof (entrycode));
5778         image->iat_offset = mono_image_add_stream_zero (&image->code, 8); /* two IAT entries */
5779         image->idt_offset = mono_image_add_stream_zero (&image->code, 2 * sizeof (MonoIDT)); /* two IDT entries */
5780         image->imp_names_offset = mono_image_add_stream_zero (&image->code, 2); /* flags for name entry */
5781         mono_image_add_stream_data (&image->code, "_CorExeMain", 12);
5782         mono_image_add_stream_data (&image->code, "mscoree.dll", 12);
5783         image->ilt_offset = mono_image_add_stream_zero (&image->code, 8); /* two ILT entries */
5784         stream_data_align (&image->code);
5785
5786         image->cli_header_offset = mono_image_add_stream_zero (&image->code, sizeof (MonoCLIHeader));
5787
5788         for (i=0; i < MONO_TABLE_NUM; ++i) {
5789                 image->tables [i].next_idx = 1;
5790                 image->tables [i].columns = table_sizes [i];
5791         }
5792
5793         image->image.assembly = (MonoAssembly*)assembly;
5794         image->run = assembly->run;
5795         image->save = assembly->save;
5796         image->pe_kind = 0x1; /* ILOnly */
5797         image->machine = 0x14c; /* I386 */
5798
5799         mono_profiler_module_loaded (&image->image, MONO_PROFILE_OK);
5800
5801         dynamic_images_lock ();
5802
5803         if (!dynamic_images)
5804                 dynamic_images = g_ptr_array_new ();
5805
5806         g_ptr_array_add (dynamic_images, image);
5807
5808         dynamic_images_unlock ();
5809
5810         return image;
5811 }
5812 #endif
5813
5814 static void
5815 free_blob_cache_entry (gpointer key, gpointer val, gpointer user_data)
5816 {
5817         g_free (key);
5818 }
5819
5820 static void
5821 release_hashtable (MonoGHashTable **hash)
5822 {
5823         if (*hash) {
5824                 mono_g_hash_table_destroy (*hash);
5825                 *hash = NULL;
5826         }
5827 }
5828
5829 void
5830 mono_dynamic_image_release_gc_roots (MonoDynamicImage *image)
5831 {
5832         release_hashtable (&image->token_fixups);
5833         release_hashtable (&image->handleref_managed);
5834         release_hashtable (&image->tokens);
5835         release_hashtable (&image->remapped_tokens);
5836         release_hashtable (&image->generic_def_objects);
5837         release_hashtable (&image->methodspec);
5838 }
5839
5840 // Free dynamic image pass one: Free resources but not image itself
5841 void
5842 mono_dynamic_image_free (MonoDynamicImage *image)
5843 {
5844         MonoDynamicImage *di = image;
5845         GList *list;
5846         int i;
5847
5848         if (di->methodspec)
5849                 mono_g_hash_table_destroy (di->methodspec);
5850         if (di->typespec)
5851                 g_hash_table_destroy (di->typespec);
5852         if (di->typeref)
5853                 g_hash_table_destroy (di->typeref);
5854         if (di->handleref)
5855                 g_hash_table_destroy (di->handleref);
5856         if (di->handleref_managed)
5857                 mono_g_hash_table_destroy (di->handleref_managed);
5858         if (di->tokens)
5859                 mono_g_hash_table_destroy (di->tokens);
5860         if (di->remapped_tokens)
5861                 mono_g_hash_table_destroy (di->remapped_tokens);
5862         if (di->generic_def_objects)
5863                 mono_g_hash_table_destroy (di->generic_def_objects);
5864         if (di->blob_cache) {
5865                 g_hash_table_foreach (di->blob_cache, free_blob_cache_entry, NULL);
5866                 g_hash_table_destroy (di->blob_cache);
5867         }
5868         if (di->standalonesig_cache)
5869                 g_hash_table_destroy (di->standalonesig_cache);
5870         for (list = di->array_methods; list; list = list->next) {
5871                 ArrayMethod *am = (ArrayMethod *)list->data;
5872                 g_free (am->sig);
5873                 g_free (am->name);
5874                 g_free (am);
5875         }
5876         g_list_free (di->array_methods);
5877         if (di->gen_params) {
5878                 for (i = 0; i < di->gen_params->len; i++) {
5879                         GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (di->gen_params, i);
5880                         mono_gc_deregister_root ((char*) &entry->gparam);
5881                         g_free (entry);
5882                 }
5883                 g_ptr_array_free (di->gen_params, TRUE);
5884         }
5885         if (di->token_fixups)
5886                 mono_g_hash_table_destroy (di->token_fixups);
5887         if (di->method_to_table_idx)
5888                 g_hash_table_destroy (di->method_to_table_idx);
5889         if (di->field_to_table_idx)
5890                 g_hash_table_destroy (di->field_to_table_idx);
5891         if (di->method_aux_hash)
5892                 g_hash_table_destroy (di->method_aux_hash);
5893         if (di->vararg_aux_hash)
5894                 g_hash_table_destroy (di->vararg_aux_hash);
5895         g_free (di->strong_name);
5896         g_free (di->win32_res);
5897         if (di->public_key)
5898                 g_free (di->public_key);
5899
5900         /*g_print ("string heap destroy for image %p\n", di);*/
5901         mono_dynamic_stream_reset (&di->sheap);
5902         mono_dynamic_stream_reset (&di->code);
5903         mono_dynamic_stream_reset (&di->resources);
5904         mono_dynamic_stream_reset (&di->us);
5905         mono_dynamic_stream_reset (&di->blob);
5906         mono_dynamic_stream_reset (&di->tstream);
5907         mono_dynamic_stream_reset (&di->guid);
5908         for (i = 0; i < MONO_TABLE_NUM; ++i) {
5909                 g_free (di->tables [i].values);
5910         }
5911
5912         dynamic_images_lock ();
5913
5914         if (dynamic_images)
5915                 g_ptr_array_remove (dynamic_images, di);
5916
5917         dynamic_images_unlock ();
5918 }
5919
5920 // Free dynamic image pass two: Free image itself (might never get called in some debug modes)
5921 void
5922 mono_dynamic_image_free_image (MonoDynamicImage *image)
5923 {
5924         /* See create_dynamic_mono_image () */
5925 #if HAVE_BOEHM_GC
5926         /* Allocated using GC_MALLOC */
5927 #else
5928         g_free (image);
5929 #endif
5930 }
5931
5932 #ifndef DISABLE_REFLECTION_EMIT
5933
5934 /*
5935  * mono_image_basic_init:
5936  * @assembly: an assembly builder object
5937  *
5938  * Create the MonoImage that represents the assembly builder and setup some
5939  * of the helper hash table and the basic metadata streams.
5940  */
5941 void
5942 mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
5943 {
5944         MonoDynamicAssembly *assembly;
5945         MonoDynamicImage *image;
5946         MonoDomain *domain = mono_object_domain (assemblyb);
5947
5948         if (assemblyb->dynamic_assembly)
5949                 return;
5950
5951 #if HAVE_BOEHM_GC
5952         /* assembly->assembly.image might be GC allocated */
5953         assembly = assemblyb->dynamic_assembly = (MonoDynamicAssembly *)GC_MALLOC (sizeof (MonoDynamicAssembly));
5954 #else
5955         assembly = assemblyb->dynamic_assembly = g_new0 (MonoDynamicAssembly, 1);
5956 #endif
5957
5958         mono_profiler_assembly_event (&assembly->assembly, MONO_PROFILE_START_LOAD);
5959
5960         assembly->assembly.ref_count = 1;
5961         assembly->assembly.dynamic = TRUE;
5962         assembly->assembly.corlib_internal = assemblyb->corlib_internal;
5963         assemblyb->assembly.assembly = (MonoAssembly*)assembly;
5964         assembly->assembly.basedir = mono_string_to_utf8 (assemblyb->dir);
5965         if (assemblyb->culture)
5966                 assembly->assembly.aname.culture = mono_string_to_utf8 (assemblyb->culture);
5967         else
5968                 assembly->assembly.aname.culture = g_strdup ("");
5969
5970         if (assemblyb->version) {
5971                         char *vstr = mono_string_to_utf8 (assemblyb->version);
5972                         char **version = g_strsplit (vstr, ".", 4);
5973                         char **parts = version;
5974                         assembly->assembly.aname.major = atoi (*parts++);
5975                         assembly->assembly.aname.minor = atoi (*parts++);
5976                         assembly->assembly.aname.build = *parts != NULL ? atoi (*parts++) : 0;
5977                         assembly->assembly.aname.revision = *parts != NULL ? atoi (*parts) : 0;
5978
5979                         g_strfreev (version);
5980                         g_free (vstr);
5981         } else {
5982                         assembly->assembly.aname.major = 0;
5983                         assembly->assembly.aname.minor = 0;
5984                         assembly->assembly.aname.build = 0;
5985                         assembly->assembly.aname.revision = 0;
5986         }
5987
5988         assembly->run = assemblyb->access != 2;
5989         assembly->save = assemblyb->access != 1;
5990         assembly->domain = domain;
5991
5992         image = create_dynamic_mono_image (assembly, mono_string_to_utf8 (assemblyb->name), g_strdup ("RefEmit_YouForgotToDefineAModule"));
5993         image->initial_image = TRUE;
5994         assembly->assembly.aname.name = image->image.name;
5995         assembly->assembly.image = &image->image;
5996         if (assemblyb->pktoken && assemblyb->pktoken->max_length) {
5997                 /* -1 to correct for the trailing NULL byte */
5998                 if (assemblyb->pktoken->max_length != MONO_PUBLIC_KEY_TOKEN_LENGTH - 1) {
5999                         g_error ("Public key token length invalid for assembly %s: %i", assembly->assembly.aname.name, assemblyb->pktoken->max_length);
6000                 }
6001                 memcpy (&assembly->assembly.aname.public_key_token, mono_array_addr (assemblyb->pktoken, guint8, 0), assemblyb->pktoken->max_length);
6002         }
6003
6004         mono_domain_assemblies_lock (domain);
6005         domain->domain_assemblies = g_slist_append (domain->domain_assemblies, assembly);
6006         mono_domain_assemblies_unlock (domain);
6007
6008         register_assembly (mono_object_domain (assemblyb), &assemblyb->assembly, &assembly->assembly);
6009
6010         mono_profiler_assembly_loaded (&assembly->assembly, MONO_PROFILE_OK);
6011
6012         mono_assembly_invoke_load_hook ((MonoAssembly*)assembly);
6013 }
6014
6015 #endif /* !DISABLE_REFLECTION_EMIT */
6016
6017 #ifndef DISABLE_REFLECTION_EMIT_SAVE
6018
6019 static int
6020 calc_section_size (MonoDynamicImage *assembly)
6021 {
6022         int nsections = 0;
6023
6024         /* alignment constraints */
6025         mono_image_add_stream_zero (&assembly->code, 4 - (assembly->code.index % 4));
6026         g_assert ((assembly->code.index % 4) == 0);
6027         assembly->meta_size += 3;
6028         assembly->meta_size &= ~3;
6029         mono_image_add_stream_zero (&assembly->resources, 4 - (assembly->resources.index % 4));
6030         g_assert ((assembly->resources.index % 4) == 0);
6031
6032         assembly->sections [MONO_SECTION_TEXT].size = assembly->meta_size + assembly->code.index + assembly->resources.index + assembly->strong_name_size;
6033         assembly->sections [MONO_SECTION_TEXT].attrs = SECT_FLAGS_HAS_CODE | SECT_FLAGS_MEM_EXECUTE | SECT_FLAGS_MEM_READ;
6034         nsections++;
6035
6036         if (assembly->win32_res) {
6037                 guint32 res_size = (assembly->win32_res_size + 3) & ~3;
6038
6039                 assembly->sections [MONO_SECTION_RSRC].size = res_size;
6040                 assembly->sections [MONO_SECTION_RSRC].attrs = SECT_FLAGS_HAS_INITIALIZED_DATA | SECT_FLAGS_MEM_READ;
6041                 nsections++;
6042         }
6043
6044         assembly->sections [MONO_SECTION_RELOC].size = 12;
6045         assembly->sections [MONO_SECTION_RELOC].attrs = SECT_FLAGS_MEM_READ | SECT_FLAGS_MEM_DISCARDABLE | SECT_FLAGS_HAS_INITIALIZED_DATA;
6046         nsections++;
6047
6048         return nsections;
6049 }
6050
6051 typedef struct {
6052         guint32 id;
6053         guint32 offset;
6054         GSList *children;
6055         MonoReflectionWin32Resource *win32_res; /* Only for leaf nodes */
6056 } ResTreeNode;
6057
6058 static int
6059 resource_tree_compare_by_id (gconstpointer a, gconstpointer b)
6060 {
6061         ResTreeNode *t1 = (ResTreeNode*)a;
6062         ResTreeNode *t2 = (ResTreeNode*)b;
6063
6064         return t1->id - t2->id;
6065 }
6066
6067 /*
6068  * resource_tree_create:
6069  *
6070  *  Organize the resources into a resource tree.
6071  */
6072 static ResTreeNode *
6073 resource_tree_create (MonoArray *win32_resources)
6074 {
6075         ResTreeNode *tree, *res_node, *type_node, *lang_node;
6076         GSList *l;
6077         int i;
6078
6079         tree = g_new0 (ResTreeNode, 1);
6080
6081         for (i = 0; i < mono_array_length (win32_resources); ++i) {
6082                 MonoReflectionWin32Resource *win32_res =
6083                         (MonoReflectionWin32Resource*)mono_array_addr (win32_resources, MonoReflectionWin32Resource, i);
6084
6085                 /* Create node */
6086
6087                 /* FIXME: BUG: this stores managed references in unmanaged memory */
6088                 lang_node = g_new0 (ResTreeNode, 1);
6089                 lang_node->id = win32_res->lang_id;
6090                 lang_node->win32_res = win32_res;
6091
6092                 /* Create type node if neccesary */
6093                 type_node = NULL;
6094                 for (l = tree->children; l; l = l->next)
6095                         if (((ResTreeNode*)(l->data))->id == win32_res->res_type) {
6096                                 type_node = (ResTreeNode*)l->data;
6097                                 break;
6098                         }
6099
6100                 if (!type_node) {
6101                         type_node = g_new0 (ResTreeNode, 1);
6102                         type_node->id = win32_res->res_type;
6103
6104                         /*
6105                          * The resource types have to be sorted otherwise
6106                          * Windows Explorer can't display the version information.
6107                          */
6108                         tree->children = g_slist_insert_sorted (tree->children,
6109                                 type_node, resource_tree_compare_by_id);
6110                 }
6111
6112                 /* Create res node if neccesary */
6113                 res_node = NULL;
6114                 for (l = type_node->children; l; l = l->next)
6115                         if (((ResTreeNode*)(l->data))->id == win32_res->res_id) {
6116                                 res_node = (ResTreeNode*)l->data;
6117                                 break;
6118                         }
6119
6120                 if (!res_node) {
6121                         res_node = g_new0 (ResTreeNode, 1);
6122                         res_node->id = win32_res->res_id;
6123                         type_node->children = g_slist_append (type_node->children, res_node);
6124                 }
6125
6126                 res_node->children = g_slist_append (res_node->children, lang_node);
6127         }
6128
6129         return tree;
6130 }
6131
6132 /*
6133  * resource_tree_encode:
6134  *
6135  *   Encode the resource tree into the format used in the PE file.
6136  */
6137 static void
6138 resource_tree_encode (ResTreeNode *node, char *begin, char *p, char **endbuf)
6139 {
6140         char *entries;
6141         MonoPEResourceDir dir;
6142         MonoPEResourceDirEntry dir_entry;
6143         MonoPEResourceDataEntry data_entry;
6144         GSList *l;
6145         guint32 res_id_entries;
6146
6147         /*
6148          * For the format of the resource directory, see the article
6149          * "An In-Depth Look into the Win32 Portable Executable File Format" by
6150          * Matt Pietrek
6151          */
6152
6153         memset (&dir, 0, sizeof (dir));
6154         memset (&dir_entry, 0, sizeof (dir_entry));
6155         memset (&data_entry, 0, sizeof (data_entry));
6156
6157         g_assert (sizeof (dir) == 16);
6158         g_assert (sizeof (dir_entry) == 8);
6159         g_assert (sizeof (data_entry) == 16);
6160
6161         node->offset = p - begin;
6162
6163         /* IMAGE_RESOURCE_DIRECTORY */
6164         res_id_entries = g_slist_length (node->children);
6165         dir.res_id_entries = GUINT16_TO_LE (res_id_entries);
6166
6167         memcpy (p, &dir, sizeof (dir));
6168         p += sizeof (dir);
6169
6170         /* Reserve space for entries */
6171         entries = p;
6172         p += sizeof (dir_entry) * res_id_entries;
6173
6174         /* Write children */
6175         for (l = node->children; l; l = l->next) {
6176                 ResTreeNode *child = (ResTreeNode*)l->data;
6177
6178                 if (child->win32_res) {
6179                         guint32 size;
6180
6181                         child->offset = p - begin;
6182
6183                         /* IMAGE_RESOURCE_DATA_ENTRY */
6184                         data_entry.rde_data_offset = GUINT32_TO_LE (p - begin + sizeof (data_entry));
6185                         size = mono_array_length (child->win32_res->res_data);
6186                         data_entry.rde_size = GUINT32_TO_LE (size);
6187
6188                         memcpy (p, &data_entry, sizeof (data_entry));
6189                         p += sizeof (data_entry);
6190
6191                         memcpy (p, mono_array_addr (child->win32_res->res_data, char, 0), size);
6192                         p += size;
6193                 } else {
6194                         resource_tree_encode (child, begin, p, &p);
6195                 }
6196         }
6197
6198         /* IMAGE_RESOURCE_ENTRY */
6199         for (l = node->children; l; l = l->next) {
6200                 ResTreeNode *child = (ResTreeNode*)l->data;
6201
6202                 MONO_PE_RES_DIR_ENTRY_SET_NAME (dir_entry, FALSE, child->id);
6203                 MONO_PE_RES_DIR_ENTRY_SET_DIR (dir_entry, !child->win32_res, child->offset);
6204
6205                 memcpy (entries, &dir_entry, sizeof (dir_entry));
6206                 entries += sizeof (dir_entry);
6207         }
6208
6209         *endbuf = p;
6210 }
6211
6212 static void
6213 resource_tree_free (ResTreeNode * node)
6214 {
6215         GSList * list;
6216         for (list = node->children; list; list = list->next)
6217                 resource_tree_free ((ResTreeNode*)list->data);
6218         g_slist_free(node->children);
6219         g_free (node);
6220 }
6221
6222 static void
6223 assembly_add_win32_resources (MonoDynamicImage *assembly, MonoReflectionAssemblyBuilder *assemblyb)
6224 {
6225         char *buf;
6226         char *p;
6227         guint32 size, i;
6228         MonoReflectionWin32Resource *win32_res;
6229         ResTreeNode *tree;
6230
6231         if (!assemblyb->win32_resources)
6232                 return;
6233
6234         /*
6235          * Resources are stored in a three level tree inside the PE file.
6236          * - level one contains a node for each type of resource
6237          * - level two contains a node for each resource
6238          * - level three contains a node for each instance of a resource for a
6239          *   specific language.
6240          */
6241
6242         tree = resource_tree_create (assemblyb->win32_resources);
6243
6244         /* Estimate the size of the encoded tree */
6245         size = 0;
6246         for (i = 0; i < mono_array_length (assemblyb->win32_resources); ++i) {
6247                 win32_res = (MonoReflectionWin32Resource*)mono_array_addr (assemblyb->win32_resources, MonoReflectionWin32Resource, i);
6248                 size += mono_array_length (win32_res->res_data);
6249         }
6250         /* Directory structure */
6251         size += mono_array_length (assemblyb->win32_resources) * 256;
6252         p = buf = (char *)g_malloc (size);
6253
6254         resource_tree_encode (tree, p, p, &p);
6255
6256         g_assert (p - buf <= size);
6257
6258         assembly->win32_res = (char *)g_malloc (p - buf);
6259         assembly->win32_res_size = p - buf;
6260         memcpy (assembly->win32_res, buf, p - buf);
6261
6262         g_free (buf);
6263         resource_tree_free (tree);
6264 }
6265
6266 static void
6267 fixup_resource_directory (char *res_section, char *p, guint32 rva)
6268 {
6269         MonoPEResourceDir *dir = (MonoPEResourceDir*)p;
6270         int i;
6271
6272         p += sizeof (MonoPEResourceDir);
6273         for (i = 0; i < GUINT16_FROM_LE (dir->res_named_entries) + GUINT16_FROM_LE (dir->res_id_entries); ++i) {
6274                 MonoPEResourceDirEntry *dir_entry = (MonoPEResourceDirEntry*)p;
6275                 char *child = res_section + MONO_PE_RES_DIR_ENTRY_DIR_OFFSET (*dir_entry);
6276                 if (MONO_PE_RES_DIR_ENTRY_IS_DIR (*dir_entry)) {
6277                         fixup_resource_directory (res_section, child, rva);
6278                 } else {
6279                         MonoPEResourceDataEntry *data_entry = (MonoPEResourceDataEntry*)child;
6280                         data_entry->rde_data_offset = GUINT32_TO_LE (GUINT32_FROM_LE (data_entry->rde_data_offset) + rva);
6281                 }
6282
6283                 p += sizeof (MonoPEResourceDirEntry);
6284         }
6285 }
6286
6287 static void
6288 checked_write_file (HANDLE f, gconstpointer buffer, guint32 numbytes)
6289 {
6290         guint32 dummy;
6291         if (!WriteFile (f, buffer, numbytes, &dummy, NULL))
6292                 g_error ("WriteFile returned %d\n", GetLastError ());
6293 }
6294
6295 /*
6296  * mono_image_create_pefile:
6297  * @mb: a module builder object
6298  *
6299  * This function creates the PE-COFF header, the image sections, the CLI header  * etc. all the data is written in
6300  * assembly->pefile where it can be easily retrieved later in chunks.
6301  */
6302 gboolean
6303 mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file, MonoError *error)
6304 {
6305         MonoMSDOSHeader *msdos;
6306         MonoDotNetHeader *header;
6307         MonoSectionTable *section;
6308         MonoCLIHeader *cli_header;
6309         guint32 size, image_size, virtual_base, text_offset;
6310         guint32 header_start, section_start, file_offset, virtual_offset;
6311         MonoDynamicImage *assembly;
6312         MonoReflectionAssemblyBuilder *assemblyb;
6313         MonoDynamicStream pefile_stream = {0};
6314         MonoDynamicStream *pefile = &pefile_stream;
6315         int i, nsections;
6316         guint32 *rva, value;
6317         guchar *p;
6318         static const unsigned char msheader[] = {
6319                 0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00, 0x00, 0x00,  0x04, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
6320                 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6321                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
6322                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
6323                 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd,  0x21, 0xb8, 0x01, 0x4c, 0xcd, 0x21, 0x54, 0x68,
6324                 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72,  0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f,
6325                 0x74, 0x20, 0x62, 0x65, 0x20, 0x72, 0x75, 0x6e,  0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
6326                 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x0d, 0x0d, 0x0a,  0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
6327         };
6328
6329         mono_error_init (error);
6330
6331         assemblyb = mb->assemblyb;
6332
6333         mono_image_basic_init (assemblyb);
6334         assembly = mb->dynamic_image;
6335
6336         assembly->pe_kind = assemblyb->pe_kind;
6337         assembly->machine = assemblyb->machine;
6338         ((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->pe_kind = assemblyb->pe_kind;
6339         ((MonoDynamicImage*)assemblyb->dynamic_assembly->assembly.image)->machine = assemblyb->machine;
6340
6341         if (!mono_image_build_metadata (mb, error))
6342                 return FALSE;
6343
6344
6345         if (mb->is_main && assemblyb->resources) {
6346                 int len = mono_array_length (assemblyb->resources);
6347                 for (i = 0; i < len; ++i)
6348                         assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (assemblyb->resources, MonoReflectionResource, i));
6349         }
6350
6351         if (mb->resources) {
6352                 int len = mono_array_length (mb->resources);
6353                 for (i = 0; i < len; ++i)
6354                         assembly_add_resource (mb, assembly, (MonoReflectionResource*)mono_array_addr (mb->resources, MonoReflectionResource, i));
6355         }
6356
6357         if (!build_compressed_metadata (assembly, error))
6358                 return FALSE;
6359
6360         if (mb->is_main)
6361                 assembly_add_win32_resources (assembly, assemblyb);
6362
6363         nsections = calc_section_size (assembly);
6364
6365         /* The DOS header and stub */
6366         g_assert (sizeof (MonoMSDOSHeader) == sizeof (msheader));
6367         mono_image_add_stream_data (pefile, (char*)msheader, sizeof (msheader));
6368
6369         /* the dotnet header */
6370         header_start = mono_image_add_stream_zero (pefile, sizeof (MonoDotNetHeader));
6371
6372         /* the section tables */
6373         section_start = mono_image_add_stream_zero (pefile, sizeof (MonoSectionTable) * nsections);
6374
6375         file_offset = section_start + sizeof (MonoSectionTable) * nsections;
6376         virtual_offset = VIRT_ALIGN;
6377         image_size = 0;
6378
6379         for (i = 0; i < MONO_SECTION_MAX; ++i) {
6380                 if (!assembly->sections [i].size)
6381                         continue;
6382                 /* align offsets */
6383                 file_offset += FILE_ALIGN - 1;
6384                 file_offset &= ~(FILE_ALIGN - 1);
6385                 virtual_offset += VIRT_ALIGN - 1;
6386                 virtual_offset &= ~(VIRT_ALIGN - 1);
6387
6388                 assembly->sections [i].offset = file_offset;
6389                 assembly->sections [i].rva = virtual_offset;
6390
6391                 file_offset += assembly->sections [i].size;
6392                 virtual_offset += assembly->sections [i].size;
6393                 image_size += (assembly->sections [i].size + VIRT_ALIGN - 1) & ~(VIRT_ALIGN - 1);
6394         }
6395
6396         file_offset += FILE_ALIGN - 1;
6397         file_offset &= ~(FILE_ALIGN - 1);
6398
6399         image_size += section_start + sizeof (MonoSectionTable) * nsections;
6400
6401         /* back-patch info */
6402         msdos = (MonoMSDOSHeader*)pefile->data;
6403         msdos->pe_offset = GUINT32_FROM_LE (sizeof (MonoMSDOSHeader));
6404
6405         header = (MonoDotNetHeader*)(pefile->data + header_start);
6406         header->pesig [0] = 'P';
6407         header->pesig [1] = 'E';
6408
6409         header->coff.coff_machine = GUINT16_FROM_LE (assemblyb->machine);
6410         header->coff.coff_sections = GUINT16_FROM_LE (nsections);
6411         header->coff.coff_time = GUINT32_FROM_LE (time (NULL));
6412         header->coff.coff_opt_header_size = GUINT16_FROM_LE (sizeof (MonoDotNetHeader) - sizeof (MonoCOFFHeader) - 4);
6413         if (assemblyb->pekind == 1) {
6414                 /* it's a dll */
6415                 header->coff.coff_attributes = GUINT16_FROM_LE (0x210e);
6416         } else {
6417                 /* it's an exe */
6418                 header->coff.coff_attributes = GUINT16_FROM_LE (0x010e);
6419         }
6420
6421         virtual_base = 0x400000; /* FIXME: 0x10000000 if a DLL */
6422
6423         header->pe.pe_magic = GUINT16_FROM_LE (0x10B);
6424         header->pe.pe_major = 6;
6425         header->pe.pe_minor = 0;
6426         size = assembly->sections [MONO_SECTION_TEXT].size;
6427         size += FILE_ALIGN - 1;
6428         size &= ~(FILE_ALIGN - 1);
6429         header->pe.pe_code_size = GUINT32_FROM_LE(size);
6430         size = assembly->sections [MONO_SECTION_RSRC].size;
6431         size += FILE_ALIGN - 1;
6432         size &= ~(FILE_ALIGN - 1);
6433         header->pe.pe_data_size = GUINT32_FROM_LE(size);
6434         g_assert (START_TEXT_RVA == assembly->sections [MONO_SECTION_TEXT].rva);
6435         header->pe.pe_rva_code_base = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_TEXT].rva);
6436         header->pe.pe_rva_data_base = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].rva);
6437         /* pe_rva_entry_point always at the beginning of the text section */
6438         header->pe.pe_rva_entry_point = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_TEXT].rva);
6439
6440         header->nt.pe_image_base = GUINT32_FROM_LE (virtual_base);
6441         header->nt.pe_section_align = GUINT32_FROM_LE (VIRT_ALIGN);
6442         header->nt.pe_file_alignment = GUINT32_FROM_LE (FILE_ALIGN);
6443         header->nt.pe_os_major = GUINT16_FROM_LE (4);
6444         header->nt.pe_os_minor = GUINT16_FROM_LE (0);
6445         header->nt.pe_subsys_major = GUINT16_FROM_LE (4);
6446         size = section_start;
6447         size += FILE_ALIGN - 1;
6448         size &= ~(FILE_ALIGN - 1);
6449         header->nt.pe_header_size = GUINT32_FROM_LE (size);
6450         size = image_size;
6451         size += VIRT_ALIGN - 1;
6452         size &= ~(VIRT_ALIGN - 1);
6453         header->nt.pe_image_size = GUINT32_FROM_LE (size);
6454
6455         /*
6456         // Translate the PEFileKind value to the value expected by the Windows loader
6457         */
6458         {
6459                 short kind;
6460
6461                 /*
6462                 // PEFileKinds.Dll == 1
6463                 // PEFileKinds.ConsoleApplication == 2
6464                 // PEFileKinds.WindowApplication == 3
6465                 //
6466                 // need to get:
6467                 //     IMAGE_SUBSYSTEM_WINDOWS_GUI 2 // Image runs in the Windows GUI subsystem.
6468                 //     IMAGE_SUBSYSTEM_WINDOWS_CUI 3 // Image runs in the Windows character subsystem.
6469                 */
6470                 if (assemblyb->pekind == 3)
6471                         kind = 2;
6472                 else
6473                         kind = 3;
6474
6475                 header->nt.pe_subsys_required = GUINT16_FROM_LE (kind);
6476         }
6477         header->nt.pe_stack_reserve = GUINT32_FROM_LE (0x00100000);
6478         header->nt.pe_stack_commit = GUINT32_FROM_LE (0x00001000);
6479         header->nt.pe_heap_reserve = GUINT32_FROM_LE (0x00100000);
6480         header->nt.pe_heap_commit = GUINT32_FROM_LE (0x00001000);
6481         header->nt.pe_loader_flags = GUINT32_FROM_LE (0);
6482         header->nt.pe_data_dir_count = GUINT32_FROM_LE (16);
6483
6484         /* fill data directory entries */
6485
6486         header->datadir.pe_resource_table.size = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].size);
6487         header->datadir.pe_resource_table.rva = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RSRC].rva);
6488
6489         header->datadir.pe_reloc_table.size = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RELOC].size);
6490         header->datadir.pe_reloc_table.rva = GUINT32_FROM_LE (assembly->sections [MONO_SECTION_RELOC].rva);
6491
6492         header->datadir.pe_cli_header.size = GUINT32_FROM_LE (72);
6493         header->datadir.pe_cli_header.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->cli_header_offset);
6494         header->datadir.pe_iat.size = GUINT32_FROM_LE (8);
6495         header->datadir.pe_iat.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->iat_offset);
6496         /* patch entrypoint name */
6497         if (assemblyb->pekind == 1)
6498                 memcpy (assembly->code.data + assembly->imp_names_offset + 2, "_CorDllMain", 12);
6499         else
6500                 memcpy (assembly->code.data + assembly->imp_names_offset + 2, "_CorExeMain", 12);
6501         /* patch imported function RVA name */
6502         rva = (guint32*)(assembly->code.data + assembly->iat_offset);
6503         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->imp_names_offset);
6504
6505         /* the import table */
6506         header->datadir.pe_import_table.size = GUINT32_FROM_LE (79); /* FIXME: magic number? */
6507         header->datadir.pe_import_table.rva = GUINT32_FROM_LE (assembly->text_rva + assembly->idt_offset);
6508         /* patch imported dll RVA name and other entries in the dir */
6509         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, name_rva));
6510         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->imp_names_offset + 14); /* 14 is hint+strlen+1 of func name */
6511         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, import_address_table_rva));
6512         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->iat_offset);
6513         rva = (guint32*)(assembly->code.data + assembly->idt_offset + G_STRUCT_OFFSET (MonoIDT, import_lookup_table));
6514         *rva = GUINT32_FROM_LE (assembly->text_rva + assembly->ilt_offset);
6515
6516         p = (guchar*)(assembly->code.data + assembly->ilt_offset);
6517         value = (assembly->text_rva + assembly->imp_names_offset);
6518         *p++ = (value) & 0xff;
6519         *p++ = (value >> 8) & (0xff);
6520         *p++ = (value >> 16) & (0xff);
6521         *p++ = (value >> 24) & (0xff);
6522
6523         /* the CLI header info */
6524         cli_header = (MonoCLIHeader*)(assembly->code.data + assembly->cli_header_offset);
6525         cli_header->ch_size = GUINT32_FROM_LE (72);
6526         cli_header->ch_runtime_major = GUINT16_FROM_LE (2);
6527         cli_header->ch_runtime_minor = GUINT16_FROM_LE (5);
6528         cli_header->ch_flags = GUINT32_FROM_LE (assemblyb->pe_kind);
6529         if (assemblyb->entry_point) {
6530                 guint32 table_idx = 0;
6531                 if (!strcmp (assemblyb->entry_point->object.vtable->klass->name, "MethodBuilder")) {
6532                         MonoReflectionMethodBuilder *methodb = (MonoReflectionMethodBuilder*)assemblyb->entry_point;
6533                         table_idx = methodb->table_idx;
6534                 } else {
6535                         table_idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->method_to_table_idx, assemblyb->entry_point->method));
6536                 }
6537                 cli_header->ch_entry_point = GUINT32_FROM_LE (table_idx | MONO_TOKEN_METHOD_DEF);
6538         } else {
6539                 cli_header->ch_entry_point = GUINT32_FROM_LE (0);
6540         }
6541         /* The embedded managed resources */
6542         text_offset = assembly->text_rva + assembly->code.index;
6543         cli_header->ch_resources.rva = GUINT32_FROM_LE (text_offset);
6544         cli_header->ch_resources.size = GUINT32_FROM_LE (assembly->resources.index);
6545         text_offset += assembly->resources.index;
6546         cli_header->ch_metadata.rva = GUINT32_FROM_LE (text_offset);
6547         cli_header->ch_metadata.size = GUINT32_FROM_LE (assembly->meta_size);
6548         text_offset += assembly->meta_size;
6549         if (assembly->strong_name_size) {
6550                 cli_header->ch_strong_name.rva = GUINT32_FROM_LE (text_offset);
6551                 cli_header->ch_strong_name.size = GUINT32_FROM_LE (assembly->strong_name_size);
6552                 text_offset += assembly->strong_name_size;
6553         }
6554
6555         /* write the section tables and section content */
6556         section = (MonoSectionTable*)(pefile->data + section_start);
6557         for (i = 0; i < MONO_SECTION_MAX; ++i) {
6558                 static const char section_names [][7] = {
6559                         ".text", ".rsrc", ".reloc"
6560                 };
6561                 if (!assembly->sections [i].size)
6562                         continue;
6563                 strcpy (section->st_name, section_names [i]);
6564                 /*g_print ("output section %s (%d), size: %d\n", section->st_name, i, assembly->sections [i].size);*/
6565                 section->st_virtual_address = GUINT32_FROM_LE (assembly->sections [i].rva);
6566                 section->st_virtual_size = GUINT32_FROM_LE (assembly->sections [i].size);
6567                 section->st_raw_data_size = GUINT32_FROM_LE (GUINT32_TO_LE (section->st_virtual_size) + (FILE_ALIGN - 1));
6568                 section->st_raw_data_size &= GUINT32_FROM_LE (~(FILE_ALIGN - 1));
6569                 section->st_raw_data_ptr = GUINT32_FROM_LE (assembly->sections [i].offset);
6570                 section->st_flags = GUINT32_FROM_LE (assembly->sections [i].attrs);
6571                 section ++;
6572         }
6573
6574         checked_write_file (file, pefile->data, pefile->index);
6575
6576         mono_dynamic_stream_reset (pefile);
6577
6578         for (i = 0; i < MONO_SECTION_MAX; ++i) {
6579                 if (!assembly->sections [i].size)
6580                         continue;
6581
6582                 if (SetFilePointer (file, assembly->sections [i].offset, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
6583                         g_error ("SetFilePointer returned %d\n", GetLastError ());
6584
6585                 switch (i) {
6586                 case MONO_SECTION_TEXT:
6587                         /* patch entry point */
6588                         p = (guchar*)(assembly->code.data + 2);
6589                         value = (virtual_base + assembly->text_rva + assembly->iat_offset);
6590                         *p++ = (value) & 0xff;
6591                         *p++ = (value >> 8) & 0xff;
6592                         *p++ = (value >> 16) & 0xff;
6593                         *p++ = (value >> 24) & 0xff;
6594
6595                         checked_write_file (file, assembly->code.data, assembly->code.index);
6596                         checked_write_file (file, assembly->resources.data, assembly->resources.index);
6597                         checked_write_file (file, assembly->image.raw_metadata, assembly->meta_size);
6598                         checked_write_file (file, assembly->strong_name, assembly->strong_name_size);
6599
6600
6601                         g_free (assembly->image.raw_metadata);
6602                         break;
6603                 case MONO_SECTION_RELOC: {
6604                         struct {
6605                                 guint32 page_rva;
6606                                 guint32 block_size;
6607                                 guint16 type_and_offset;
6608                                 guint16 term;
6609                         } reloc;
6610
6611                         g_assert (sizeof (reloc) == 12);
6612
6613                         reloc.page_rva = GUINT32_FROM_LE (assembly->text_rva);
6614                         reloc.block_size = GUINT32_FROM_LE (12);
6615
6616                         /*
6617                          * the entrypoint is always at the start of the text section
6618                          * 3 is IMAGE_REL_BASED_HIGHLOW
6619                          * 2 is patch_size_rva - text_rva
6620                          */
6621                         reloc.type_and_offset = GUINT16_FROM_LE ((3 << 12) + (2));
6622                         reloc.term = 0;
6623
6624                         checked_write_file (file, &reloc, sizeof (reloc));
6625
6626                         break;
6627                 }
6628                 case MONO_SECTION_RSRC:
6629                         if (assembly->win32_res) {
6630
6631                                 /* Fixup the offsets in the IMAGE_RESOURCE_DATA_ENTRY structures */
6632                                 fixup_resource_directory (assembly->win32_res, assembly->win32_res, assembly->sections [i].rva);
6633                                 checked_write_file (file, assembly->win32_res, assembly->win32_res_size);
6634                         }
6635                         break;
6636                 default:
6637                         g_assert_not_reached ();
6638                 }
6639         }
6640
6641         /* check that the file is properly padded */
6642         if (SetFilePointer (file, file_offset, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
6643                 g_error ("SetFilePointer returned %d\n", GetLastError ());
6644         if (! SetEndOfFile (file))
6645                 g_error ("SetEndOfFile returned %d\n", GetLastError ());
6646
6647         mono_dynamic_stream_reset (&assembly->code);
6648         mono_dynamic_stream_reset (&assembly->us);
6649         mono_dynamic_stream_reset (&assembly->blob);
6650         mono_dynamic_stream_reset (&assembly->guid);
6651         mono_dynamic_stream_reset (&assembly->sheap);
6652
6653         g_hash_table_foreach (assembly->blob_cache, (GHFunc)g_free, NULL);
6654         g_hash_table_destroy (assembly->blob_cache);
6655         assembly->blob_cache = NULL;
6656
6657         return TRUE;
6658 }
6659
6660 #else /* DISABLE_REFLECTION_EMIT_SAVE */
6661
6662 gboolean
6663 mono_image_create_pefile (MonoReflectionModuleBuilder *mb, HANDLE file, MonoError *error)
6664 {
6665         g_assert_not_reached ();
6666 }
6667
6668 #endif /* DISABLE_REFLECTION_EMIT_SAVE */
6669
6670 #ifndef DISABLE_REFLECTION_EMIT
6671
6672 MonoReflectionModule *
6673 mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *ab, MonoString *fileName, MonoError *error)
6674 {
6675         char *name;
6676         MonoImage *image;
6677         MonoImageOpenStatus status;
6678         MonoDynamicAssembly *assembly;
6679         guint32 module_count;
6680         MonoImage **new_modules;
6681         gboolean *new_modules_loaded;
6682
6683         mono_error_init (error);
6684
6685         name = mono_string_to_utf8 (fileName);
6686
6687         image = mono_image_open (name, &status);
6688         if (!image) {
6689                 if (status == MONO_IMAGE_ERROR_ERRNO)
6690                         mono_error_set_exception_instance (error, mono_get_exception_file_not_found (fileName));
6691                 else
6692                         mono_error_set_bad_image_name (error, name, NULL);
6693                 g_free (name);
6694                 return NULL;
6695         }
6696
6697         g_free (name);
6698
6699         assembly = ab->dynamic_assembly;
6700         image->assembly = (MonoAssembly*)assembly;
6701
6702         module_count = image->assembly->image->module_count;
6703         new_modules = g_new0 (MonoImage *, module_count + 1);
6704         new_modules_loaded = g_new0 (gboolean, module_count + 1);
6705
6706         if (image->assembly->image->modules)
6707                 memcpy (new_modules, image->assembly->image->modules, module_count * sizeof (MonoImage *));
6708         if (image->assembly->image->modules_loaded)
6709                 memcpy (new_modules_loaded, image->assembly->image->modules_loaded, module_count * sizeof (gboolean));
6710         new_modules [module_count] = image;
6711         new_modules_loaded [module_count] = TRUE;
6712         mono_image_addref (image);
6713
6714         g_free (image->assembly->image->modules);
6715         image->assembly->image->modules = new_modules;
6716         image->assembly->image->modules_loaded = new_modules_loaded;
6717         image->assembly->image->module_count ++;
6718
6719         mono_assembly_load_references (image, &status);
6720         if (status) {
6721                 mono_image_close (image);
6722                 mono_error_set_exception_instance (error, mono_get_exception_file_not_found (fileName));
6723                 return NULL;
6724         }
6725
6726         return mono_module_get_object_checked (mono_domain_get (), image, error);
6727 }
6728
6729 #endif /* DISABLE_REFLECTION_EMIT */
6730
6731 /*
6732  * We need to return always the same object for MethodInfo, FieldInfo etc..
6733  * but we need to consider the reflected type.
6734  * type uses a different hash, since it uses custom hash/equal functions.
6735  */
6736
6737 typedef struct {
6738         gpointer item;
6739         MonoClass *refclass;
6740 } ReflectedEntry;
6741
6742 static gboolean
6743 reflected_equal (gconstpointer a, gconstpointer b) {
6744         const ReflectedEntry *ea = (const ReflectedEntry *)a;
6745         const ReflectedEntry *eb = (const ReflectedEntry *)b;
6746
6747         return (ea->item == eb->item) && (ea->refclass == eb->refclass);
6748 }
6749
6750 static guint
6751 reflected_hash (gconstpointer a) {
6752         const ReflectedEntry *ea = (const ReflectedEntry *)a;
6753         return mono_aligned_addr_hash (ea->item);
6754 }
6755
6756 #define CHECK_OBJECT(t,p,k)     \
6757         do {    \
6758                 t _obj; \
6759                 ReflectedEntry e;       \
6760                 e.item = (p);   \
6761                 e.refclass = (k);       \
6762                 mono_domain_lock (domain);      \
6763                 if (!domain->refobject_hash)    \
6764                         domain->refobject_hash = mono_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection objects table");  \
6765                 if ((_obj = (t)mono_g_hash_table_lookup (domain->refobject_hash, &e))) {        \
6766                         mono_domain_unlock (domain);    \
6767                         return _obj;    \
6768                 }       \
6769         mono_domain_unlock (domain); \
6770         } while (0)
6771
6772 #ifdef HAVE_BOEHM_GC
6773 /* ReflectedEntry doesn't need to be GC tracked */
6774 #define ALLOC_REFENTRY g_new0 (ReflectedEntry, 1)
6775 #define FREE_REFENTRY(entry) g_free ((entry))
6776 #define REFENTRY_REQUIRES_CLEANUP
6777 #else
6778 #define ALLOC_REFENTRY (ReflectedEntry *)mono_mempool_alloc (domain->mp, sizeof (ReflectedEntry))
6779 /* FIXME: */
6780 #define FREE_REFENTRY(entry)
6781 #endif
6782
6783 #define CACHE_OBJECT(t,p,o,k)   \
6784         do {    \
6785                 t _obj; \
6786         ReflectedEntry pe; \
6787         pe.item = (p); \
6788         pe.refclass = (k); \
6789         mono_domain_lock (domain); \
6790                 if (!domain->refobject_hash)    \
6791                         domain->refobject_hash = mono_g_hash_table_new_type (reflected_hash, reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection objects table");  \
6792         _obj = (t)mono_g_hash_table_lookup (domain->refobject_hash, &pe); \
6793         if (!_obj) { \
6794                     ReflectedEntry *e = ALLOC_REFENTRY;         \
6795                     e->item = (p);      \
6796                     e->refclass = (k);  \
6797                     mono_g_hash_table_insert (domain->refobject_hash, e,o);     \
6798             _obj = o; \
6799         } \
6800                 mono_domain_unlock (domain);    \
6801         return _obj; \
6802         } while (0)
6803
6804 static void
6805 clear_cached_object (MonoDomain *domain, gpointer o, MonoClass *klass)
6806 {
6807         mono_domain_lock (domain);
6808         if (domain->refobject_hash) {
6809         ReflectedEntry pe;
6810                 gpointer orig_pe, orig_value;
6811
6812                 pe.item = o;
6813                 pe.refclass = klass;
6814                 if (mono_g_hash_table_lookup_extended (domain->refobject_hash, &pe, &orig_pe, &orig_value)) {
6815                         mono_g_hash_table_remove (domain->refobject_hash, &pe);
6816                         FREE_REFENTRY (orig_pe);
6817                 }
6818         }
6819         mono_domain_unlock (domain);
6820 }
6821
6822 #ifdef REFENTRY_REQUIRES_CLEANUP
6823 static void
6824 cleanup_refobject_hash (gpointer key, gpointer value, gpointer user_data)
6825 {
6826         FREE_REFENTRY (key);
6827 }
6828 #endif
6829
6830 void
6831 mono_reflection_cleanup_domain (MonoDomain *domain)
6832 {
6833         if (domain->refobject_hash) {
6834 /*let's avoid scanning the whole hashtable if not needed*/
6835 #ifdef REFENTRY_REQUIRES_CLEANUP
6836                 mono_g_hash_table_foreach (domain->refobject_hash, cleanup_refobject_hash, NULL);
6837 #endif
6838                 mono_g_hash_table_destroy (domain->refobject_hash);
6839                 domain->refobject_hash = NULL;
6840         }
6841 }
6842
6843 #ifndef DISABLE_REFLECTION_EMIT
6844 static gpointer
6845 register_assembly (MonoDomain *domain, MonoReflectionAssembly *res, MonoAssembly *assembly)
6846 {
6847         CACHE_OBJECT (MonoReflectionAssembly *, assembly, res, NULL);
6848 }
6849
6850 static gpointer
6851 register_module (MonoDomain *domain, MonoReflectionModuleBuilder *res, MonoDynamicImage *module)
6852 {
6853         CACHE_OBJECT (MonoReflectionModuleBuilder *, module, res, NULL);
6854 }
6855
6856 void
6857 mono_image_module_basic_init (MonoReflectionModuleBuilder *moduleb)
6858 {
6859         MonoDynamicImage *image = moduleb->dynamic_image;
6860         MonoReflectionAssemblyBuilder *ab = moduleb->assemblyb;
6861         if (!image) {
6862                 MonoError error;
6863                 int module_count;
6864                 MonoImage **new_modules;
6865                 MonoImage *ass;
6866                 char *name, *fqname;
6867                 /*
6868                  * FIXME: we already created an image in mono_image_basic_init (), but
6869                  * we don't know which module it belongs to, since that is only
6870                  * determined at assembly save time.
6871                  */
6872                 /*image = (MonoDynamicImage*)ab->dynamic_assembly->assembly.image; */
6873                 name = mono_string_to_utf8 (ab->name);
6874                 fqname = mono_string_to_utf8_checked (moduleb->module.fqname, &error);
6875                 if (!mono_error_ok (&error)) {
6876                         g_free (name);
6877                         mono_error_raise_exception (&error);
6878                 }
6879                 image = create_dynamic_mono_image (ab->dynamic_assembly, name, fqname);
6880
6881                 moduleb->module.image = &image->image;
6882                 moduleb->dynamic_image = image;
6883                 register_module (mono_object_domain (moduleb), moduleb, image);
6884
6885                 /* register the module with the assembly */
6886                 ass = ab->dynamic_assembly->assembly.image;
6887                 module_count = ass->module_count;
6888                 new_modules = g_new0 (MonoImage *, module_count + 1);
6889
6890                 if (ass->modules)
6891                         memcpy (new_modules, ass->modules, module_count * sizeof (MonoImage *));
6892                 new_modules [module_count] = &image->image;
6893                 mono_image_addref (&image->image);
6894
6895                 g_free (ass->modules);
6896                 ass->modules = new_modules;
6897                 ass->module_count ++;
6898         }
6899 }
6900
6901 void
6902 mono_image_set_wrappers_type (MonoReflectionModuleBuilder *moduleb, MonoReflectionType *type)
6903 {
6904         MonoDynamicImage *image = moduleb->dynamic_image;
6905
6906         g_assert (type->type);
6907         image->wrappers_type = mono_class_from_mono_type (type->type);
6908 }
6909
6910 #endif
6911
6912 /*
6913  * mono_assembly_get_object:
6914  * @domain: an app domain
6915  * @assembly: an assembly
6916  *
6917  * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
6918  */
6919 MonoReflectionAssembly*
6920 mono_assembly_get_object (MonoDomain *domain, MonoAssembly *assembly)
6921 {
6922         MonoError error;
6923         MonoReflectionAssembly *result;
6924         result = mono_assembly_get_object_checked (domain, assembly, &error);
6925         mono_error_cleanup (&error); /* FIXME new API that doesn't swallow the error */
6926         return result;
6927 }
6928 /*
6929  * mono_assembly_get_object_checked:
6930  * @domain: an app domain
6931  * @assembly: an assembly
6932  *
6933  * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
6934  */
6935 MonoReflectionAssembly*
6936 mono_assembly_get_object_checked (MonoDomain *domain, MonoAssembly *assembly, MonoError *error)
6937 {
6938         MonoReflectionAssembly *res;
6939
6940         mono_error_init (error);
6941
6942         CHECK_OBJECT (MonoReflectionAssembly *, assembly, NULL);
6943         res = (MonoReflectionAssembly *)mono_object_new_checked (domain, mono_class_get_mono_assembly_class (), error);
6944         if (!res)
6945                 return NULL;
6946         res->assembly = assembly;
6947
6948         CACHE_OBJECT (MonoReflectionAssembly *, assembly, res, NULL);
6949 }
6950
6951
6952
6953 MonoReflectionModule*
6954 mono_module_get_object   (MonoDomain *domain, MonoImage *image)
6955 {
6956         MonoError error;
6957         MonoReflectionModule *result;
6958         result = mono_module_get_object_checked (domain, image, &error);
6959         mono_error_raise_exception (&error);
6960         return result;
6961 }
6962
6963 MonoReflectionModule*
6964 mono_module_get_object_checked (MonoDomain *domain, MonoImage *image, MonoError *error)
6965 {
6966         MonoReflectionModule *res;
6967         char* basename;
6968
6969         mono_error_init (error);
6970         CHECK_OBJECT (MonoReflectionModule *, image, NULL);
6971         res = (MonoReflectionModule *)mono_object_new_checked (domain, mono_class_get_mono_module_class (), error);
6972         if (!res)
6973                 return NULL;
6974
6975         res->image = image;
6976         MonoReflectionAssembly *assm_obj = mono_assembly_get_object_checked (domain, image->assembly, error);
6977         if (!assm_obj)
6978                 return NULL;
6979         MONO_OBJECT_SETREF (res, assembly, assm_obj);
6980
6981         MONO_OBJECT_SETREF (res, fqname, mono_string_new (domain, image->name));
6982         basename = g_path_get_basename (image->name);
6983         MONO_OBJECT_SETREF (res, name, mono_string_new (domain, basename));
6984         MONO_OBJECT_SETREF (res, scopename, mono_string_new (domain, image->module_name));
6985
6986         g_free (basename);
6987
6988         if (image->assembly->image == image) {
6989                 res->token = mono_metadata_make_token (MONO_TABLE_MODULE, 1);
6990         } else {
6991                 int i;
6992                 res->token = 0;
6993                 if (image->assembly->image->modules) {
6994                         for (i = 0; i < image->assembly->image->module_count; i++) {
6995                                 if (image->assembly->image->modules [i] == image)
6996                                         res->token = mono_metadata_make_token (MONO_TABLE_MODULEREF, i + 1);
6997                         }
6998                         g_assert (res->token);
6999                 }
7000         }
7001
7002         CACHE_OBJECT (MonoReflectionModule *, image, res, NULL);
7003 }
7004
7005 MonoReflectionModule*
7006 mono_module_file_get_object (MonoDomain *domain, MonoImage *image, int table_index)
7007 {
7008         MonoError error;
7009         MonoReflectionModule *result;
7010         result = mono_module_file_get_object_checked (domain, image, table_index, &error);
7011         mono_error_cleanup (&error); /* FIXME new API that doesn't swallow the error */
7012         return result;
7013 }
7014
7015 MonoReflectionModule*
7016 mono_module_file_get_object_checked (MonoDomain *domain, MonoImage *image, int table_index, MonoError *error)
7017 {
7018         MonoReflectionModule *res;
7019         MonoTableInfo *table;
7020         guint32 cols [MONO_FILE_SIZE];
7021         const char *name;
7022         guint32 i, name_idx;
7023         const char *val;
7024
7025         mono_error_init (error);
7026
7027         res = (MonoReflectionModule *)mono_object_new_checked (domain, mono_class_get_mono_module_class (), error);
7028         if (!res)
7029                 return NULL;
7030
7031         table = &image->tables [MONO_TABLE_FILE];
7032         g_assert (table_index < table->rows);
7033         mono_metadata_decode_row (table, table_index, cols, MONO_FILE_SIZE);
7034
7035         res->image = NULL;
7036         MonoReflectionAssembly *assm_obj = mono_assembly_get_object_checked (domain, image->assembly, error);
7037         if (!assm_obj)
7038                 return NULL;
7039         MONO_OBJECT_SETREF (res, assembly, assm_obj);
7040         name = mono_metadata_string_heap (image, cols [MONO_FILE_NAME]);
7041
7042         /* Check whenever the row has a corresponding row in the moduleref table */
7043         table = &image->tables [MONO_TABLE_MODULEREF];
7044         for (i = 0; i < table->rows; ++i) {
7045                 name_idx = mono_metadata_decode_row_col (table, i, MONO_MODULEREF_NAME);
7046                 val = mono_metadata_string_heap (image, name_idx);
7047                 if (strcmp (val, name) == 0)
7048                         res->image = image->modules [i];
7049         }
7050
7051         MONO_OBJECT_SETREF (res, fqname, mono_string_new (domain, name));
7052         MONO_OBJECT_SETREF (res, name, mono_string_new (domain, name));
7053         MONO_OBJECT_SETREF (res, scopename, mono_string_new (domain, name));
7054         res->is_resource = cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA;
7055         res->token = mono_metadata_make_token (MONO_TABLE_FILE, table_index + 1);
7056
7057         return res;
7058 }
7059
7060 static gboolean
7061 verify_safe_for_managed_space (MonoType *type)
7062 {
7063         switch (type->type) {
7064 #ifdef DEBUG_HARDER
7065         case MONO_TYPE_ARRAY:
7066                 return verify_safe_for_managed_space (&type->data.array->eklass->byval_arg);
7067         case MONO_TYPE_PTR:
7068                 return verify_safe_for_managed_space (type->data.type);
7069         case MONO_TYPE_SZARRAY:
7070                 return verify_safe_for_managed_space (&type->data.klass->byval_arg);
7071         case MONO_TYPE_GENERICINST: {
7072                 MonoGenericInst *inst = type->data.generic_class->inst;
7073                 int i;
7074                 if (!inst->is_open)
7075                         break;
7076                 for (i = 0; i < inst->type_argc; ++i)
7077                         if (!verify_safe_for_managed_space (inst->type_argv [i]))
7078                                 return FALSE;
7079                 return TRUE;
7080         }
7081 #endif
7082         case MONO_TYPE_VAR:
7083         case MONO_TYPE_MVAR:
7084                 return TRUE;
7085         default:
7086                 return TRUE;
7087         }
7088 }
7089
7090 static MonoType*
7091 mono_type_normalize (MonoType *type)
7092 {
7093         int i;
7094         MonoGenericClass *gclass;
7095         MonoGenericInst *ginst;
7096         MonoClass *gtd;
7097         MonoGenericContainer *gcontainer;
7098         MonoType **argv = NULL;
7099         gboolean is_denorm_gtd = TRUE, requires_rebind = FALSE;
7100
7101         if (type->type != MONO_TYPE_GENERICINST)
7102                 return type;
7103
7104         gclass = type->data.generic_class;
7105         ginst = gclass->context.class_inst;
7106         if (!ginst->is_open)
7107                 return type;
7108
7109         gtd = gclass->container_class;
7110         gcontainer = gtd->generic_container;
7111         argv = g_newa (MonoType*, ginst->type_argc);
7112
7113         for (i = 0; i < ginst->type_argc; ++i) {
7114                 MonoType *t = ginst->type_argv [i], *norm;
7115                 if (t->type != MONO_TYPE_VAR || t->data.generic_param->num != i || t->data.generic_param->owner != gcontainer)
7116                         is_denorm_gtd = FALSE;
7117                 norm = mono_type_normalize (t);
7118                 argv [i] = norm;
7119                 if (norm != t)
7120                         requires_rebind = TRUE;
7121         }
7122
7123         if (is_denorm_gtd)
7124                 return type->byref == gtd->byval_arg.byref ? &gtd->byval_arg : &gtd->this_arg;
7125
7126         if (requires_rebind) {
7127                 MonoClass *klass = mono_class_bind_generic_parameters (gtd, ginst->type_argc, argv, gclass->is_dynamic);
7128                 return type->byref == klass->byval_arg.byref ? &klass->byval_arg : &klass->this_arg;
7129         }
7130
7131         return type;
7132 }
7133 /*
7134  * mono_type_get_object:
7135  * @domain: an app domain
7136  * @type: a type
7137  *
7138  * Return an System.MonoType object representing the type @type.
7139  */
7140 MonoReflectionType*
7141 mono_type_get_object (MonoDomain *domain, MonoType *type)
7142 {
7143         MonoError error;
7144         MonoReflectionType *ret = mono_type_get_object_checked (domain, type, &error);
7145         mono_error_raise_exception (&error);
7146
7147         return ret;
7148 }
7149
7150 MonoReflectionType*
7151 mono_type_get_object_checked (MonoDomain *domain, MonoType *type, MonoError *error)
7152 {
7153         MonoType *norm_type;
7154         MonoReflectionType *res;
7155         MonoClass *klass;
7156
7157         mono_error_init (error);
7158
7159         klass = mono_class_from_mono_type (type);
7160
7161         /*we must avoid using @type as it might have come
7162          * from a mono_metadata_type_dup and the caller
7163          * expects that is can be freed.
7164          * Using the right type from
7165          */
7166         type = klass->byval_arg.byref == type->byref ? &klass->byval_arg : &klass->this_arg;
7167
7168         /* void is very common */
7169         if (type->type == MONO_TYPE_VOID && domain->typeof_void)
7170                 return (MonoReflectionType*)domain->typeof_void;
7171
7172         /*
7173          * If the vtable of the given class was already created, we can use
7174          * the MonoType from there and avoid all locking and hash table lookups.
7175          *
7176          * We cannot do this for TypeBuilders as mono_reflection_create_runtime_class expects
7177          * that the resulting object is different.
7178          */
7179         if (type == &klass->byval_arg && !image_is_dynamic (klass->image)) {
7180                 MonoVTable *vtable = mono_class_try_get_vtable (domain, klass);
7181                 if (vtable && vtable->type)
7182                         return (MonoReflectionType *)vtable->type;
7183         }
7184
7185         mono_loader_lock (); /*FIXME mono_class_init and mono_class_vtable acquire it*/
7186         mono_domain_lock (domain);
7187         if (!domain->type_hash)
7188                 domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
7189                                 (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection types table");
7190         if ((res = (MonoReflectionType *)mono_g_hash_table_lookup (domain->type_hash, type))) {
7191                 mono_domain_unlock (domain);
7192                 mono_loader_unlock ();
7193                 return res;
7194         }
7195
7196         /*Types must be normalized so a generic instance of the GTD get's the same inner type.
7197          * For example in: Foo<A,B>; Bar<A> : Foo<A, Bar<A>>
7198          * The second Bar will be encoded a generic instance of Bar with <A> as parameter.
7199          * On all other places, Bar<A> will be encoded as the GTD itself. This is an implementation
7200          * artifact of how generics are encoded and should be transparent to managed code so we
7201          * need to weed out this diference when retrieving managed System.Type objects.
7202          */
7203         norm_type = mono_type_normalize (type);
7204         if (norm_type != type) {
7205                 res = mono_type_get_object_checked (domain, norm_type, error);
7206                 if (!mono_error_ok (error))
7207                         return NULL;
7208                 mono_g_hash_table_insert (domain->type_hash, type, res);
7209                 mono_domain_unlock (domain);
7210                 mono_loader_unlock ();
7211                 return res;
7212         }
7213
7214         /* This MonoGenericClass hack is no longer necessary. Let's leave it here until we finish with the 2-stage type-builder setup.*/
7215         if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_class->is_dynamic && !type->data.generic_class->container_class->wastypebuilder)
7216                 g_assert (0);
7217
7218         if (!verify_safe_for_managed_space (type)) {
7219                 mono_domain_unlock (domain);
7220                 mono_loader_unlock ();
7221                 mono_error_set_generic_error (error, "System", "InvalidOperationException", "This type cannot be propagated to managed space");
7222                 return NULL;
7223         }
7224
7225         if (mono_class_get_ref_info (klass) && !klass->wastypebuilder) {
7226                 gboolean is_type_done = TRUE;
7227                 /* Generic parameters have reflection_info set but they are not finished together with their enclosing type.
7228                  * We must ensure that once a type is finished we don't return a GenericTypeParameterBuilder.
7229                  * We can't simply close the types as this will interfere with other parts of the generics machinery.
7230                 */
7231                 if (klass->byval_arg.type == MONO_TYPE_MVAR || klass->byval_arg.type == MONO_TYPE_VAR) {
7232                         MonoGenericParam *gparam = klass->byval_arg.data.generic_param;
7233
7234                         if (gparam->owner && gparam->owner->is_method) {
7235                                 MonoMethod *method = gparam->owner->owner.method;
7236                                 if (method && mono_class_get_generic_type_definition (method->klass)->wastypebuilder)
7237                                         is_type_done = FALSE;
7238                         } else if (gparam->owner && !gparam->owner->is_method) {
7239                                 MonoClass *klass = gparam->owner->owner.klass;
7240                                 if (klass && mono_class_get_generic_type_definition (klass)->wastypebuilder)
7241                                         is_type_done = FALSE;
7242                         }
7243                 }
7244
7245                 /* g_assert_not_reached (); */
7246                 /* should this be considered an error condition? */
7247                 if (is_type_done && !type->byref) {
7248                         mono_domain_unlock (domain);
7249                         mono_loader_unlock ();
7250                         return (MonoReflectionType *)mono_class_get_ref_info (klass);
7251                 }
7252         }
7253         /* This is stored in vtables/JITted code so it has to be pinned */
7254         res = (MonoReflectionType *)mono_object_new_pinned (domain, mono_defaults.monotype_class, error);
7255         if (!mono_error_ok (error))
7256                 return NULL;
7257
7258         res->type = type;
7259         mono_g_hash_table_insert (domain->type_hash, type, res);
7260
7261         if (type->type == MONO_TYPE_VOID)
7262                 domain->typeof_void = (MonoObject*)res;
7263
7264         mono_domain_unlock (domain);
7265         mono_loader_unlock ();
7266         return res;
7267 }
7268
7269 /*
7270  * mono_method_get_object:
7271  * @domain: an app domain
7272  * @method: a method
7273  * @refclass: the reflected type (can be NULL)
7274  *
7275  * Return an System.Reflection.MonoMethod object representing the method @method.
7276  */
7277 MonoReflectionMethod*
7278 mono_method_get_object (MonoDomain *domain, MonoMethod *method, MonoClass *refclass)
7279 {
7280         MonoError error;
7281         MonoReflectionMethod *ret = NULL;
7282         ret = mono_method_get_object_checked (domain, method, refclass, &error);
7283         mono_error_raise_exception (&error);
7284         return ret;
7285 }
7286
7287 /*
7288  * mono_method_get_object_checked:
7289  * @domain: an app domain
7290  * @method: a method
7291  * @refclass: the reflected type (can be NULL)
7292  * @error: set on error.
7293  *
7294  * Return an System.Reflection.MonoMethod object representing the method @method.
7295  * Returns NULL and sets @error on error.
7296  */
7297 MonoReflectionMethod*
7298 mono_method_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
7299 {
7300         /*
7301          * We use the same C representation for methods and constructors, but the type
7302          * name in C# is different.
7303          */
7304         MonoReflectionType *rt;
7305         MonoClass *klass;
7306         MonoReflectionMethod *ret;
7307
7308         mono_error_init (error);
7309
7310         if (method->is_inflated) {
7311                 MonoReflectionGenericMethod *gret;
7312
7313                 if (!refclass)
7314                         refclass = method->klass;
7315                 CHECK_OBJECT (MonoReflectionMethod *, method, refclass);
7316                 if ((*method->name == '.') && (!strcmp (method->name, ".ctor") || !strcmp (method->name, ".cctor"))) {
7317                         klass = mono_class_get_mono_generic_cmethod_class ();
7318                 } else {
7319                         klass = mono_class_get_mono_generic_method_class ();
7320                 }
7321                 gret = (MonoReflectionGenericMethod*)mono_object_new_checked (domain, klass, error);
7322                 if (!mono_error_ok (error))
7323                         goto leave;
7324                 gret->method.method = method;
7325
7326                 MONO_OBJECT_SETREF (gret, method.name, mono_string_new (domain, method->name));
7327
7328                 rt = mono_type_get_object_checked (domain, &refclass->byval_arg, error);
7329                 if (!mono_error_ok (error))
7330                     goto leave;
7331
7332                 MONO_OBJECT_SETREF (gret, method.reftype, rt);
7333
7334                 CACHE_OBJECT (MonoReflectionMethod *, method, (MonoReflectionMethod*)gret, refclass);
7335         }
7336
7337         if (!refclass)
7338                 refclass = method->klass;
7339
7340         CHECK_OBJECT (MonoReflectionMethod *, method, refclass);
7341         if (*method->name == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0)) {
7342                 klass = mono_class_get_mono_cmethod_class ();
7343         }
7344         else {
7345                 klass = mono_class_get_mono_method_class ();
7346         }
7347         ret = (MonoReflectionMethod*)mono_object_new_checked (domain, klass, error);
7348         if (!mono_error_ok (error))
7349                 goto leave;
7350         ret->method = method;
7351
7352         rt = mono_type_get_object_checked (domain, &refclass->byval_arg, error);
7353         if (!mono_error_ok (error))
7354                 goto leave;
7355
7356         MONO_OBJECT_SETREF (ret, reftype, rt);
7357
7358         CACHE_OBJECT (MonoReflectionMethod *, method, ret, refclass);
7359
7360 leave:
7361         g_assert (!mono_error_ok (error));
7362         return NULL;
7363 }
7364
7365 /*
7366  * mono_method_clear_object:
7367  *
7368  *   Clear the cached reflection objects for the dynamic method METHOD.
7369  */
7370 void
7371 mono_method_clear_object (MonoDomain *domain, MonoMethod *method)
7372 {
7373         MonoClass *klass;
7374         g_assert (method_is_dynamic (method));
7375
7376         klass = method->klass;
7377         while (klass) {
7378                 clear_cached_object (domain, method, klass);
7379                 klass = klass->parent;
7380         }
7381         /* Added by mono_param_get_objects () */
7382         clear_cached_object (domain, &(method->signature), NULL);
7383         klass = method->klass;
7384         while (klass) {
7385                 clear_cached_object (domain, &(method->signature), klass);
7386                 klass = klass->parent;
7387         }
7388 }
7389
7390 /*
7391  * mono_field_get_object:
7392  * @domain: an app domain
7393  * @klass: a type
7394  * @field: a field
7395  *
7396  * Return an System.Reflection.MonoField object representing the field @field
7397  * in class @klass.
7398  */
7399 MonoReflectionField*
7400 mono_field_get_object (MonoDomain *domain, MonoClass *klass, MonoClassField *field)
7401 {
7402         MonoError error;
7403         MonoReflectionField *result;
7404         result = mono_field_get_object_checked (domain, klass, field, &error);
7405         mono_error_raise_exception (&error);
7406         return result;
7407 }
7408
7409 /*
7410  * mono_field_get_object_checked:
7411  * @domain: an app domain
7412  * @klass: a type
7413  * @field: a field
7414  * @error: set on error
7415  *
7416  * Return an System.Reflection.MonoField object representing the field @field
7417  * in class @klass. On error, returns NULL and sets @error.
7418  */
7419 MonoReflectionField*
7420 mono_field_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoClassField *field, MonoError *error)
7421 {
7422         MonoReflectionType *rt;
7423         MonoReflectionField *res;
7424
7425         mono_error_init (error);
7426
7427         CHECK_OBJECT (MonoReflectionField *, field, klass);
7428         res = (MonoReflectionField *)mono_object_new_checked (domain, mono_class_get_mono_field_class (), error);
7429         if (!res)
7430                 return NULL;
7431         res->klass = klass;
7432         res->field = field;
7433         MONO_OBJECT_SETREF (res, name, mono_string_new (domain, mono_field_get_name (field)));
7434
7435         if (is_field_on_inst (field)) {
7436                 res->attrs = get_field_on_inst_generic_type (field)->attrs;
7437
7438                 rt = mono_type_get_object_checked (domain, field->type, error);
7439                 if (!mono_error_ok (error))
7440                         return NULL;
7441
7442                 MONO_OBJECT_SETREF (res, type, rt);
7443         } else {
7444                 if (field->type) {
7445                         rt = mono_type_get_object_checked (domain, field->type, error);
7446                         if (!mono_error_ok (error))
7447                                 return NULL;
7448
7449                         MONO_OBJECT_SETREF (res, type, rt);
7450                 }
7451                 res->attrs = mono_field_get_flags (field);
7452         }
7453         CACHE_OBJECT (MonoReflectionField *, field, res, klass);
7454 }
7455
7456 /*
7457  * mono_property_get_object:
7458  * @domain: an app domain
7459  * @klass: a type
7460  * @property: a property
7461  *
7462  * Return an System.Reflection.MonoProperty object representing the property @property
7463  * in class @klass.
7464  */
7465 MonoReflectionProperty*
7466 mono_property_get_object (MonoDomain *domain, MonoClass *klass, MonoProperty *property)
7467 {
7468         MonoError error;
7469         MonoReflectionProperty *result;
7470         result = mono_property_get_object_checked (domain, klass, property, &error);
7471         mono_error_raise_exception (&error);
7472         return result;
7473 }
7474
7475 /**
7476  * mono_property_get_object:
7477  * @domain: an app domain
7478  * @klass: a type
7479  * @property: a property
7480  * @error: set on error
7481  *
7482  * Return an System.Reflection.MonoProperty object representing the property @property
7483  * in class @klass.  On error returns NULL and sets @error.
7484  */
7485 MonoReflectionProperty*
7486 mono_property_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoProperty *property, MonoError *error)
7487 {
7488         MonoReflectionProperty *res;
7489
7490         mono_error_init (error);
7491
7492         CHECK_OBJECT (MonoReflectionProperty *, property, klass);
7493         res = (MonoReflectionProperty *)mono_object_new_checked (domain, mono_class_get_mono_property_class (), error);
7494         if (!res)
7495                 return NULL;
7496         res->klass = klass;
7497         res->property = property;
7498         CACHE_OBJECT (MonoReflectionProperty *, property, res, klass);
7499 }
7500
7501 /*
7502  * mono_event_get_object:
7503  * @domain: an app domain
7504  * @klass: a type
7505  * @event: a event
7506  *
7507  * Return an System.Reflection.MonoEvent object representing the event @event
7508  * in class @klass.
7509  */
7510 MonoReflectionEvent*
7511 mono_event_get_object (MonoDomain *domain, MonoClass *klass, MonoEvent *event)
7512 {
7513         MonoError error;
7514         MonoReflectionEvent *result;
7515         result = mono_event_get_object_checked (domain, klass, event, &error);
7516         mono_error_raise_exception (&error);
7517         return result;
7518 }
7519
7520 /**
7521  * mono_event_get_object_checked:
7522  * @domain: an app domain
7523  * @klass: a type
7524  * @event: a event
7525  * @error: set on error
7526  *
7527  * Return an System.Reflection.MonoEvent object representing the event @event
7528  * in class @klass. On failure sets @error and returns NULL
7529  */
7530 MonoReflectionEvent*
7531 mono_event_get_object_checked (MonoDomain *domain, MonoClass *klass, MonoEvent *event, MonoError *error)
7532 {
7533         MonoReflectionEvent *res;
7534         MonoReflectionMonoEvent *mono_event;
7535
7536         CHECK_OBJECT (MonoReflectionEvent *, event, klass);
7537         mono_event = (MonoReflectionMonoEvent *)mono_object_new_checked (domain, mono_class_get_mono_event_class (), error);
7538         if (!mono_event)
7539                 return NULL;
7540         mono_event->klass = klass;
7541         mono_event->event = event;
7542         res = (MonoReflectionEvent*)mono_event;
7543         CACHE_OBJECT (MonoReflectionEvent *, event, res, klass);
7544 }
7545
7546 /**
7547  * mono_get_reflection_missing_object:
7548  * @domain: Domain where the object lives
7549  *
7550  * Returns the System.Reflection.Missing.Value singleton object
7551  * (of type System.Reflection.Missing).
7552  *
7553  * Used as the value for ParameterInfo.DefaultValue when Optional
7554  * is present
7555  */
7556 static MonoObject *
7557 mono_get_reflection_missing_object (MonoDomain *domain)
7558 {
7559         MonoError error;
7560         MonoObject *obj;
7561         static MonoClassField *missing_value_field = NULL;
7562
7563         if (!missing_value_field) {
7564                 MonoClass *missing_klass;
7565                 missing_klass = mono_class_get_missing_class ();
7566                 mono_class_init (missing_klass);
7567                 missing_value_field = mono_class_get_field_from_name (missing_klass, "Value");
7568                 g_assert (missing_value_field);
7569         }
7570         obj = mono_field_get_value_object_checked (domain, missing_value_field, NULL, &error);
7571         mono_error_assert_ok (&error);
7572         return obj;
7573 }
7574
7575 static MonoObject*
7576 get_dbnull (MonoDomain *domain, MonoObject **dbnull)
7577 {
7578         if (!*dbnull)
7579                 *dbnull = mono_get_dbnull_object (domain);
7580         return *dbnull;
7581 }
7582
7583 static MonoObject*
7584 get_reflection_missing (MonoDomain *domain, MonoObject **reflection_missing)
7585 {
7586         if (!*reflection_missing)
7587                 *reflection_missing = mono_get_reflection_missing_object (domain);
7588         return *reflection_missing;
7589 }
7590
7591 /*
7592  * mono_param_get_objects:
7593  * @domain: an app domain
7594  * @method: a method
7595  *
7596  * Return an System.Reflection.ParameterInfo array object representing the parameters
7597  * in the method @method.
7598  */
7599 MonoArray*
7600 mono_param_get_objects_internal (MonoDomain *domain, MonoMethod *method, MonoClass *refclass, MonoError *error)
7601 {
7602         static MonoClass *System_Reflection_ParameterInfo;
7603         static MonoClass *System_Reflection_ParameterInfo_array;
7604         MonoArray *res = NULL;
7605         MonoReflectionMethod *member = NULL;
7606         MonoReflectionParameter *param = NULL;
7607         char **names = NULL, **blobs = NULL;
7608         guint32 *types = NULL;
7609         MonoType *type = NULL;
7610         MonoObject *dbnull = NULL;
7611         MonoObject *missing = NULL;
7612         MonoMarshalSpec **mspecs = NULL;
7613         MonoMethodSignature *sig = NULL;
7614         MonoVTable *pinfo_vtable;
7615         MonoReflectionType *rt;
7616         int i;
7617
7618         mono_error_init (error);
7619
7620         if (!System_Reflection_ParameterInfo_array) {
7621                 MonoClass *klass;
7622
7623                 klass = mono_class_get_mono_parameter_info_class ();
7624
7625                 mono_memory_barrier ();
7626                 System_Reflection_ParameterInfo = klass;
7627
7628
7629                 klass = mono_array_class_get (klass, 1);
7630                 mono_memory_barrier ();
7631                 System_Reflection_ParameterInfo_array = klass;
7632         }
7633
7634         sig = mono_method_signature_checked (method, error);
7635         if (!mono_error_ok (error))
7636                 goto leave;
7637
7638         if (!sig->param_count) {
7639                 res = mono_array_new_specific_checked (mono_class_vtable (domain, System_Reflection_ParameterInfo_array), 0, error);
7640                 if (!res)
7641                         goto leave;
7642
7643                 return res;
7644         }
7645
7646         /* Note: the cache is based on the address of the signature into the method
7647          * since we already cache MethodInfos with the method as keys.
7648          */
7649         CHECK_OBJECT (MonoArray*, &(method->signature), refclass);
7650
7651         member = mono_method_get_object_checked (domain, method, refclass, error);
7652         if (!member)
7653                 goto leave;
7654         names = g_new (char *, sig->param_count);
7655         mono_method_get_param_names (method, (const char **) names);
7656
7657         mspecs = g_new (MonoMarshalSpec*, sig->param_count + 1);
7658         mono_method_get_marshal_info (method, mspecs);
7659
7660         res = mono_array_new_specific_checked (mono_class_vtable (domain, System_Reflection_ParameterInfo_array), sig->param_count, error);
7661         if (!res)
7662                 goto leave;
7663
7664         pinfo_vtable = mono_class_vtable (domain, System_Reflection_ParameterInfo);
7665         for (i = 0; i < sig->param_count; ++i) {
7666                 param = (MonoReflectionParameter *) mono_object_new_specific_checked (pinfo_vtable, error);
7667                 if (!param)
7668                         goto leave;
7669
7670                 rt = mono_type_get_object_checked (domain, sig->params [i], error);
7671                 if (!rt)
7672                         goto leave;
7673
7674                 MONO_OBJECT_SETREF (param, ClassImpl, rt);
7675
7676                 MONO_OBJECT_SETREF (param, MemberImpl, (MonoObject*)member);
7677
7678                 MONO_OBJECT_SETREF (param, NameImpl, mono_string_new (domain, names [i]));
7679
7680                 param->PositionImpl = i;
7681                 param->AttrsImpl = sig->params [i]->attrs;
7682
7683                 if (!(param->AttrsImpl & PARAM_ATTRIBUTE_HAS_DEFAULT)) {
7684                         if (param->AttrsImpl & PARAM_ATTRIBUTE_OPTIONAL)
7685                                 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_reflection_missing (domain, &missing));
7686                         else
7687                                 MONO_OBJECT_SETREF (param, DefaultValueImpl, get_dbnull (domain, &dbnull));
7688                 } else {
7689
7690                         if (!blobs) {
7691                                 blobs = g_new0 (char *, sig->param_count);
7692                                 types = g_new0 (guint32, sig->param_count);
7693                                 get_default_param_value_blobs (method, blobs, types);
7694                         }
7695
7696                         /* Build MonoType for the type from the Constant Table */
7697                         if (!type)
7698                                 type = g_new0 (MonoType, 1);
7699                         type->type = (MonoTypeEnum)types [i];
7700                         type->data.klass = NULL;
7701                         if (types [i] == MONO_TYPE_CLASS)
7702                                 type->data.klass = mono_defaults.object_class;
7703                         else if ((sig->params [i]->type == MONO_TYPE_VALUETYPE) && sig->params [i]->data.klass->enumtype) {
7704                                 /* For enums, types [i] contains the base type */
7705
7706                                         type->type = MONO_TYPE_VALUETYPE;
7707                                         type->data.klass = mono_class_from_mono_type (sig->params [i]);
7708                         } else
7709                                 type->data.klass = mono_class_from_mono_type (type);
7710
7711                         MonoObject *default_val_obj = mono_get_object_from_blob (domain, type, blobs [i], error);
7712                         if (!is_ok (error))
7713                                 goto leave;
7714                         MONO_OBJECT_SETREF (param, DefaultValueImpl, default_val_obj);
7715
7716                         /* Type in the Constant table is MONO_TYPE_CLASS for nulls */
7717                         if (types [i] != MONO_TYPE_CLASS && !param->DefaultValueImpl) {
7718                                 if (param->AttrsImpl & PARAM_ATTRIBUTE_OPTIONAL)
7719                                         MONO_OBJECT_SETREF (param, DefaultValueImpl, get_reflection_missing (domain, &missing));
7720                                 else
7721                                         MONO_OBJECT_SETREF (param, DefaultValueImpl, get_dbnull (domain, &dbnull));
7722                         }
7723
7724                 }
7725
7726                 if (mspecs [i + 1]) {
7727                         MonoReflectionMarshalAsAttribute* mobj;
7728                         mobj = mono_reflection_marshal_as_attribute_from_marshal_spec (domain, method->klass, mspecs [i + 1], error);
7729                         if (!mobj)
7730                                 goto leave;
7731                         MONO_OBJECT_SETREF (param, MarshalAsImpl, (MonoObject*)mobj);
7732                 }
7733
7734                 mono_array_setref (res, i, param);
7735         }
7736
7737 leave:
7738         g_free (names);
7739         g_free (blobs);
7740         g_free (types);
7741         g_free (type);
7742
7743         if (sig) {
7744                 for (i = sig->param_count; i >= 0; i--) {
7745                         if (mspecs [i])
7746                                 mono_metadata_free_marshal_spec (mspecs [i]);
7747                 }
7748         }
7749         g_free (mspecs);
7750
7751         if (!is_ok (error))
7752                 return NULL;
7753
7754         CACHE_OBJECT (MonoArray *, &(method->signature), res, refclass);
7755 }
7756
7757 MonoArray*
7758 mono_param_get_objects (MonoDomain *domain, MonoMethod *method)
7759 {
7760         MonoError error;
7761         MonoArray *result = mono_param_get_objects_internal (domain, method, NULL, &error);
7762         mono_error_assert_ok (&error);
7763         return result;
7764 }
7765
7766 /*
7767  * mono_method_body_get_object:
7768  * @domain: an app domain
7769  * @method: a method
7770  *
7771  * Return an System.Reflection.MethodBody object representing the method @method.
7772  */
7773 MonoReflectionMethodBody*
7774 mono_method_body_get_object (MonoDomain *domain, MonoMethod *method)
7775 {
7776         MonoError error;
7777         MonoReflectionMethodBody *result = mono_method_body_get_object_checked (domain, method, &error);
7778         mono_error_cleanup (&error); /* FIXME better API that doesn't swallow the error */
7779         return result;
7780 }
7781
7782 /**
7783  * mono_method_body_get_object_checked:
7784  * @domain: an app domain
7785  * @method: a method
7786  * @error: set on error
7787  *
7788  * Return an System.Reflection.MethodBody object representing the
7789  * method @method.  On failure, returns NULL and sets @error.
7790  */
7791 MonoReflectionMethodBody*
7792 mono_method_body_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoError *error)
7793 {
7794         MonoReflectionMethodBody *ret;
7795         MonoMethodHeader *header;
7796         MonoImage *image;
7797         MonoReflectionType *rt;
7798         guint32 method_rva, local_var_sig_token;
7799         char *ptr;
7800         unsigned char format, flags;
7801         int i;
7802
7803         mono_error_init (error);
7804
7805         /* for compatibility with .net */
7806         if (method_is_dynamic (method)) {
7807                 mono_error_set_generic_error (error, "System", "InvalidOperationException", "");
7808                 return NULL;
7809         }
7810
7811         CHECK_OBJECT (MonoReflectionMethodBody *, method, NULL);
7812
7813         if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
7814                 (method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
7815             (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
7816                 (method->klass->image->raw_data && method->klass->image->raw_data [1] != 'Z') ||
7817             (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME))
7818                 return NULL;
7819
7820         image = method->klass->image;
7821         header = mono_method_get_header_checked (method, error);
7822         return_val_if_nok (error, NULL);
7823
7824         if (!image_is_dynamic (image)) {
7825                 /* Obtain local vars signature token */
7826                 method_rva = mono_metadata_decode_row_col (&image->tables [MONO_TABLE_METHOD], mono_metadata_token_index (method->token) - 1, MONO_METHOD_RVA);
7827                 ptr = mono_image_rva_map (image, method_rva);
7828                 flags = *(const unsigned char *) ptr;
7829                 format = flags & METHOD_HEADER_FORMAT_MASK;
7830                 switch (format){
7831                 case METHOD_HEADER_TINY_FORMAT:
7832                         local_var_sig_token = 0;
7833                         break;
7834                 case METHOD_HEADER_FAT_FORMAT:
7835                         ptr += 2;
7836                         ptr += 2;
7837                         ptr += 4;
7838                         local_var_sig_token = read32 (ptr);
7839                         break;
7840                 default:
7841                         g_assert_not_reached ();
7842                 }
7843         } else
7844                 local_var_sig_token = 0; //FIXME
7845
7846         ret = (MonoReflectionMethodBody*)mono_object_new_checked (domain, mono_class_get_method_body_class (), error);
7847         if (!is_ok (error))
7848                 goto fail;
7849
7850         ret->init_locals = header->init_locals;
7851         ret->max_stack = header->max_stack;
7852         ret->local_var_sig_token = local_var_sig_token;
7853         MONO_OBJECT_SETREF (ret, il, mono_array_new_cached (domain, mono_defaults.byte_class, header->code_size));
7854         memcpy (mono_array_addr (ret->il, guint8, 0), header->code, header->code_size);
7855
7856         /* Locals */
7857         MONO_OBJECT_SETREF (ret, locals, mono_array_new_cached (domain, mono_class_get_local_variable_info_class (), header->num_locals));
7858         for (i = 0; i < header->num_locals; ++i) {
7859                 MonoReflectionLocalVariableInfo *info = (MonoReflectionLocalVariableInfo*)mono_object_new_checked (domain, mono_class_get_local_variable_info_class (), error);
7860                 if (!is_ok (error))
7861                         goto fail;
7862
7863                 rt = mono_type_get_object_checked (domain, header->locals [i], error);
7864                 if (!is_ok (error))
7865                         goto fail;
7866
7867                 MONO_OBJECT_SETREF (info, local_type, rt);
7868
7869                 info->is_pinned = header->locals [i]->pinned;
7870                 info->local_index = i;
7871                 mono_array_setref (ret->locals, i, info);
7872         }
7873
7874         /* Exceptions */
7875         MONO_OBJECT_SETREF (ret, clauses, mono_array_new_cached (domain, mono_class_get_exception_handling_clause_class (), header->num_clauses));
7876         for (i = 0; i < header->num_clauses; ++i) {
7877                 MonoReflectionExceptionHandlingClause *info = (MonoReflectionExceptionHandlingClause*)mono_object_new_checked (domain, mono_class_get_exception_handling_clause_class (), error);
7878                 if (!is_ok (error))
7879                         goto fail;
7880                 MonoExceptionClause *clause = &header->clauses [i];
7881
7882                 info->flags = clause->flags;
7883                 info->try_offset = clause->try_offset;
7884                 info->try_length = clause->try_len;
7885                 info->handler_offset = clause->handler_offset;
7886                 info->handler_length = clause->handler_len;
7887                 if (clause->flags == MONO_EXCEPTION_CLAUSE_FILTER)
7888                         info->filter_offset = clause->data.filter_offset;
7889                 else if (clause->data.catch_class) {
7890                         rt = mono_type_get_object_checked (mono_domain_get (), &clause->data.catch_class->byval_arg, error);
7891                         if (!is_ok (error))
7892                                 goto fail;
7893
7894                         MONO_OBJECT_SETREF (info, catch_type, rt);
7895                 }
7896
7897                 mono_array_setref (ret->clauses, i, info);
7898         }
7899
7900         mono_metadata_free_mh (header);
7901         CACHE_OBJECT (MonoReflectionMethodBody *, method, ret, NULL);
7902         return ret;
7903
7904 fail:
7905         mono_metadata_free_mh (header);
7906         return NULL;
7907 }
7908
7909 /**
7910  * mono_get_dbnull_object:
7911  * @domain: Domain where the object lives
7912  *
7913  * Returns the System.DBNull.Value singleton object
7914  *
7915  * Used as the value for ParameterInfo.DefaultValue
7916  */
7917 MonoObject *
7918 mono_get_dbnull_object (MonoDomain *domain)
7919 {
7920         MonoError error;
7921         MonoObject *obj;
7922         static MonoClassField *dbnull_value_field = NULL;
7923
7924         if (!dbnull_value_field) {
7925                 MonoClass *dbnull_klass;
7926                 dbnull_klass = mono_class_get_dbnull_class ();
7927                 dbnull_value_field = mono_class_get_field_from_name (dbnull_klass, "Value");
7928                 g_assert (dbnull_value_field);
7929         }
7930         obj = mono_field_get_value_object_checked (domain, dbnull_value_field, NULL, &error);
7931         mono_error_assert_ok (&error);
7932         return obj;
7933 }
7934
7935 static void
7936 get_default_param_value_blobs (MonoMethod *method, char **blobs, guint32 *types)
7937 {
7938         guint32 param_index, i, lastp, crow = 0;
7939         guint32 param_cols [MONO_PARAM_SIZE], const_cols [MONO_CONSTANT_SIZE];
7940         gint32 idx;
7941
7942         MonoClass *klass = method->klass;
7943         MonoImage *image = klass->image;
7944         MonoMethodSignature *methodsig = mono_method_signature (method);
7945
7946         MonoTableInfo *constt;
7947         MonoTableInfo *methodt;
7948         MonoTableInfo *paramt;
7949
7950         if (!methodsig->param_count)
7951                 return;
7952
7953         mono_class_init (klass);
7954
7955         if (image_is_dynamic (klass->image)) {
7956                 MonoReflectionMethodAux *aux;
7957                 if (method->is_inflated)
7958                         method = ((MonoMethodInflated*)method)->declaring;
7959                 aux = (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
7960                 if (aux && aux->param_defaults) {
7961                         memcpy (blobs, &(aux->param_defaults [1]), methodsig->param_count * sizeof (char*));
7962                         memcpy (types, &(aux->param_default_types [1]), methodsig->param_count * sizeof (guint32));
7963                 }
7964                 return;
7965         }
7966
7967         methodt = &klass->image->tables [MONO_TABLE_METHOD];
7968         paramt = &klass->image->tables [MONO_TABLE_PARAM];
7969         constt = &image->tables [MONO_TABLE_CONSTANT];
7970
7971         idx = mono_method_get_index (method) - 1;
7972         g_assert (idx != -1);
7973
7974         param_index = mono_metadata_decode_row_col (methodt, idx, MONO_METHOD_PARAMLIST);
7975         if (idx + 1 < methodt->rows)
7976                 lastp = mono_metadata_decode_row_col (methodt, idx + 1, MONO_METHOD_PARAMLIST);
7977         else
7978                 lastp = paramt->rows + 1;
7979
7980         for (i = param_index; i < lastp; ++i) {
7981                 guint32 paramseq;
7982
7983                 mono_metadata_decode_row (paramt, i - 1, param_cols, MONO_PARAM_SIZE);
7984                 paramseq = param_cols [MONO_PARAM_SEQUENCE];
7985
7986                 if (!(param_cols [MONO_PARAM_FLAGS] & PARAM_ATTRIBUTE_HAS_DEFAULT))
7987                         continue;
7988
7989                 crow = mono_metadata_get_constant_index (image, MONO_TOKEN_PARAM_DEF | i, crow + 1);
7990                 if (!crow) {
7991                         continue;
7992                 }
7993
7994                 mono_metadata_decode_row (constt, crow - 1, const_cols, MONO_CONSTANT_SIZE);
7995                 blobs [paramseq - 1] = (char *)mono_metadata_blob_heap (image, const_cols [MONO_CONSTANT_VALUE]);
7996                 types [paramseq - 1] = const_cols [MONO_CONSTANT_TYPE];
7997         }
7998
7999         return;
8000 }
8001
8002 MonoObject *
8003 mono_get_object_from_blob (MonoDomain *domain, MonoType *type, const char *blob, MonoError *error)
8004 {
8005         void *retval;
8006         MonoClass *klass;
8007         MonoObject *object;
8008         MonoType *basetype = type;
8009
8010         mono_error_init (error);
8011
8012         if (!blob)
8013                 return NULL;
8014
8015         klass = mono_class_from_mono_type (type);
8016         if (klass->valuetype) {
8017                 object = mono_object_new_checked (domain, klass, error);
8018                 return_val_if_nok (error, NULL);
8019                 retval = ((gchar *) object + sizeof (MonoObject));
8020                 if (klass->enumtype)
8021                         basetype = mono_class_enum_basetype (klass);
8022         } else {
8023                 retval = &object;
8024         }
8025
8026         if (!mono_get_constant_value_from_blob (domain, basetype->type,  blob, retval))
8027                 return object;
8028         else
8029                 return NULL;
8030 }
8031
8032 static int
8033 assembly_name_to_aname (MonoAssemblyName *assembly, char *p) {
8034         int found_sep;
8035         char *s;
8036         gboolean quoted = FALSE;
8037
8038         memset (assembly, 0, sizeof (MonoAssemblyName));
8039         assembly->culture = "";
8040         memset (assembly->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
8041
8042         if (*p == '"') {
8043                 quoted = TRUE;
8044                 p++;
8045         }
8046         assembly->name = p;
8047         while (*p && (isalnum (*p) || *p == '.' || *p == '-' || *p == '_' || *p == '$' || *p == '@' || g_ascii_isspace (*p)))
8048                 p++;
8049         if (quoted) {
8050                 if (*p != '"')
8051                         return 1;
8052                 *p = 0;
8053                 p++;
8054         }
8055         if (*p != ',')
8056                 return 1;
8057         *p = 0;
8058         /* Remove trailing whitespace */
8059         s = p - 1;
8060         while (*s && g_ascii_isspace (*s))
8061                 *s-- = 0;
8062         p ++;
8063         while (g_ascii_isspace (*p))
8064                 p++;
8065         while (*p) {
8066                 if (*p == 'V' && g_ascii_strncasecmp (p, "Version=", 8) == 0) {
8067                         p += 8;
8068                         assembly->major = strtoul (p, &s, 10);
8069                         if (s == p || *s != '.')
8070                                 return 1;
8071                         p = ++s;
8072                         assembly->minor = strtoul (p, &s, 10);
8073                         if (s == p || *s != '.')
8074                                 return 1;
8075                         p = ++s;
8076                         assembly->build = strtoul (p, &s, 10);
8077                         if (s == p || *s != '.')
8078                                 return 1;
8079                         p = ++s;
8080                         assembly->revision = strtoul (p, &s, 10);
8081                         if (s == p)
8082                                 return 1;
8083                         p = s;
8084                 } else if (*p == 'C' && g_ascii_strncasecmp (p, "Culture=", 8) == 0) {
8085                         p += 8;
8086                         if (g_ascii_strncasecmp (p, "neutral", 7) == 0) {
8087                                 assembly->culture = "";
8088                                 p += 7;
8089                         } else {
8090                                 assembly->culture = p;
8091                                 while (*p && *p != ',') {
8092                                         p++;
8093                                 }
8094                         }
8095                 } else if (*p == 'P' && g_ascii_strncasecmp (p, "PublicKeyToken=", 15) == 0) {
8096                         p += 15;
8097                         if (strncmp (p, "null", 4) == 0) {
8098                                 p += 4;
8099                         } else {
8100                                 int len;
8101                                 gchar *start = p;
8102                                 while (*p && *p != ',') {
8103                                         p++;
8104                                 }
8105                                 len = (p - start + 1);
8106                                 if (len > MONO_PUBLIC_KEY_TOKEN_LENGTH)
8107                                         len = MONO_PUBLIC_KEY_TOKEN_LENGTH;
8108                                 g_strlcpy ((char*)assembly->public_key_token, start, len);
8109                         }
8110                 } else {
8111                         while (*p && *p != ',')
8112                                 p++;
8113                 }
8114                 found_sep = 0;
8115                 while (g_ascii_isspace (*p) || *p == ',') {
8116                         *p++ = 0;
8117                         found_sep = 1;
8118                         continue;
8119                 }
8120                 /* failed */
8121                 if (!found_sep)
8122                         return 1;
8123         }
8124
8125         return 0;
8126 }
8127
8128 /*
8129  * mono_reflection_parse_type:
8130  * @name: type name
8131  *
8132  * Parse a type name as accepted by the GetType () method and output the info
8133  * extracted in the info structure.
8134  * the name param will be mangled, so, make a copy before passing it to this function.
8135  * The fields in info will be valid until the memory pointed to by name is valid.
8136  *
8137  * See also mono_type_get_name () below.
8138  *
8139  * Returns: 0 on parse error.
8140  */
8141 static int
8142 _mono_reflection_parse_type (char *name, char **endptr, gboolean is_recursed,
8143                              MonoTypeNameParse *info)
8144 {
8145         char *start, *p, *w, *last_point, *startn;
8146         int in_modifiers = 0;
8147         int isbyref = 0, rank = 0, isptr = 0;
8148
8149         start = p = w = name;
8150
8151         //FIXME could we just zero the whole struct? memset (&info, 0, sizeof (MonoTypeNameParse))
8152         memset (&info->assembly, 0, sizeof (MonoAssemblyName));
8153         info->name = info->name_space = NULL;
8154         info->nested = NULL;
8155         info->modifiers = NULL;
8156         info->type_arguments = NULL;
8157
8158         /* last_point separates the namespace from the name */
8159         last_point = NULL;
8160         /* Skips spaces */
8161         while (*p == ' ') p++, start++, w++, name++;
8162
8163         while (*p) {
8164                 switch (*p) {
8165                 case '+':
8166                         *p = 0; /* NULL terminate the name */
8167                         startn = p + 1;
8168                         info->nested = g_list_append (info->nested, startn);
8169                         /* we have parsed the nesting namespace + name */
8170                         if (info->name)
8171                                 break;
8172                         if (last_point) {
8173                                 info->name_space = start;
8174                                 *last_point = 0;
8175                                 info->name = last_point + 1;
8176                         } else {
8177                                 info->name_space = (char *)"";
8178                                 info->name = start;
8179                         }
8180                         break;
8181                 case '.':
8182                         last_point = p;
8183                         break;
8184                 case '\\':
8185                         ++p;
8186                         break;
8187                 case '&':
8188                 case '*':
8189                 case '[':
8190                 case ',':
8191                 case ']':
8192                         in_modifiers = 1;
8193                         break;
8194                 default:
8195                         break;
8196                 }
8197                 if (in_modifiers)
8198                         break;
8199                 // *w++ = *p++;
8200                 p++;
8201         }
8202
8203         if (!info->name) {
8204                 if (last_point) {
8205                         info->name_space = start;
8206                         *last_point = 0;
8207                         info->name = last_point + 1;
8208                 } else {
8209                         info->name_space = (char *)"";
8210                         info->name = start;
8211                 }
8212         }
8213         while (*p) {
8214                 switch (*p) {
8215                 case '&':
8216                         if (isbyref) /* only one level allowed by the spec */
8217                                 return 0;
8218                         isbyref = 1;
8219                         isptr = 0;
8220                         info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (0));
8221                         *p++ = 0;
8222                         break;
8223                 case '*':
8224                         if (isbyref) /* pointer to ref not okay */
8225                                 return 0;
8226                         info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-1));
8227                         isptr = 1;
8228                         *p++ = 0;
8229                         break;
8230                 case '[':
8231                         if (isbyref) /* array of ref and generic ref are not okay */
8232                                 return 0;
8233                         //Decide if it's an array of a generic argument list
8234                         *p++ = 0;
8235
8236                         if (!*p) //XXX test
8237                                 return 0;
8238                         if (*p  == ',' || *p == '*' || *p == ']') { //array
8239                                 isptr = 0;
8240                                 rank = 1;
8241                                 while (*p) {
8242                                         if (*p == ']')
8243                                                 break;
8244                                         if (*p == ',')
8245                                                 rank++;
8246                                         else if (*p == '*') /* '*' means unknown lower bound */
8247                                                 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (-2));
8248                                         else
8249                                                 return 0;
8250                                         ++p;
8251                                 }
8252                                 if (*p++ != ']')
8253                                         return 0;
8254                                 info->modifiers = g_list_append (info->modifiers, GUINT_TO_POINTER (rank));
8255                         } else {
8256                                 if (rank || isptr) /* generic args after array spec or ptr*/ //XXX test
8257                                         return 0;
8258                                 isptr = 0;
8259                                 info->type_arguments = g_ptr_array_new ();
8260                                 while (*p) {
8261                                         MonoTypeNameParse *subinfo = g_new0 (MonoTypeNameParse, 1);
8262                                         gboolean fqname = FALSE;
8263
8264                                         g_ptr_array_add (info->type_arguments, subinfo);
8265
8266                                         while (*p == ' ') p++;
8267                                         if (*p == '[') {
8268                                                 p++;
8269                                                 fqname = TRUE;
8270                                         }
8271
8272                                         if (!_mono_reflection_parse_type (p, &p, TRUE, subinfo))
8273                                                 return 0;
8274
8275                                         /*MS is lenient on [] delimited parameters that aren't fqn - and F# uses them.*/
8276                                         if (fqname && (*p != ']')) {
8277                                                 char *aname;
8278
8279                                                 if (*p != ',')
8280                                                         return 0;
8281                                                 *p++ = 0;
8282
8283                                                 aname = p;
8284                                                 while (*p && (*p != ']'))
8285                                                         p++;
8286
8287                                                 if (*p != ']')
8288                                                         return 0;
8289
8290                                                 *p++ = 0;
8291                                                 while (*aname) {
8292                                                         if (g_ascii_isspace (*aname)) {
8293                                                                 ++aname;
8294                                                                 continue;
8295                                                         }
8296                                                         break;
8297                                                 }
8298                                                 if (!*aname ||
8299                                                     !assembly_name_to_aname (&subinfo->assembly, aname))
8300                                                         return 0;
8301                                         } else if (fqname && (*p == ']')) {
8302                                                 *p++ = 0;
8303                                         }
8304                                         if (*p == ']') {
8305                                                 *p++ = 0;
8306                                                 break;
8307                                         } else if (!*p) {
8308                                                 return 0;
8309                                         }
8310                                         *p++ = 0;
8311                                 }
8312                         }
8313                         break;
8314                 case ']':
8315                         if (is_recursed)
8316                                 goto end;
8317                         return 0;
8318                 case ',':
8319                         if (is_recursed)
8320                                 goto end;
8321                         *p++ = 0;
8322                         while (*p) {
8323                                 if (g_ascii_isspace (*p)) {
8324                                         ++p;
8325                                         continue;
8326                                 }
8327                                 break;
8328                         }
8329                         if (!*p)
8330                                 return 0; /* missing assembly name */
8331                         if (!assembly_name_to_aname (&info->assembly, p))
8332                                 return 0;
8333                         break;
8334                 default:
8335                         return 0;
8336                 }
8337                 if (info->assembly.name)
8338                         break;
8339         }
8340         // *w = 0; /* terminate class name */
8341  end:
8342         if (!info->name || !*info->name)
8343                 return 0;
8344         if (endptr)
8345                 *endptr = p;
8346         /* add other consistency checks */
8347         return 1;
8348 }
8349
8350
8351 /**
8352  * mono_identifier_unescape_type_name_chars:
8353  * @identifier: the display name of a mono type
8354  *
8355  * Returns:
8356  *  The name in internal form, that is without escaping backslashes.
8357  *
8358  *  The string is modified in place!
8359  */
8360 char*
8361 mono_identifier_unescape_type_name_chars(char* identifier)
8362 {
8363         char *w, *r;
8364         if (!identifier)
8365                 return NULL;
8366         for (w = r = identifier; *r != 0; r++)
8367         {
8368                 char c = *r;
8369                 if (c == '\\') {
8370                         r++;
8371                         if (*r == 0)
8372                                 break;
8373                         c = *r;
8374                 }
8375                 *w = c;
8376                 w++;
8377         }
8378         if (w != r)
8379                 *w = 0;
8380         return identifier;
8381 }
8382
8383 void
8384 mono_identifier_unescape_info (MonoTypeNameParse* info);
8385
8386 static void
8387 unescape_each_type_argument(void* data, void* user_data)
8388 {
8389         MonoTypeNameParse* info = (MonoTypeNameParse*)data;
8390         mono_identifier_unescape_info (info);
8391 }
8392
8393 static void
8394 unescape_each_nested_name (void* data, void* user_data)
8395 {
8396         char* nested_name = (char*) data;
8397         mono_identifier_unescape_type_name_chars(nested_name);
8398 }
8399
8400 /**
8401  * mono_identifier_unescape_info:
8402  *
8403  * @info: a parsed display form of an (optionally assembly qualified) full type name.
8404  *
8405  * Returns: nothing.
8406  *
8407  * Destructively updates the info by unescaping the identifiers that
8408  * comprise the type namespace, name, nested types (if any) and
8409  * generic type arguments (if any).
8410  *
8411  * The resulting info has the names in internal form.
8412  *
8413  */
8414 void
8415 mono_identifier_unescape_info (MonoTypeNameParse *info)
8416 {
8417         if (!info)
8418                 return;
8419         mono_identifier_unescape_type_name_chars(info->name_space);
8420         mono_identifier_unescape_type_name_chars(info->name);
8421         // but don't escape info->assembly
8422         if (info->type_arguments)
8423                 g_ptr_array_foreach(info->type_arguments, &unescape_each_type_argument, NULL);
8424         if (info->nested)
8425                 g_list_foreach(info->nested, &unescape_each_nested_name, NULL);
8426 }
8427
8428 int
8429 mono_reflection_parse_type (char *name, MonoTypeNameParse *info)
8430 {
8431         int ok = _mono_reflection_parse_type (name, NULL, FALSE, info);
8432         if (ok) {
8433                 mono_identifier_unescape_info (info);
8434         }
8435         return ok;
8436 }
8437
8438 static MonoType*
8439 _mono_reflection_get_type_from_info (MonoTypeNameParse *info, MonoImage *image, gboolean ignorecase, MonoError *error)
8440 {
8441         gboolean type_resolve = FALSE;
8442         MonoType *type;
8443         MonoImage *rootimage = image;
8444
8445         mono_error_init (error);
8446
8447         if (info->assembly.name) {
8448                 MonoAssembly *assembly = mono_assembly_loaded (&info->assembly);
8449                 if (!assembly && image && image->assembly && mono_assembly_names_equal (&info->assembly, &image->assembly->aname))
8450                         /*
8451                          * This could happen in the AOT compiler case when the search hook is not
8452                          * installed.
8453                          */
8454                         assembly = image->assembly;
8455                 if (!assembly) {
8456                         /* then we must load the assembly ourselve - see #60439 */
8457                         assembly = mono_assembly_load (&info->assembly, image->assembly->basedir, NULL);
8458                         if (!assembly)
8459                                 return NULL;
8460                 }
8461                 image = assembly->image;
8462         } else if (!image) {
8463                 image = mono_defaults.corlib;
8464         }
8465
8466         type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
8467         if (type == NULL && !info->assembly.name && image != mono_defaults.corlib) {
8468                 mono_error_cleanup (error);
8469                 image = mono_defaults.corlib;
8470                 type = mono_reflection_get_type_with_rootimage (rootimage, image, info, ignorecase, &type_resolve, error);
8471         }
8472
8473         return type;
8474 }
8475
8476 /**
8477  * mono_reflection_get_type_internal:
8478  *
8479  * Returns: may return NULL on success, sets error on failure.
8480  */
8481 static MonoType*
8482 mono_reflection_get_type_internal (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
8483 {
8484         MonoClass *klass;
8485         GList *mod;
8486         int modval;
8487         gboolean bounded = FALSE;
8488
8489         mono_error_init (error);
8490         if (!image)
8491                 image = mono_defaults.corlib;
8492
8493         if (!rootimage)
8494                 rootimage = mono_defaults.corlib;
8495
8496         if (ignorecase)
8497                 klass = mono_class_from_name_case_checked (image, info->name_space, info->name, error);
8498         else
8499                 klass = mono_class_from_name_checked (image, info->name_space, info->name, error);
8500
8501         if (!klass)
8502                 return NULL;
8503
8504         for (mod = info->nested; mod; mod = mod->next) {
8505                 gpointer iter = NULL;
8506                 MonoClass *parent;
8507
8508                 parent = klass;
8509                 mono_class_init (parent);
8510
8511                 while ((klass = mono_class_get_nested_types (parent, &iter))) {
8512                         char *lastp;
8513                         char *nested_name, *nested_nspace;
8514                         gboolean match = TRUE;
8515
8516                         lastp = strrchr ((const char *)mod->data, '.');
8517                         if (lastp) {
8518                                 /* Nested classes can have namespaces */
8519                                 int nspace_len;
8520
8521                                 nested_name = g_strdup (lastp + 1);
8522                                 nspace_len = lastp - (char*)mod->data;
8523                                 nested_nspace = (char *)g_malloc (nspace_len + 1);
8524                                 memcpy (nested_nspace, mod->data, nspace_len);
8525                                 nested_nspace [nspace_len] = '\0';
8526
8527                         } else {
8528                                 nested_name = (char *)mod->data;
8529                                 nested_nspace = NULL;
8530                         }
8531
8532                         if (nested_nspace) {
8533                                 if (ignorecase) {
8534                                         if (!(klass->name_space && mono_utf8_strcasecmp (klass->name_space, nested_nspace) == 0))
8535                                                 match = FALSE;
8536                                 } else {
8537                                         if (!(klass->name_space && strcmp (klass->name_space, nested_nspace) == 0))
8538                                                 match = FALSE;
8539                                 }
8540                         }
8541                         if (match) {
8542                                 if (ignorecase) {
8543                                         if (mono_utf8_strcasecmp (klass->name, nested_name) != 0)
8544                                                 match = FALSE;
8545                                 } else {
8546                                         if (strcmp (klass->name, nested_name) != 0)
8547                                                 match = FALSE;
8548                                 }
8549                         }
8550                         if (lastp) {
8551                                 g_free (nested_name);
8552                                 g_free (nested_nspace);
8553                         }
8554                         if (match)
8555                                 break;
8556                 }
8557
8558                 if (!klass)
8559                         break;
8560         }
8561         if (!klass)
8562                 return NULL;
8563
8564         if (info->type_arguments) {
8565                 MonoType **type_args = g_new0 (MonoType *, info->type_arguments->len);
8566                 MonoReflectionType *the_type;
8567                 MonoType *instance;
8568                 int i;
8569
8570                 for (i = 0; i < info->type_arguments->len; i++) {
8571                         MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
8572
8573                         type_args [i] = _mono_reflection_get_type_from_info (subinfo, rootimage, ignorecase, error);
8574                         if (!type_args [i]) {
8575                                 g_free (type_args);
8576                                 return NULL;
8577                         }
8578                 }
8579
8580                 the_type = mono_type_get_object_checked (mono_domain_get (), &klass->byval_arg, error);
8581                 if (!the_type)
8582                         return NULL;
8583
8584                 instance = mono_reflection_bind_generic_parameters (
8585                         the_type, info->type_arguments->len, type_args, error);
8586
8587                 g_free (type_args);
8588                 if (!instance)
8589                         return NULL;
8590
8591                 klass = mono_class_from_mono_type (instance);
8592         }
8593
8594         for (mod = info->modifiers; mod; mod = mod->next) {
8595                 modval = GPOINTER_TO_UINT (mod->data);
8596                 if (!modval) { /* byref: must be last modifier */
8597                         return &klass->this_arg;
8598                 } else if (modval == -1) {
8599                         klass = mono_ptr_class_get (&klass->byval_arg);
8600                 } else if (modval == -2) {
8601                         bounded = TRUE;
8602                 } else { /* array rank */
8603                         klass = mono_bounded_array_class_get (klass, modval, bounded);
8604                 }
8605         }
8606
8607         return &klass->byval_arg;
8608 }
8609
8610 /*
8611  * mono_reflection_get_type:
8612  * @image: a metadata context
8613  * @info: type description structure
8614  * @ignorecase: flag for case-insensitive string compares
8615  * @type_resolve: whenever type resolve was already tried
8616  *
8617  * Build a MonoType from the type description in @info.
8618  *
8619  */
8620
8621 MonoType*
8622 mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve) {
8623         MonoError error;
8624         MonoType *result = mono_reflection_get_type_with_rootimage (image, image, info, ignorecase, type_resolve, &error);
8625         mono_error_cleanup (&error);
8626         return result;
8627 }
8628
8629 /**
8630  * mono_reflection_get_type_checked:
8631  * @image: a metadata context
8632  * @info: type description structure
8633  * @ignorecase: flag for case-insensitive string compares
8634  * @type_resolve: whenever type resolve was already tried
8635  * @error: set on error.
8636  *
8637  * Build a MonoType from the type description in @info. On failure returns NULL and sets @error.
8638  *
8639  */
8640 MonoType*
8641 mono_reflection_get_type_checked (MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error) {
8642         mono_error_init (error);
8643         return mono_reflection_get_type_with_rootimage (image, image, info, ignorecase, type_resolve, error);
8644 }
8645
8646
8647 static MonoType*
8648 mono_reflection_get_type_internal_dynamic (MonoImage *rootimage, MonoAssembly *assembly, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
8649 {
8650         MonoReflectionAssemblyBuilder *abuilder;
8651         MonoType *type;
8652         int i;
8653
8654         mono_error_init (error);
8655         g_assert (assembly_is_dynamic (assembly));
8656         abuilder = (MonoReflectionAssemblyBuilder*)mono_assembly_get_object_checked (((MonoDynamicAssembly*)assembly)->domain, assembly, error);
8657         if (!abuilder)
8658                 return NULL;
8659
8660         /* Enumerate all modules */
8661
8662         type = NULL;
8663         if (abuilder->modules) {
8664                 for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
8665                         MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
8666                         type = mono_reflection_get_type_internal (rootimage, &mb->dynamic_image->image, info, ignorecase, error);
8667                         if (type)
8668                                 break;
8669                         if (!mono_error_ok (error))
8670                                 return NULL;
8671                 }
8672         }
8673
8674         if (!type && abuilder->loaded_modules) {
8675                 for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
8676                         MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
8677                         type = mono_reflection_get_type_internal (rootimage, mod->image, info, ignorecase, error);
8678                         if (type)
8679                                 break;
8680                         if (!mono_error_ok (error))
8681                                 return NULL;
8682                 }
8683         }
8684
8685         return type;
8686 }
8687
8688 MonoType*
8689 mono_reflection_get_type_with_rootimage (MonoImage *rootimage, MonoImage* image, MonoTypeNameParse *info, gboolean ignorecase, gboolean *type_resolve, MonoError *error)
8690 {
8691         MonoType *type;
8692         MonoReflectionAssembly *assembly;
8693         GString *fullName;
8694         GList *mod;
8695
8696         mono_error_init (error);
8697
8698         if (image && image_is_dynamic (image))
8699                 type = mono_reflection_get_type_internal_dynamic (rootimage, image->assembly, info, ignorecase, error);
8700         else {
8701                 type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase, error);
8702         }
8703         return_val_if_nok (error, NULL);
8704
8705         if (type)
8706                 return type;
8707         if (!mono_domain_has_type_resolve (mono_domain_get ()))
8708                 return NULL;
8709
8710         if (type_resolve) {
8711                 if (*type_resolve)
8712                         return NULL;
8713                 else
8714                         *type_resolve = TRUE;
8715         }
8716
8717         /* Reconstruct the type name */
8718         fullName = g_string_new ("");
8719         if (info->name_space && (info->name_space [0] != '\0'))
8720                 g_string_printf (fullName, "%s.%s", info->name_space, info->name);
8721         else
8722                 g_string_printf (fullName, "%s", info->name);
8723         for (mod = info->nested; mod; mod = mod->next)
8724                 g_string_append_printf (fullName, "+%s", (char*)mod->data);
8725
8726         assembly = mono_domain_try_type_resolve_checked ( mono_domain_get (), fullName->str, NULL, error);
8727         if (!is_ok (error)) {
8728                 g_string_free (fullName, TRUE);
8729                 return NULL;
8730         }
8731
8732         if (assembly) {
8733                 if (assembly_is_dynamic (assembly->assembly))
8734                         type = mono_reflection_get_type_internal_dynamic (rootimage, assembly->assembly,
8735                                                                           info, ignorecase, error);
8736                 else
8737                         type = mono_reflection_get_type_internal (rootimage, assembly->assembly->image,
8738                                                                   info, ignorecase, error);
8739         }
8740         g_string_free (fullName, TRUE);
8741         return_val_if_nok (error, NULL);
8742         return type;
8743 }
8744
8745 void
8746 mono_reflection_free_type_info (MonoTypeNameParse *info)
8747 {
8748         g_list_free (info->modifiers);
8749         g_list_free (info->nested);
8750
8751         if (info->type_arguments) {
8752                 int i;
8753
8754                 for (i = 0; i < info->type_arguments->len; i++) {
8755                         MonoTypeNameParse *subinfo = (MonoTypeNameParse *)g_ptr_array_index (info->type_arguments, i);
8756
8757                         mono_reflection_free_type_info (subinfo);
8758                         /*We free the subinfo since it is allocated by _mono_reflection_parse_type*/
8759                         g_free (subinfo);
8760                 }
8761
8762                 g_ptr_array_free (info->type_arguments, TRUE);
8763         }
8764 }
8765
8766 /*
8767  * mono_reflection_type_from_name:
8768  * @name: type name.
8769  * @image: a metadata context (can be NULL).
8770  *
8771  * Retrieves a MonoType from its @name. If the name is not fully qualified,
8772  * it defaults to get the type from @image or, if @image is NULL or loading
8773  * from it fails, uses corlib.
8774  *
8775  */
8776 MonoType*
8777 mono_reflection_type_from_name (char *name, MonoImage *image)
8778 {
8779         MonoError error;
8780         MonoType  *result = mono_reflection_type_from_name_checked (name, image, &error);
8781         mono_error_cleanup (&error);
8782         return result;
8783 }
8784
8785 /**
8786  * mono_reflection_type_from_name_checked:
8787  * @name: type name.
8788  * @image: a metadata context (can be NULL).
8789  * @error: set on errror.
8790  *
8791  * Retrieves a MonoType from its @name. If the name is not fully qualified,
8792  * it defaults to get the type from @image or, if @image is NULL or loading
8793  * from it fails, uses corlib.  On failure returns NULL and sets @error.
8794  *
8795  */
8796 MonoType*
8797 mono_reflection_type_from_name_checked (char *name, MonoImage *image, MonoError *error)
8798 {
8799         MonoType *type = NULL;
8800         MonoTypeNameParse info;
8801         char *tmp;
8802
8803         mono_error_init (error);
8804         /* Make a copy since parse_type modifies its argument */
8805         tmp = g_strdup (name);
8806
8807         /*g_print ("requested type %s\n", str);*/
8808         if (mono_reflection_parse_type (tmp, &info)) {
8809                 type = _mono_reflection_get_type_from_info (&info, image, FALSE, error);
8810                 if (!is_ok (error)) {
8811                         g_free (tmp);
8812                         mono_reflection_free_type_info (&info);
8813                         return NULL;
8814                 }
8815         }
8816
8817         g_free (tmp);
8818         mono_reflection_free_type_info (&info);
8819         return type;
8820 }
8821
8822 /*
8823  * mono_reflection_get_token:
8824  *
8825  *   Return the metadata token of OBJ which should be an object
8826  * representing a metadata element.
8827  */
8828 guint32
8829 mono_reflection_get_token (MonoObject *obj)
8830 {
8831         MonoError error;
8832         guint32 result = mono_reflection_get_token_checked (obj, &error);
8833         mono_error_assert_ok (&error);
8834         return result;
8835 }
8836
8837 /**
8838  * mono_reflection_get_token_checked:
8839  * @obj: the object
8840  * @error: set on error
8841  *
8842  *   Return the metadata token of @obj which should be an object
8843  * representing a metadata element.  On failure sets @error.
8844  */
8845 guint32
8846 mono_reflection_get_token_checked (MonoObject *obj, MonoError *error)
8847 {
8848         MonoClass *klass;
8849         guint32 token = 0;
8850
8851         mono_error_init (error);
8852
8853         klass = obj->vtable->klass;
8854
8855         if (strcmp (klass->name, "MethodBuilder") == 0) {
8856                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj;
8857
8858                 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
8859         } else if (strcmp (klass->name, "ConstructorBuilder") == 0) {
8860                 MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj;
8861
8862                 token = mb->table_idx | MONO_TOKEN_METHOD_DEF;
8863         } else if (strcmp (klass->name, "FieldBuilder") == 0) {
8864                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj;
8865
8866                 token = fb->table_idx | MONO_TOKEN_FIELD_DEF;
8867         } else if (strcmp (klass->name, "TypeBuilder") == 0) {
8868                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj;
8869                 token = tb->table_idx | MONO_TOKEN_TYPE_DEF;
8870         } else if (strcmp (klass->name, "MonoType") == 0) {
8871                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error);
8872                 return_val_if_nok (error, 0);
8873                 MonoClass *mc = mono_class_from_mono_type (type);
8874                 if (!mono_class_init (mc)) {
8875                         mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (mc));
8876                         return 0;
8877                 }
8878
8879                 token = mc->type_token;
8880         } else if (strcmp (klass->name, "MonoCMethod") == 0 ||
8881                    strcmp (klass->name, "MonoMethod") == 0 ||
8882                    strcmp (klass->name, "MonoGenericMethod") == 0 ||
8883                    strcmp (klass->name, "MonoGenericCMethod") == 0) {
8884                 MonoReflectionMethod *m = (MonoReflectionMethod *)obj;
8885                 if (m->method->is_inflated) {
8886                         MonoMethodInflated *inflated = (MonoMethodInflated *) m->method;
8887                         return inflated->declaring->token;
8888                 } else {
8889                         token = m->method->token;
8890                 }
8891         } else if (strcmp (klass->name, "MonoField") == 0) {
8892                 MonoReflectionField *f = (MonoReflectionField*)obj;
8893
8894                 if (is_field_on_inst (f->field)) {
8895                         MonoDynamicGenericClass *dgclass = (MonoDynamicGenericClass*)f->field->parent->generic_class;
8896
8897                         if (f->field >= dgclass->fields && f->field < dgclass->fields + dgclass->count_fields) {
8898                                 int field_index = f->field - dgclass->fields;
8899                                 MonoObject *obj;
8900
8901                                 g_assert (field_index >= 0 && field_index < dgclass->count_fields);
8902                                 obj = dgclass->field_objects [field_index];
8903                                 return mono_reflection_get_token_checked (obj, error);
8904                         }
8905                 }
8906                 token = mono_class_get_field_token (f->field);
8907         } else if (strcmp (klass->name, "MonoProperty") == 0) {
8908                 MonoReflectionProperty *p = (MonoReflectionProperty*)obj;
8909
8910                 token = mono_class_get_property_token (p->property);
8911         } else if (strcmp (klass->name, "MonoEvent") == 0) {
8912                 MonoReflectionMonoEvent *p = (MonoReflectionMonoEvent*)obj;
8913
8914                 token = mono_class_get_event_token (p->event);
8915         } else if (strcmp (klass->name, "ParameterInfo") == 0 || strcmp (klass->name, "MonoParameterInfo") == 0) {
8916                 MonoReflectionParameter *p = (MonoReflectionParameter*)obj;
8917                 MonoClass *member_class = mono_object_class (p->MemberImpl);
8918                 g_assert (mono_class_is_reflection_method_or_constructor (member_class));
8919
8920                 token = mono_method_get_param_token (((MonoReflectionMethod*)p->MemberImpl)->method, p->PositionImpl);
8921         } else if (strcmp (klass->name, "Module") == 0 || strcmp (klass->name, "MonoModule") == 0) {
8922                 MonoReflectionModule *m = (MonoReflectionModule*)obj;
8923
8924                 token = m->token;
8925         } else if (strcmp (klass->name, "Assembly") == 0 || strcmp (klass->name, "MonoAssembly") == 0) {
8926                 token = mono_metadata_make_token (MONO_TABLE_ASSEMBLY, 1);
8927         } else {
8928                 mono_error_set_not_implemented (error, "MetadataToken is not supported for type '%s.%s'",
8929                                                 klass->name_space, klass->name);
8930                 return 0;
8931         }
8932
8933         return token;
8934 }
8935
8936 static MonoClass*
8937 load_cattr_enum_type (MonoImage *image, const char *p, const char **end, MonoError *error)
8938 {
8939         char *n;
8940         MonoType *t;
8941         int slen = mono_metadata_decode_value (p, &p);
8942
8943         mono_error_init (error);
8944
8945         n = (char *)g_memdup (p, slen + 1);
8946         n [slen] = 0;
8947         t = mono_reflection_type_from_name_checked (n, image, error);
8948         if (!t) {
8949                 char *msg = g_strdup (mono_error_get_message (error));
8950                 mono_error_cleanup (error);
8951                 /* We don't free n, it's consumed by mono_error */
8952                 mono_error_set_type_load_name (error, n, NULL, "Could not load enum type %s while decoding custom attribute: %s", n, msg);
8953                 g_free (msg);
8954                 return NULL;
8955         }
8956         g_free (n);
8957         p += slen;
8958         *end = p;
8959         return mono_class_from_mono_type (t);
8960 }
8961
8962 static void*
8963 load_cattr_value (MonoImage *image, MonoType *t, const char *p, const char **end, MonoError *error)
8964 {
8965         int slen, type = t->type;
8966         MonoClass *tklass = t->data.klass;
8967
8968         mono_error_init (error);
8969
8970 handle_enum:
8971         switch (type) {
8972         case MONO_TYPE_U1:
8973         case MONO_TYPE_I1:
8974         case MONO_TYPE_BOOLEAN: {
8975                 MonoBoolean *bval = (MonoBoolean *)g_malloc (sizeof (MonoBoolean));
8976                 *bval = *p;
8977                 *end = p + 1;
8978                 return bval;
8979         }
8980         case MONO_TYPE_CHAR:
8981         case MONO_TYPE_U2:
8982         case MONO_TYPE_I2: {
8983                 guint16 *val = (guint16 *)g_malloc (sizeof (guint16));
8984                 *val = read16 (p);
8985                 *end = p + 2;
8986                 return val;
8987         }
8988 #if SIZEOF_VOID_P == 4
8989         case MONO_TYPE_U:
8990         case MONO_TYPE_I:
8991 #endif
8992         case MONO_TYPE_R4:
8993         case MONO_TYPE_U4:
8994         case MONO_TYPE_I4: {
8995                 guint32 *val = (guint32 *)g_malloc (sizeof (guint32));
8996                 *val = read32 (p);
8997                 *end = p + 4;
8998                 return val;
8999         }
9000 #if SIZEOF_VOID_P == 8
9001         case MONO_TYPE_U: /* error out instead? this should probably not happen */
9002         case MONO_TYPE_I:
9003 #endif
9004         case MONO_TYPE_U8:
9005         case MONO_TYPE_I8: {
9006                 guint64 *val = (guint64 *)g_malloc (sizeof (guint64));
9007                 *val = read64 (p);
9008                 *end = p + 8;
9009                 return val;
9010         }
9011         case MONO_TYPE_R8: {
9012                 double *val = (double *)g_malloc (sizeof (double));
9013                 readr8 (p, val);
9014                 *end = p + 8;
9015                 return val;
9016         }
9017         case MONO_TYPE_VALUETYPE:
9018                 if (t->data.klass->enumtype) {
9019                         type = mono_class_enum_basetype (t->data.klass)->type;
9020                         goto handle_enum;
9021                 } else {
9022                         MonoClass *k =  t->data.klass;
9023
9024                         if (mono_is_corlib_image (k->image) && strcmp (k->name_space, "System") == 0 && strcmp (k->name, "DateTime") == 0){
9025                                 guint64 *val = (guint64 *)g_malloc (sizeof (guint64));
9026                                 *val = read64 (p);
9027                                 *end = p + 8;
9028                                 return val;
9029                         }
9030                 }
9031                 g_error ("generic valutype %s not handled in custom attr value decoding", t->data.klass->name);
9032                 break;
9033
9034         case MONO_TYPE_STRING:
9035                 if (*p == (char)0xFF) {
9036                         *end = p + 1;
9037                         return NULL;
9038                 }
9039                 slen = mono_metadata_decode_value (p, &p);
9040                 *end = p + slen;
9041                 return mono_string_new_len (mono_domain_get (), p, slen);
9042         case MONO_TYPE_CLASS: {
9043                 MonoReflectionType *rt;
9044                 char *n;
9045                 MonoType *t;
9046                 if (*p == (char)0xFF) {
9047                         *end = p + 1;
9048                         return NULL;
9049                 }
9050 handle_type:
9051                 slen = mono_metadata_decode_value (p, &p);
9052                 n = (char *)g_memdup (p, slen + 1);
9053                 n [slen] = 0;
9054                 t = mono_reflection_type_from_name_checked (n, image, error);
9055                 if (!t) {
9056                         char *msg = g_strdup (mono_error_get_message (error));
9057                         mono_error_cleanup (error);
9058                         /* We don't free n, it's consumed by mono_error */
9059                         mono_error_set_type_load_name (error, n, NULL, "Could not load type %s while decoding custom attribute: %msg", n, msg);
9060                         g_free (msg);
9061                         return NULL;
9062                 }
9063                 g_free (n);
9064                 *end = p + slen;
9065
9066                 rt = mono_type_get_object_checked (mono_domain_get (), t, error);
9067                 if (!mono_error_ok (error))
9068                         return NULL;
9069
9070                 return rt;
9071         }
9072         case MONO_TYPE_OBJECT: {
9073                 char subt = *p++;
9074                 MonoObject *obj;
9075                 MonoClass *subc = NULL;
9076                 void *val;
9077
9078                 if (subt == 0x50) {
9079                         goto handle_type;
9080                 } else if (subt == 0x0E) {
9081                         type = MONO_TYPE_STRING;
9082                         goto handle_enum;
9083                 } else if (subt == 0x1D) {
9084                         MonoType simple_type = {{0}};
9085                         int etype = *p;
9086                         p ++;
9087
9088                         type = MONO_TYPE_SZARRAY;
9089                         if (etype == 0x50) {
9090                                 tklass = mono_defaults.systemtype_class;
9091                         } else if (etype == 0x55) {
9092                                 tklass = load_cattr_enum_type (image, p, &p, error);
9093                                 if (!mono_error_ok (error))
9094                                         return NULL;
9095                         } else {
9096                                 if (etype == 0x51)
9097                                         /* See Partition II, Appendix B3 */
9098                                         etype = MONO_TYPE_OBJECT;
9099                                 simple_type.type = (MonoTypeEnum)etype;
9100                                 tklass = mono_class_from_mono_type (&simple_type);
9101                         }
9102                         goto handle_enum;
9103                 } else if (subt == 0x55) {
9104                         char *n;
9105                         MonoType *t;
9106                         slen = mono_metadata_decode_value (p, &p);
9107                         n = (char *)g_memdup (p, slen + 1);
9108                         n [slen] = 0;
9109                         t = mono_reflection_type_from_name_checked (n, image, error);
9110                         if (!t) {
9111                                 char *msg = g_strdup (mono_error_get_message (error));
9112                                 mono_error_cleanup (error);
9113                                 /* We don't free n, it's consumed by mono_error */
9114                                 mono_error_set_type_load_name (error, n, NULL, "Could not load type %s while decoding custom attribute: %s", n, msg);
9115                                 g_free (msg);
9116                                 return NULL;
9117                         }
9118                         g_free (n);
9119                         p += slen;
9120                         subc = mono_class_from_mono_type (t);
9121                 } else if (subt >= MONO_TYPE_BOOLEAN && subt <= MONO_TYPE_R8) {
9122                         MonoType simple_type = {{0}};
9123                         simple_type.type = (MonoTypeEnum)subt;
9124                         subc = mono_class_from_mono_type (&simple_type);
9125                 } else {
9126                         g_error ("Unknown type 0x%02x for object type encoding in custom attr", subt);
9127                 }
9128                 val = load_cattr_value (image, &subc->byval_arg, p, end, error);
9129                 obj = NULL;
9130                 if (mono_error_ok (error)) {
9131                         obj = mono_object_new_checked (mono_domain_get (), subc, error);
9132                         g_assert (!subc->has_references);
9133                         if (mono_error_ok (error))
9134                                 mono_gc_memmove_atomic ((char*)obj + sizeof (MonoObject), val, mono_class_value_size (subc, NULL));
9135                 }
9136
9137                 g_free (val);
9138                 return obj;
9139         }
9140         case MONO_TYPE_SZARRAY: {
9141                 MonoArray *arr;
9142                 guint32 i, alen, basetype;
9143                 alen = read32 (p);
9144                 p += 4;
9145                 if (alen == 0xffffffff) {
9146                         *end = p;
9147                         return NULL;
9148                 }
9149                 arr = mono_array_new (mono_domain_get(), tklass, alen);
9150                 basetype = tklass->byval_arg.type;
9151                 if (basetype == MONO_TYPE_VALUETYPE && tklass->enumtype)
9152                         basetype = mono_class_enum_basetype (tklass)->type;
9153                 switch (basetype)
9154                 {
9155                         case MONO_TYPE_U1:
9156                         case MONO_TYPE_I1:
9157                         case MONO_TYPE_BOOLEAN:
9158                                 for (i = 0; i < alen; i++) {
9159                                         MonoBoolean val = *p++;
9160                                         mono_array_set (arr, MonoBoolean, i, val);
9161                                 }
9162                                 break;
9163                         case MONO_TYPE_CHAR:
9164                         case MONO_TYPE_U2:
9165                         case MONO_TYPE_I2:
9166                                 for (i = 0; i < alen; i++) {
9167                                         guint16 val = read16 (p);
9168                                         mono_array_set (arr, guint16, i, val);
9169                                         p += 2;
9170                                 }
9171                                 break;
9172                         case MONO_TYPE_R4:
9173                         case MONO_TYPE_U4:
9174                         case MONO_TYPE_I4:
9175                                 for (i = 0; i < alen; i++) {
9176                                         guint32 val = read32 (p);
9177                                         mono_array_set (arr, guint32, i, val);
9178                                         p += 4;
9179                                 }
9180                                 break;
9181                         case MONO_TYPE_R8:
9182                                 for (i = 0; i < alen; i++) {
9183                                         double val;
9184                                         readr8 (p, &val);
9185                                         mono_array_set (arr, double, i, val);
9186                                         p += 8;
9187                                 }
9188                                 break;
9189                         case MONO_TYPE_U8:
9190                         case MONO_TYPE_I8:
9191                                 for (i = 0; i < alen; i++) {
9192                                         guint64 val = read64 (p);
9193                                         mono_array_set (arr, guint64, i, val);
9194                                         p += 8;
9195                                 }
9196                                 break;
9197                         case MONO_TYPE_CLASS:
9198                         case MONO_TYPE_OBJECT:
9199                         case MONO_TYPE_STRING:
9200                         case MONO_TYPE_SZARRAY:
9201                                 for (i = 0; i < alen; i++) {
9202                                         MonoObject *item = (MonoObject *)load_cattr_value (image, &tklass->byval_arg, p, &p, error);
9203                                         if (!mono_error_ok (error))
9204                                                 return NULL;
9205                                         mono_array_setref (arr, i, item);
9206                                 }
9207                                 break;
9208                         default:
9209                                 g_error ("Type 0x%02x not handled in custom attr array decoding", basetype);
9210                 }
9211                 *end=p;
9212                 return arr;
9213         }
9214         default:
9215                 g_error ("Type 0x%02x not handled in custom attr value decoding", type);
9216         }
9217         return NULL;
9218 }
9219
9220 static MonoObject*
9221 load_cattr_value_boxed (MonoDomain *domain, MonoImage *image, MonoType *t, const char* p, const char** end, MonoError *error)
9222 {
9223         mono_error_init (error);
9224
9225         gboolean is_ref = type_is_reference (t);
9226
9227         void *val = load_cattr_value (image, t, p, end, error);
9228         if (!is_ok (error)) {
9229                 if (is_ref)
9230                         g_free (val);
9231                 return NULL;
9232         }
9233
9234         if (is_ref)
9235                 return (MonoObject*)val;
9236
9237         MonoObject *boxed = mono_value_box_checked (domain, mono_class_from_mono_type (t), val, error);
9238         g_free (val);
9239         return boxed;
9240 }
9241
9242 static MonoObject*
9243 create_cattr_typed_arg (MonoType *t, MonoObject *val, MonoError *error)
9244 {
9245         static MonoMethod *ctor;
9246         MonoObject *retval;
9247         void *params [2], *unboxed;
9248
9249         mono_error_init (error);
9250
9251         if (!ctor)
9252                 ctor = mono_class_get_method_from_name (mono_class_get_custom_attribute_typed_argument_class (), ".ctor", 2);
9253
9254         params [0] = mono_type_get_object_checked (mono_domain_get (), t, error);
9255         return_val_if_nok (error, NULL);
9256
9257         params [1] = val;
9258         retval = mono_object_new_checked (mono_domain_get (), mono_class_get_custom_attribute_typed_argument_class (), error);
9259         return_val_if_nok (error, NULL);
9260         unboxed = mono_object_unbox (retval);
9261
9262         mono_runtime_invoke_checked (ctor, unboxed, params, error);
9263         return_val_if_nok (error, NULL);
9264
9265         return retval;
9266 }
9267
9268 static MonoObject*
9269 create_cattr_named_arg (void *minfo, MonoObject *typedarg, MonoError *error)
9270 {
9271         static MonoMethod *ctor;
9272         MonoObject *retval;
9273         void *unboxed, *params [2];
9274
9275         mono_error_init (error);
9276
9277         if (!ctor)
9278                 ctor = mono_class_get_method_from_name (mono_class_get_custom_attribute_named_argument_class (), ".ctor", 2);
9279
9280         params [0] = minfo;
9281         params [1] = typedarg;
9282         retval = mono_object_new_checked (mono_domain_get (), mono_class_get_custom_attribute_named_argument_class (), error);
9283         return_val_if_nok (error, NULL);
9284
9285         unboxed = mono_object_unbox (retval);
9286
9287         mono_runtime_invoke_checked (ctor, unboxed, params, error);
9288         return_val_if_nok (error, NULL);
9289
9290         return retval;
9291 }
9292
9293 static gboolean
9294 type_is_reference (MonoType *type)
9295 {
9296         switch (type->type) {
9297         case MONO_TYPE_BOOLEAN:
9298         case MONO_TYPE_CHAR:
9299         case MONO_TYPE_U:
9300         case MONO_TYPE_I:
9301         case MONO_TYPE_U1:
9302         case MONO_TYPE_I1:
9303         case MONO_TYPE_U2:
9304         case MONO_TYPE_I2:
9305         case MONO_TYPE_U4:
9306         case MONO_TYPE_I4:
9307         case MONO_TYPE_U8:
9308         case MONO_TYPE_I8:
9309         case MONO_TYPE_R8:
9310         case MONO_TYPE_R4:
9311         case MONO_TYPE_VALUETYPE:
9312                 return FALSE;
9313         default:
9314                 return TRUE;
9315         }
9316 }
9317
9318 static void
9319 free_param_data (MonoMethodSignature *sig, void **params) {
9320         int i;
9321         for (i = 0; i < sig->param_count; ++i) {
9322                 if (!type_is_reference (sig->params [i]))
9323                         g_free (params [i]);
9324         }
9325 }
9326
9327 /*
9328  * Find the field index in the metadata FieldDef table.
9329  */
9330 static guint32
9331 find_field_index (MonoClass *klass, MonoClassField *field) {
9332         int i;
9333
9334         for (i = 0; i < klass->field.count; ++i) {
9335                 if (field == &klass->fields [i])
9336                         return klass->field.first + 1 + i;
9337         }
9338         return 0;
9339 }
9340
9341 /*
9342  * Find the property index in the metadata Property table.
9343  */
9344 static guint32
9345 find_property_index (MonoClass *klass, MonoProperty *property) {
9346         int i;
9347
9348         for (i = 0; i < klass->ext->property.count; ++i) {
9349                 if (property == &klass->ext->properties [i])
9350                         return klass->ext->property.first + 1 + i;
9351         }
9352         return 0;
9353 }
9354
9355 /*
9356  * Find the event index in the metadata Event table.
9357  */
9358 static guint32
9359 find_event_index (MonoClass *klass, MonoEvent *event) {
9360         int i;
9361
9362         for (i = 0; i < klass->ext->event.count; ++i) {
9363                 if (event == &klass->ext->events [i])
9364                         return klass->ext->event.first + 1 + i;
9365         }
9366         return 0;
9367 }
9368
9369 static MonoObject*
9370 create_custom_attr (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoError *error)
9371 {
9372         const char *p = (const char*)data;
9373         const char *named;
9374         guint32 i, j, num_named;
9375         MonoObject *attr;
9376         void *params_buf [32];
9377         void **params = NULL;
9378         MonoMethodSignature *sig;
9379         MonoObject *exc = NULL;
9380
9381         mono_error_init (error);
9382
9383         mono_class_init (method->klass);
9384
9385         if (!mono_verifier_verify_cattr_content (image, method, data, len, NULL)) {
9386                 mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
9387                 return NULL;
9388         }
9389
9390         if (len == 0) {
9391                 attr = mono_object_new_checked (mono_domain_get (), method->klass, error);
9392                 if (!mono_error_ok (error)) return NULL;
9393
9394                 mono_runtime_invoke_checked (method, attr, NULL, error);
9395                 if (!mono_error_ok (error))
9396                         return NULL;
9397
9398                 return attr;
9399         }
9400
9401         if (len < 2 || read16 (p) != 0x0001) /* Prolog */
9402                 return NULL;
9403
9404         /*g_print ("got attr %s\n", method->klass->name);*/
9405
9406         sig = mono_method_signature (method);
9407         if (sig->param_count < 32) {
9408                 params = params_buf;
9409                 memset (params, 0, sizeof (void*) * sig->param_count);
9410         } else {
9411                 /* Allocate using GC so it gets GC tracking */
9412                 params = (void **)mono_gc_alloc_fixed (sig->param_count * sizeof (void*), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_REFLECTION, "custom attribute parameters");
9413         }
9414
9415         /* skip prolog */
9416         p += 2;
9417         for (i = 0; i < mono_method_signature (method)->param_count; ++i) {
9418                 params [i] = load_cattr_value (image, mono_method_signature (method)->params [i], p, &p, error);
9419                 if (!mono_error_ok (error))
9420                         goto fail;
9421         }
9422
9423         named = p;
9424         attr = mono_object_new_checked (mono_domain_get (), method->klass, error);
9425         if (!mono_error_ok (error)) goto fail;
9426
9427         mono_runtime_try_invoke (method, attr, params, &exc, error);
9428         if (!mono_error_ok (error))
9429                 goto fail;
9430         if (exc)
9431                 goto fail;
9432
9433         num_named = read16 (named);
9434         named += 2;
9435         for (j = 0; j < num_named; j++) {
9436                 gint name_len;
9437                 char *name, named_type, data_type;
9438                 named_type = *named++;
9439                 data_type = *named++; /* type of data */
9440                 if (data_type == MONO_TYPE_SZARRAY)
9441                         data_type = *named++;
9442                 if (data_type == MONO_TYPE_ENUM) {
9443                         gint type_len;
9444                         char *type_name;
9445                         type_len = mono_metadata_decode_blob_size (named, &named);
9446                         type_name = (char *)g_malloc (type_len + 1);
9447                         memcpy (type_name, named, type_len);
9448                         type_name [type_len] = 0;
9449                         named += type_len;
9450                         /* FIXME: lookup the type and check type consistency */
9451                         g_free (type_name);
9452                 }
9453                 name_len = mono_metadata_decode_blob_size (named, &named);
9454                 name = (char *)g_malloc (name_len + 1);
9455                 memcpy (name, named, name_len);
9456                 name [name_len] = 0;
9457                 named += name_len;
9458                 if (named_type == 0x53) {
9459                         MonoClassField *field;
9460                         void *val;
9461
9462                         /* how this fail is a blackbox */
9463                         field = mono_class_get_field_from_name (mono_object_class (attr), name);
9464                         if (!field) {
9465                                 mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Could not find a field with name %s", name);
9466                                 g_free (name);
9467                                 goto fail;
9468                         }
9469
9470                         val = load_cattr_value (image, field->type, named, &named, error);
9471                         if (!mono_error_ok (error)) {
9472                                 g_free (name);
9473                                 if (!type_is_reference (field->type))
9474                                         g_free (val);
9475                                 goto fail;
9476                         }
9477
9478                         mono_field_set_value (attr, field, val);
9479                         if (!type_is_reference (field->type))
9480                                 g_free (val);
9481                 } else if (named_type == 0x54) {
9482                         MonoProperty *prop;
9483                         void *pparams [1];
9484                         MonoType *prop_type;
9485
9486                         prop = mono_class_get_property_from_name (mono_object_class (attr), name);
9487
9488                         if (!prop) {
9489                                 mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Could not find a property with name %s", name);
9490                                 g_free (name);
9491                                 goto fail;
9492                         }
9493
9494                         if (!prop->set) {
9495                                 mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Could not find the setter for %s", name);
9496                                 g_free (name);
9497                                 goto fail;
9498                         }
9499
9500                         /* can we have more that 1 arg in a custom attr named property? */
9501                         prop_type = prop->get? mono_method_signature (prop->get)->ret :
9502                              mono_method_signature (prop->set)->params [mono_method_signature (prop->set)->param_count - 1];
9503
9504                         pparams [0] = load_cattr_value (image, prop_type, named, &named, error);
9505                         if (!mono_error_ok (error)) {
9506                                 g_free (name);
9507                                 if (!type_is_reference (prop_type))
9508                                         g_free (pparams [0]);
9509                                 goto fail;
9510                         }
9511
9512
9513                         mono_property_set_value (prop, attr, pparams, NULL);
9514                         if (!type_is_reference (prop_type))
9515                                 g_free (pparams [0]);
9516                 }
9517                 g_free (name);
9518         }
9519
9520         free_param_data (method->signature, params);
9521         if (params != params_buf)
9522                 mono_gc_free_fixed (params);
9523
9524         return attr;
9525
9526 fail:
9527         free_param_data (method->signature, params);
9528         if (params != params_buf)
9529                 mono_gc_free_fixed (params);
9530         if (exc)
9531                 mono_raise_exception ((MonoException*)exc);
9532         return NULL;
9533 }
9534
9535 /*
9536  * mono_reflection_create_custom_attr_data_args:
9537  *
9538  *   Create an array of typed and named arguments from the cattr blob given by DATA.
9539  * TYPED_ARGS and NAMED_ARGS will contain the objects representing the arguments,
9540  * NAMED_ARG_INFO will contain information about the named arguments.
9541  */
9542 void
9543 mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *method, const guchar *data, guint32 len, MonoArray **typed_args, MonoArray **named_args, CattrNamedArg **named_arg_info, MonoError *error)
9544 {
9545         MonoArray *typedargs, *namedargs;
9546         MonoClass *attrklass;
9547         MonoDomain *domain;
9548         const char *p = (const char*)data;
9549         const char *named;
9550         guint32 i, j, num_named;
9551         CattrNamedArg *arginfo = NULL;
9552
9553         *typed_args = NULL;
9554         *named_args = NULL;
9555         *named_arg_info = NULL;
9556
9557         mono_error_init (error);
9558
9559         if (!mono_verifier_verify_cattr_content (image, method, data, len, NULL)) {
9560                 mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
9561                 return;
9562         }
9563
9564         mono_class_init (method->klass);
9565
9566         domain = mono_domain_get ();
9567
9568         if (len < 2 || read16 (p) != 0x0001) /* Prolog */
9569                 return;
9570
9571         typedargs = mono_array_new (domain, mono_get_object_class (), mono_method_signature (method)->param_count);
9572
9573         /* skip prolog */
9574         p += 2;
9575         for (i = 0; i < mono_method_signature (method)->param_count; ++i) {
9576                 MonoObject *obj;
9577
9578                 obj = load_cattr_value_boxed (domain, image, mono_method_signature (method)->params [i], p, &p, error);
9579                 return_if_nok (error);
9580                 mono_array_setref (typedargs, i, obj);
9581         }
9582
9583         named = p;
9584         num_named = read16 (named);
9585         namedargs = mono_array_new (domain, mono_get_object_class (), num_named);
9586         named += 2;
9587         attrklass = method->klass;
9588
9589         arginfo = g_new0 (CattrNamedArg, num_named);
9590         *named_arg_info = arginfo;
9591
9592         for (j = 0; j < num_named; j++) {
9593                 gint name_len;
9594                 char *name, named_type, data_type;
9595                 named_type = *named++;
9596                 data_type = *named++; /* type of data */
9597                 if (data_type == MONO_TYPE_SZARRAY)
9598                         data_type = *named++;
9599                 if (data_type == MONO_TYPE_ENUM) {
9600                         gint type_len;
9601                         char *type_name;
9602                         type_len = mono_metadata_decode_blob_size (named, &named);
9603                         if (ADDP_IS_GREATER_OR_OVF ((const guchar*)named, type_len, data + len))
9604                                 goto fail;
9605
9606                         type_name = (char *)g_malloc (type_len + 1);
9607                         memcpy (type_name, named, type_len);
9608                         type_name [type_len] = 0;
9609                         named += type_len;
9610                         /* FIXME: lookup the type and check type consistency */
9611                         g_free (type_name);
9612                 }
9613                 name_len = mono_metadata_decode_blob_size (named, &named);
9614                 if (ADDP_IS_GREATER_OR_OVF ((const guchar*)named, name_len, data + len))
9615                         goto fail;
9616                 name = (char *)g_malloc (name_len + 1);
9617                 memcpy (name, named, name_len);
9618                 name [name_len] = 0;
9619                 named += name_len;
9620                 if (named_type == 0x53) {
9621                         MonoObject *obj;
9622                         MonoClassField *field = mono_class_get_field_from_name (attrklass, name);
9623
9624                         if (!field) {
9625                                 g_free (name);
9626                                 goto fail;
9627                         }
9628
9629                         arginfo [j].type = field->type;
9630                         arginfo [j].field = field;
9631
9632                         obj = load_cattr_value_boxed (domain, image, field->type, named, &named, error);
9633                         if (!is_ok (error)) {
9634                                 g_free (name);
9635                                 return;
9636                         }
9637                         mono_array_setref (namedargs, j, obj);
9638
9639                 } else if (named_type == 0x54) {
9640                         MonoObject *obj;
9641                         MonoType *prop_type;
9642                         MonoProperty *prop = mono_class_get_property_from_name (attrklass, name);
9643
9644                         if (!prop || !prop->set) {
9645                                 g_free (name);
9646                                 goto fail;
9647                         }
9648
9649                         prop_type = prop->get? mono_method_signature (prop->get)->ret :
9650                              mono_method_signature (prop->set)->params [mono_method_signature (prop->set)->param_count - 1];
9651
9652                         arginfo [j].type = prop_type;
9653                         arginfo [j].prop = prop;
9654
9655                         obj = load_cattr_value_boxed (domain, image, prop_type, named, &named, error);
9656                         if (!is_ok (error)) {
9657                                 g_free (name);
9658                                 return;
9659                         }
9660                         mono_array_setref (namedargs, j, obj);
9661                 }
9662                 g_free (name);
9663         }
9664
9665         *typed_args = typedargs;
9666         *named_args = namedargs;
9667         return;
9668 fail:
9669         mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Binary format of the specified custom attribute was invalid.");
9670         g_free (arginfo);
9671         *named_arg_info = NULL;
9672 }
9673
9674 void
9675 mono_reflection_resolve_custom_attribute_data (MonoReflectionMethod *ref_method, MonoReflectionAssembly *assembly, gpointer data, guint32 len, MonoArray **ctor_args, MonoArray **named_args)
9676 {
9677         MonoDomain *domain;
9678         MonoArray *typedargs, *namedargs;
9679         MonoImage *image;
9680         MonoMethod *method;
9681         CattrNamedArg *arginfo = NULL;
9682         MonoError error;
9683         int i;
9684
9685         mono_error_init (&error);
9686
9687         *ctor_args = NULL;
9688         *named_args = NULL;
9689
9690         if (len == 0)
9691                 return;
9692
9693         image = assembly->assembly->image;
9694         method = ref_method->method;
9695         domain = mono_object_domain (ref_method);
9696
9697         if (!mono_class_init (method->klass))
9698                 mono_raise_exception (mono_class_get_exception_for_failure (method->klass));
9699
9700         mono_reflection_create_custom_attr_data_args (image, method, (const guchar *)data, len, &typedargs, &namedargs, &arginfo, &error);
9701         if (!mono_error_ok (&error))
9702                 goto leave;
9703
9704         if (mono_loader_get_last_error ()) {
9705                 mono_error_set_from_loader_error (&error);
9706                 goto leave;
9707         }
9708
9709         if (!typedargs || !namedargs)
9710                 goto leave;
9711
9712         for (i = 0; i < mono_method_signature (method)->param_count; ++i) {
9713                 MonoObject *obj = mono_array_get (typedargs, MonoObject*, i);
9714                 MonoObject *typedarg;
9715
9716                 typedarg = create_cattr_typed_arg (mono_method_signature (method)->params [i], obj, &error);
9717                 if (!is_ok (&error))
9718                         goto leave;
9719                 mono_array_setref (typedargs, i, typedarg);
9720         }
9721
9722         for (i = 0; i < mono_array_length (namedargs); ++i) {
9723                 MonoObject *obj = mono_array_get (namedargs, MonoObject*, i);
9724                 MonoObject *typedarg, *namedarg, *minfo;
9725
9726                 if (arginfo [i].prop) {
9727                         minfo = (MonoObject*)mono_property_get_object_checked (domain, NULL, arginfo [i].prop, &error);
9728                         if (!minfo)
9729                                 goto leave;
9730                 } else {
9731                         minfo = (MonoObject*)mono_field_get_object_checked (domain, NULL, arginfo [i].field, &error);
9732                         if (!mono_error_ok (&error))
9733                                 goto leave;
9734                 }
9735
9736                 typedarg = create_cattr_typed_arg (arginfo [i].type, obj, &error);
9737                 if (!is_ok (&error))
9738                         goto leave;
9739                 namedarg = create_cattr_named_arg (minfo, typedarg, &error);
9740                 if (!is_ok (&error))
9741                         goto leave;
9742
9743                 mono_array_setref (namedargs, i, namedarg);
9744         }
9745
9746         *ctor_args = typedargs;
9747         *named_args = namedargs;
9748 leave:
9749         g_free (arginfo);
9750         mono_error_raise_exception (&error);
9751
9752 }
9753
9754 static MonoObject*
9755 create_custom_attr_data (MonoImage *image, MonoCustomAttrEntry *cattr, MonoError *error)
9756 {
9757         static MonoMethod *ctor;
9758
9759         MonoDomain *domain;
9760         MonoObject *attr;
9761         void *params [4];
9762
9763         mono_error_init (error);
9764
9765         g_assert (image->assembly);
9766
9767         if (!ctor)
9768                 ctor = mono_class_get_method_from_name (mono_defaults.customattribute_data_class, ".ctor", 4);
9769
9770         domain = mono_domain_get ();
9771         attr = mono_object_new_checked (domain, mono_defaults.customattribute_data_class, error);
9772         return_val_if_nok (error, NULL);
9773         params [0] = mono_method_get_object_checked (domain, cattr->ctor, NULL, error);
9774         return_val_if_nok (error, NULL);
9775         params [1] = mono_assembly_get_object_checked (domain, image->assembly, error);
9776         return_val_if_nok (error, NULL);
9777         params [2] = (gpointer)&cattr->data;
9778         params [3] = &cattr->data_size;
9779
9780         mono_runtime_invoke_checked (ctor, attr, params, error);
9781         return_val_if_nok (error, NULL);
9782         return attr;
9783 }
9784
9785 static MonoArray*
9786 mono_custom_attrs_construct_by_type (MonoCustomAttrInfo *cinfo, MonoClass *attr_klass, MonoError *error)
9787 {
9788         MonoArray *result;
9789         MonoObject *attr;
9790         int i, n;
9791
9792         mono_error_init (error);
9793
9794         n = 0;
9795         for (i = 0; i < cinfo->num_attrs; ++i) {
9796                 if (!attr_klass || mono_class_is_assignable_from (attr_klass, cinfo->attrs [i].ctor->klass))
9797                         n ++;
9798         }
9799
9800         result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, n);
9801         n = 0;
9802         for (i = 0; i < cinfo->num_attrs; ++i) {
9803                 if (!cinfo->attrs [i].ctor) {
9804                         /* The cattr type is not finished yet */
9805                         /* We should include the type name but cinfo doesn't contain it */
9806                         mono_error_set_type_load_name (error, NULL, NULL, "");
9807                         return NULL;
9808                 }
9809                 if (!attr_klass || mono_class_is_assignable_from (attr_klass, cinfo->attrs [i].ctor->klass)) {
9810                         attr = create_custom_attr (cinfo->image, cinfo->attrs [i].ctor, cinfo->attrs [i].data, cinfo->attrs [i].data_size, error);
9811                         if (!mono_error_ok (error))
9812                                 return result;
9813                         mono_array_setref (result, n, attr);
9814                         n ++;
9815                 }
9816         }
9817         return result;
9818 }
9819
9820 MonoArray*
9821 mono_custom_attrs_construct (MonoCustomAttrInfo *cinfo)
9822 {
9823         MonoError error;
9824         MonoArray *result = mono_custom_attrs_construct_by_type (cinfo, NULL, &error);
9825         mono_error_assert_ok (&error); /*FIXME proper error handling*/
9826
9827         return result;
9828 }
9829
9830 static MonoArray*
9831 mono_custom_attrs_data_construct (MonoCustomAttrInfo *cinfo, MonoError *error)
9832 {
9833         MonoArray *result;
9834         MonoObject *attr;
9835         int i;
9836
9837         mono_error_init (error);
9838         result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, cinfo->num_attrs);
9839         for (i = 0; i < cinfo->num_attrs; ++i) {
9840                 attr = create_custom_attr_data (cinfo->image, &cinfo->attrs [i], error);
9841                 return_val_if_nok (error, NULL);
9842                 mono_array_setref (result, i, attr);
9843         }
9844         return result;
9845 }
9846
9847 /**
9848  * mono_custom_attrs_from_index:
9849  *
9850  * Returns: NULL if no attributes are found or if a loading error occurs.
9851  */
9852 MonoCustomAttrInfo*
9853 mono_custom_attrs_from_index (MonoImage *image, guint32 idx)
9854 {
9855         MonoError error;
9856         MonoCustomAttrInfo *result = mono_custom_attrs_from_index_checked (image, idx, &error);
9857         mono_error_cleanup (&error); /* FIXME a better public API that doesn't swallow the error. */
9858         return result;
9859 }
9860 /**
9861  * mono_custom_attrs_from_index_checked:
9862  *
9863  * Returns: NULL if no attributes are found.  On error returns NULL and sets @error.
9864  */
9865 MonoCustomAttrInfo*
9866 mono_custom_attrs_from_index_checked (MonoImage *image, guint32 idx, MonoError *error)
9867 {
9868         guint32 mtoken, i, len;
9869         guint32 cols [MONO_CUSTOM_ATTR_SIZE];
9870         MonoTableInfo *ca;
9871         MonoCustomAttrInfo *ainfo;
9872         GList *tmp, *list = NULL;
9873         const char *data;
9874         MonoCustomAttrEntry* attr;
9875
9876         mono_error_init (error);
9877
9878         ca = &image->tables [MONO_TABLE_CUSTOMATTRIBUTE];
9879
9880         i = mono_metadata_custom_attrs_from_index (image, idx);
9881         if (!i)
9882                 return NULL;
9883         i --;
9884         while (i < ca->rows) {
9885                 if (mono_metadata_decode_row_col (ca, i, MONO_CUSTOM_ATTR_PARENT) != idx)
9886                         break;
9887                 list = g_list_prepend (list, GUINT_TO_POINTER (i));
9888                 ++i;
9889         }
9890         len = g_list_length (list);
9891         if (!len)
9892                 return NULL;
9893         ainfo = (MonoCustomAttrInfo *)g_malloc0 (MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * len);
9894         ainfo->num_attrs = len;
9895         ainfo->image = image;
9896         for (i = len, tmp = list; i != 0; --i, tmp = tmp->next) {
9897                 mono_metadata_decode_row (ca, GPOINTER_TO_UINT (tmp->data), cols, MONO_CUSTOM_ATTR_SIZE);
9898                 mtoken = cols [MONO_CUSTOM_ATTR_TYPE] >> MONO_CUSTOM_ATTR_TYPE_BITS;
9899                 switch (cols [MONO_CUSTOM_ATTR_TYPE] & MONO_CUSTOM_ATTR_TYPE_MASK) {
9900                 case MONO_CUSTOM_ATTR_TYPE_METHODDEF:
9901                         mtoken |= MONO_TOKEN_METHOD_DEF;
9902                         break;
9903                 case MONO_CUSTOM_ATTR_TYPE_MEMBERREF:
9904                         mtoken |= MONO_TOKEN_MEMBER_REF;
9905                         break;
9906                 default:
9907                         g_error ("Unknown table for custom attr type %08x", cols [MONO_CUSTOM_ATTR_TYPE]);
9908                         break;
9909                 }
9910                 attr = &ainfo->attrs [i - 1];
9911                 attr->ctor = mono_get_method_checked (image, mtoken, NULL, NULL, error);
9912                 if (!attr->ctor) {
9913                         g_warning ("Can't find custom attr constructor image: %s mtoken: 0x%08x due to %s", image->name, mtoken, mono_error_get_message (error));
9914                         g_list_free (list);
9915                         g_free (ainfo);
9916                         return NULL;
9917                 }
9918
9919                 if (!mono_verifier_verify_cattr_blob (image, cols [MONO_CUSTOM_ATTR_VALUE], NULL)) {
9920                         /*FIXME raising an exception here doesn't make any sense*/
9921                         g_warning ("Invalid custom attribute blob on image %s for index %x", image->name, idx);
9922                         g_list_free (list);
9923                         g_free (ainfo);
9924                         return NULL;
9925                 }
9926                 data = mono_metadata_blob_heap (image, cols [MONO_CUSTOM_ATTR_VALUE]);
9927                 attr->data_size = mono_metadata_decode_value (data, &data);
9928                 attr->data = (guchar*)data;
9929         }
9930         g_list_free (list);
9931
9932         return ainfo;
9933 }
9934
9935 MonoCustomAttrInfo*
9936 mono_custom_attrs_from_method (MonoMethod *method)
9937 {
9938         MonoError error;
9939         MonoCustomAttrInfo* result = mono_custom_attrs_from_method_checked  (method, &error);
9940         mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
9941         return result;
9942 }
9943
9944 MonoCustomAttrInfo*
9945 mono_custom_attrs_from_method_checked (MonoMethod *method, MonoError *error)
9946 {
9947         guint32 idx;
9948
9949         mono_error_init (error);
9950
9951         /*
9952          * An instantiated method has the same cattrs as the generic method definition.
9953          *
9954          * LAMESPEC: The .NET SRE throws an exception for instantiations of generic method builders
9955          *           Note that this stanza is not necessary for non-SRE types, but it's a micro-optimization
9956          */
9957         if (method->is_inflated)
9958                 method = ((MonoMethodInflated *) method)->declaring;
9959
9960         if (method_is_dynamic (method) || image_is_dynamic (method->klass->image))
9961                 return lookup_custom_attr (method->klass->image, method);
9962
9963         if (!method->token)
9964                 /* Synthetic methods */
9965                 return NULL;
9966
9967         idx = mono_method_get_index (method);
9968         idx <<= MONO_CUSTOM_ATTR_BITS;
9969         idx |= MONO_CUSTOM_ATTR_METHODDEF;
9970         return mono_custom_attrs_from_index_checked (method->klass->image, idx, error);
9971 }
9972
9973 MonoCustomAttrInfo*
9974 mono_custom_attrs_from_class (MonoClass *klass)
9975 {
9976         MonoError error;
9977         MonoCustomAttrInfo *result = mono_custom_attrs_from_class_checked (klass, &error);
9978         mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
9979         return result;
9980 }
9981
9982 MonoCustomAttrInfo*
9983 mono_custom_attrs_from_class_checked (MonoClass *klass, MonoError *error)
9984 {
9985         guint32 idx;
9986
9987         mono_error_init (error);
9988
9989         if (klass->generic_class)
9990                 klass = klass->generic_class->container_class;
9991
9992         if (image_is_dynamic (klass->image))
9993                 return lookup_custom_attr (klass->image, klass);
9994
9995         if (klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR) {
9996                 idx = mono_metadata_token_index (klass->sizes.generic_param_token);
9997                 idx <<= MONO_CUSTOM_ATTR_BITS;
9998                 idx |= MONO_CUSTOM_ATTR_GENERICPAR;
9999         } else {
10000                 idx = mono_metadata_token_index (klass->type_token);
10001                 idx <<= MONO_CUSTOM_ATTR_BITS;
10002                 idx |= MONO_CUSTOM_ATTR_TYPEDEF;
10003         }
10004         return mono_custom_attrs_from_index_checked (klass->image, idx, error);
10005 }
10006
10007 MonoCustomAttrInfo*
10008 mono_custom_attrs_from_assembly (MonoAssembly *assembly)
10009 {
10010         MonoError error;
10011         MonoCustomAttrInfo *result = mono_custom_attrs_from_assembly_checked (assembly, &error);
10012         mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
10013         return result;
10014 }
10015
10016 MonoCustomAttrInfo*
10017 mono_custom_attrs_from_assembly_checked (MonoAssembly *assembly, MonoError *error)
10018 {
10019         guint32 idx;
10020
10021         mono_error_init (error);
10022
10023         if (image_is_dynamic (assembly->image))
10024                 return lookup_custom_attr (assembly->image, assembly);
10025         idx = 1; /* there is only one assembly */
10026         idx <<= MONO_CUSTOM_ATTR_BITS;
10027         idx |= MONO_CUSTOM_ATTR_ASSEMBLY;
10028         return mono_custom_attrs_from_index_checked (assembly->image, idx, error);
10029 }
10030
10031 static MonoCustomAttrInfo*
10032 mono_custom_attrs_from_module (MonoImage *image, MonoError *error)
10033 {
10034         guint32 idx;
10035
10036         if (image_is_dynamic (image))
10037                 return lookup_custom_attr (image, image);
10038         idx = 1; /* there is only one module */
10039         idx <<= MONO_CUSTOM_ATTR_BITS;
10040         idx |= MONO_CUSTOM_ATTR_MODULE;
10041         return mono_custom_attrs_from_index_checked (image, idx, error);
10042 }
10043
10044 MonoCustomAttrInfo*
10045 mono_custom_attrs_from_property (MonoClass *klass, MonoProperty *property)
10046 {
10047         MonoError error;
10048         MonoCustomAttrInfo * result = mono_custom_attrs_from_property_checked (klass, property, &error);
10049         mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
10050         return result;
10051 }
10052
10053 MonoCustomAttrInfo*
10054 mono_custom_attrs_from_property_checked (MonoClass *klass, MonoProperty *property, MonoError *error)
10055 {
10056         guint32 idx;
10057
10058         if (image_is_dynamic (klass->image)) {
10059                 property = mono_metadata_get_corresponding_property_from_generic_type_definition (property);
10060                 return lookup_custom_attr (klass->image, property);
10061         }
10062         idx = find_property_index (klass, property);
10063         idx <<= MONO_CUSTOM_ATTR_BITS;
10064         idx |= MONO_CUSTOM_ATTR_PROPERTY;
10065         return mono_custom_attrs_from_index_checked (klass->image, idx, error);
10066 }
10067
10068 MonoCustomAttrInfo*
10069 mono_custom_attrs_from_event (MonoClass *klass, MonoEvent *event)
10070 {
10071         MonoError error;
10072         MonoCustomAttrInfo * result = mono_custom_attrs_from_event_checked (klass, event, &error);
10073         mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
10074         return result;
10075 }
10076
10077 MonoCustomAttrInfo*
10078 mono_custom_attrs_from_event_checked (MonoClass *klass, MonoEvent *event, MonoError *error)
10079 {
10080         guint32 idx;
10081
10082         if (image_is_dynamic (klass->image)) {
10083                 event = mono_metadata_get_corresponding_event_from_generic_type_definition (event);
10084                 return lookup_custom_attr (klass->image, event);
10085         }
10086         idx = find_event_index (klass, event);
10087         idx <<= MONO_CUSTOM_ATTR_BITS;
10088         idx |= MONO_CUSTOM_ATTR_EVENT;
10089         return mono_custom_attrs_from_index_checked (klass->image, idx, error);
10090 }
10091
10092 MonoCustomAttrInfo*
10093 mono_custom_attrs_from_field (MonoClass *klass, MonoClassField *field)
10094 {
10095         MonoError error;
10096         MonoCustomAttrInfo * result = mono_custom_attrs_from_field_checked (klass, field, &error);
10097         mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
10098         return result;
10099 }
10100
10101 MonoCustomAttrInfo*
10102 mono_custom_attrs_from_field_checked (MonoClass *klass, MonoClassField *field, MonoError *error)
10103 {
10104         guint32 idx;
10105         mono_error_init (error);
10106
10107         if (image_is_dynamic (klass->image)) {
10108                 field = mono_metadata_get_corresponding_field_from_generic_type_definition (field);
10109                 return lookup_custom_attr (klass->image, field);
10110         }
10111         idx = find_field_index (klass, field);
10112         idx <<= MONO_CUSTOM_ATTR_BITS;
10113         idx |= MONO_CUSTOM_ATTR_FIELDDEF;
10114         return mono_custom_attrs_from_index_checked (klass->image, idx, error);
10115 }
10116
10117 /**
10118  * mono_custom_attrs_from_param:
10119  * @method: handle to the method that we want to retrieve custom parameter information from
10120  * @param: parameter number, where zero represent the return value, and one is the first parameter in the method
10121  *
10122  * The result must be released with mono_custom_attrs_free().
10123  *
10124  * Returns: the custom attribute object for the specified parameter, or NULL if there are none.
10125  */
10126 MonoCustomAttrInfo*
10127 mono_custom_attrs_from_param (MonoMethod *method, guint32 param)
10128 {
10129         MonoError error;
10130         MonoCustomAttrInfo *result = mono_custom_attrs_from_param_checked (method, param, &error);
10131         mono_error_cleanup (&error); /* FIXME want a better API that doesn't swallow the error */
10132         return result;
10133 }
10134
10135 /**
10136  * mono_custom_attrs_from_param_checked:
10137  * @method: handle to the method that we want to retrieve custom parameter information from
10138  * @param: parameter number, where zero represent the return value, and one is the first parameter in the method
10139  * @error: set on error
10140  *
10141  * The result must be released with mono_custom_attrs_free().
10142  *
10143  * Returns: the custom attribute object for the specified parameter, or NULL if there are none.  On failure returns NULL and sets @error.
10144  */
10145 MonoCustomAttrInfo*
10146 mono_custom_attrs_from_param_checked (MonoMethod *method, guint32 param, MonoError *error)
10147 {
10148         MonoTableInfo *ca;
10149         guint32 i, idx, method_index;
10150         guint32 param_list, param_last, param_pos, found;
10151         MonoImage *image;
10152         MonoReflectionMethodAux *aux;
10153
10154         mono_error_init (error);
10155
10156         /*
10157          * An instantiated method has the same cattrs as the generic method definition.
10158          *
10159          * LAMESPEC: The .NET SRE throws an exception for instantiations of generic method builders
10160          *           Note that this stanza is not necessary for non-SRE types, but it's a micro-optimization
10161          */
10162         if (method->is_inflated)
10163                 method = ((MonoMethodInflated *) method)->declaring;
10164
10165         if (image_is_dynamic (method->klass->image)) {
10166                 MonoCustomAttrInfo *res, *ainfo;
10167                 int size;
10168
10169                 aux = (MonoReflectionMethodAux *)g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method);
10170                 if (!aux || !aux->param_cattr)
10171                         return NULL;
10172
10173                 /* Need to copy since it will be freed later */
10174                 ainfo = aux->param_cattr [param];
10175                 if (!ainfo)
10176                         return NULL;
10177                 size = MONO_SIZEOF_CUSTOM_ATTR_INFO + sizeof (MonoCustomAttrEntry) * ainfo->num_attrs;
10178                 res = (MonoCustomAttrInfo *)g_malloc0 (size);
10179                 memcpy (res, ainfo, size);
10180                 return res;
10181         }
10182
10183         image = method->klass->image;
10184         method_index = mono_method_get_index (method);
10185         if (!method_index)
10186                 return NULL;
10187         ca = &image->tables [MONO_TABLE_METHOD];
10188
10189         param_list = mono_metadata_decode_row_col (ca, method_index - 1, MONO_METHOD_PARAMLIST);
10190         if (method_index == ca->rows) {
10191                 ca = &image->tables [MONO_TABLE_PARAM];
10192                 param_last = ca->rows + 1;
10193         } else {
10194                 param_last = mono_metadata_decode_row_col (ca, method_index, MONO_METHOD_PARAMLIST);
10195                 ca = &image->tables [MONO_TABLE_PARAM];
10196         }
10197         found = FALSE;
10198         for (i = param_list; i < param_last; ++i) {
10199                 param_pos = mono_metadata_decode_row_col (ca, i - 1, MONO_PARAM_SEQUENCE);
10200                 if (param_pos == param) {
10201                         found = TRUE;
10202                         break;
10203                 }
10204         }
10205         if (!found)
10206                 return NULL;
10207         idx = i;
10208         idx <<= MONO_CUSTOM_ATTR_BITS;
10209         idx |= MONO_CUSTOM_ATTR_PARAMDEF;
10210         return mono_custom_attrs_from_index_checked (image, idx, error);
10211 }
10212
10213 gboolean
10214 mono_custom_attrs_has_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass)
10215 {
10216         int i;
10217         MonoClass *klass;
10218         for (i = 0; i < ainfo->num_attrs; ++i) {
10219                 klass = ainfo->attrs [i].ctor->klass;
10220                 if (mono_class_has_parent (klass, attr_klass) || (MONO_CLASS_IS_INTERFACE (attr_klass) && mono_class_is_assignable_from (attr_klass, klass)))
10221                         return TRUE;
10222         }
10223         return FALSE;
10224 }
10225
10226 MonoObject*
10227 mono_custom_attrs_get_attr (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass)
10228 {
10229         MonoError error;
10230         MonoObject *res = mono_custom_attrs_get_attr_checked (ainfo, attr_klass, &error);
10231         g_assert (mono_error_ok (&error)); /*FIXME proper error handling*/
10232         return res;
10233 }
10234
10235 MonoObject*
10236 mono_custom_attrs_get_attr_checked (MonoCustomAttrInfo *ainfo, MonoClass *attr_klass, MonoError *error)
10237 {
10238         int i, attr_index;
10239         MonoClass *klass;
10240         MonoArray *attrs;
10241
10242         mono_error_init (error);
10243
10244         attr_index = -1;
10245         for (i = 0; i < ainfo->num_attrs; ++i) {
10246                 klass = ainfo->attrs [i].ctor->klass;
10247                 if (mono_class_has_parent (klass, attr_klass)) {
10248                         attr_index = i;
10249                         break;
10250                 }
10251         }
10252         if (attr_index == -1)
10253                 return NULL;
10254
10255         attrs = mono_custom_attrs_construct_by_type (ainfo, NULL, error);
10256         if (!mono_error_ok (error))
10257                 return NULL;
10258         return mono_array_get (attrs, MonoObject*, attr_index);
10259 }
10260
10261 /*
10262  * mono_reflection_get_custom_attrs_info:
10263  * @obj: a reflection object handle
10264  *
10265  * Return the custom attribute info for attributes defined for the
10266  * reflection handle @obj. The objects.
10267  *
10268  * FIXME this function leaks like a sieve for SRE objects.
10269  */
10270 MonoCustomAttrInfo*
10271 mono_reflection_get_custom_attrs_info (MonoObject *obj)
10272 {
10273         MonoError error;
10274         MonoCustomAttrInfo *result = mono_reflection_get_custom_attrs_info_checked (obj, &error);
10275         mono_error_assert_ok (&error);
10276         return result;
10277 }
10278
10279 /**
10280  * mono_reflection_get_custom_attrs_info_checked:
10281  * @obj: a reflection object handle
10282  * @error: set on error
10283  *
10284  * Return the custom attribute info for attributes defined for the
10285  * reflection handle @obj. The objects.
10286  *
10287  * On failure returns NULL and sets @error.
10288  *
10289  * FIXME this function leaks like a sieve for SRE objects.
10290  */
10291 MonoCustomAttrInfo*
10292 mono_reflection_get_custom_attrs_info_checked (MonoObject *obj, MonoError *error)
10293 {
10294         MonoClass *klass;
10295         MonoCustomAttrInfo *cinfo = NULL;
10296
10297         mono_error_init (error);
10298
10299         klass = obj->vtable->klass;
10300         if (klass == mono_defaults.monotype_class) {
10301                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error);
10302                 return_val_if_nok (error, NULL);
10303                 klass = mono_class_from_mono_type (type);
10304                 /*We cannot mono_class_init the class from which we'll load the custom attributes since this must work with broken types.*/
10305                 cinfo = mono_custom_attrs_from_class_checked (klass, error);
10306                 return_val_if_nok (error, NULL);
10307         } else if (strcmp ("Assembly", klass->name) == 0 || strcmp ("MonoAssembly", klass->name) == 0) {
10308                 MonoReflectionAssembly *rassembly = (MonoReflectionAssembly*)obj;
10309                 cinfo = mono_custom_attrs_from_assembly_checked (rassembly->assembly, error);
10310                 return_val_if_nok (error, NULL);
10311         } else if (strcmp ("Module", klass->name) == 0 || strcmp ("MonoModule", klass->name) == 0) {
10312                 MonoReflectionModule *module = (MonoReflectionModule*)obj;
10313                 cinfo = mono_custom_attrs_from_module (module->image, error);
10314                 return_val_if_nok (error, NULL);
10315         } else if (strcmp ("MonoProperty", klass->name) == 0) {
10316                 MonoReflectionProperty *rprop = (MonoReflectionProperty*)obj;
10317                 cinfo = mono_custom_attrs_from_property_checked (rprop->property->parent, rprop->property, error);
10318                 return_val_if_nok (error, NULL);
10319         } else if (strcmp ("MonoEvent", klass->name) == 0) {
10320                 MonoReflectionMonoEvent *revent = (MonoReflectionMonoEvent*)obj;
10321                 cinfo = mono_custom_attrs_from_event_checked (revent->event->parent, revent->event, error);
10322                 return_val_if_nok (error, NULL);
10323         } else if (strcmp ("MonoField", klass->name) == 0) {
10324                 MonoReflectionField *rfield = (MonoReflectionField*)obj;
10325                 cinfo = mono_custom_attrs_from_field_checked (rfield->field->parent, rfield->field, error);
10326                 return_val_if_nok (error, NULL);
10327         } else if ((strcmp ("MonoMethod", klass->name) == 0) || (strcmp ("MonoCMethod", klass->name) == 0)) {
10328                 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)obj;
10329                 cinfo = mono_custom_attrs_from_method_checked (rmethod->method, error);
10330                 return_val_if_nok (error, NULL);
10331         } else if ((strcmp ("MonoGenericMethod", klass->name) == 0) || (strcmp ("MonoGenericCMethod", klass->name) == 0)) {
10332                 MonoReflectionMethod *rmethod = (MonoReflectionMethod*)obj;
10333                 cinfo = mono_custom_attrs_from_method_checked (rmethod->method, error);
10334                 return_val_if_nok (error, NULL);
10335         } else if (strcmp ("ParameterInfo", klass->name) == 0 || strcmp ("MonoParameterInfo", klass->name) == 0) {
10336                 MonoReflectionParameter *param = (MonoReflectionParameter*)obj;
10337                 MonoClass *member_class = mono_object_class (param->MemberImpl);
10338                 if (mono_class_is_reflection_method_or_constructor (member_class)) {
10339                         MonoReflectionMethod *rmethod = (MonoReflectionMethod*)param->MemberImpl;
10340                         cinfo = mono_custom_attrs_from_param_checked (rmethod->method, param->PositionImpl + 1, error);
10341                         return_val_if_nok (error, NULL);
10342                 } else if (is_sr_mono_property (member_class)) {
10343                         MonoReflectionProperty *prop = (MonoReflectionProperty *)param->MemberImpl;
10344                         MonoMethod *method;
10345                         if (!(method = prop->property->get))
10346                                 method = prop->property->set;
10347                         g_assert (method);
10348
10349                         cinfo = mono_custom_attrs_from_param_checked (method, param->PositionImpl + 1, error);
10350                         return_val_if_nok (error, NULL);
10351                 }
10352 #ifndef DISABLE_REFLECTION_EMIT
10353                 else if (is_sre_method_on_tb_inst (member_class)) {/*XXX This is a workaround for Compiler Context*/
10354                         MonoMethod *method = mono_reflection_method_on_tb_inst_get_handle ((MonoReflectionMethodOnTypeBuilderInst*)param->MemberImpl, error);
10355                         return_val_if_nok (error, NULL);
10356                         cinfo = mono_custom_attrs_from_param_checked (method, param->PositionImpl + 1, error);
10357                         return_val_if_nok (error, NULL);
10358                 } else if (is_sre_ctor_on_tb_inst (member_class)) { /*XX This is a workaround for Compiler Context*/
10359                         MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)param->MemberImpl;
10360                         MonoMethod *method = NULL;
10361                         if (is_sre_ctor_builder (mono_object_class (c->cb)))
10362                                 method = ((MonoReflectionCtorBuilder *)c->cb)->mhandle;
10363                         else if (is_sr_mono_cmethod (mono_object_class (c->cb)))
10364                                 method = ((MonoReflectionMethod *)c->cb)->method;
10365                         else
10366                                 g_error ("mono_reflection_get_custom_attrs_info:: can't handle a CTBI with base_method of type %s", mono_type_get_full_name (member_class));
10367
10368                         cinfo = mono_custom_attrs_from_param_checked (method, param->PositionImpl + 1, error);
10369                         return_val_if_nok (error, NULL);
10370                 }
10371 #endif
10372                 else {
10373                         char *type_name = mono_type_get_full_name (member_class);
10374                         mono_error_set_not_supported (error,
10375                                                       "Custom attributes on a ParamInfo with member %s are not supported",
10376                                                       type_name);
10377                         g_free (type_name);
10378                         return NULL;
10379                 }
10380         } else if (strcmp ("AssemblyBuilder", klass->name) == 0) {
10381                 MonoReflectionAssemblyBuilder *assemblyb = (MonoReflectionAssemblyBuilder*)obj;
10382                 cinfo = mono_custom_attrs_from_builders (NULL, assemblyb->assembly.assembly->image, assemblyb->cattrs);
10383         } else if (strcmp ("TypeBuilder", klass->name) == 0) {
10384                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)obj;
10385                 cinfo = mono_custom_attrs_from_builders (NULL, &tb->module->dynamic_image->image, tb->cattrs);
10386         } else if (strcmp ("ModuleBuilder", klass->name) == 0) {
10387                 MonoReflectionModuleBuilder *mb = (MonoReflectionModuleBuilder*)obj;
10388                 cinfo = mono_custom_attrs_from_builders (NULL, &mb->dynamic_image->image, mb->cattrs);
10389         } else if (strcmp ("ConstructorBuilder", klass->name) == 0) {
10390                 MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder*)obj;
10391                 cinfo = mono_custom_attrs_from_builders (NULL, cb->mhandle->klass->image, cb->cattrs);
10392         } else if (strcmp ("MethodBuilder", klass->name) == 0) {
10393                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)obj;
10394                 cinfo = mono_custom_attrs_from_builders (NULL, mb->mhandle->klass->image, mb->cattrs);
10395         } else if (strcmp ("FieldBuilder", klass->name) == 0) {
10396                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder*)obj;
10397                 cinfo = mono_custom_attrs_from_builders (NULL, &((MonoReflectionTypeBuilder*)fb->typeb)->module->dynamic_image->image, fb->cattrs);
10398         } else if (strcmp ("MonoGenericClass", klass->name) == 0) {
10399                 MonoReflectionGenericClass *gclass = (MonoReflectionGenericClass*)obj;
10400                 cinfo = mono_reflection_get_custom_attrs_info_checked ((MonoObject*)gclass->generic_type, error);
10401                 return_val_if_nok (error, NULL);
10402         } else { /* handle other types here... */
10403                 g_error ("get custom attrs not yet supported for %s", klass->name);
10404         }
10405
10406         return cinfo;
10407 }
10408
10409 /*
10410  * mono_reflection_get_custom_attrs_by_type:
10411  * @obj: a reflection object handle
10412  *
10413  * Return an array with all the custom attributes defined of the
10414  * reflection handle @obj. If @attr_klass is non-NULL, only custom attributes
10415  * of that type are returned. The objects are fully build. Return NULL if a loading error
10416  * occurs.
10417  */
10418 MonoArray*
10419 mono_reflection_get_custom_attrs_by_type (MonoObject *obj, MonoClass *attr_klass, MonoError *error)
10420 {
10421         MonoArray *result;
10422         MonoCustomAttrInfo *cinfo;
10423
10424         mono_error_init (error);
10425
10426         cinfo = mono_reflection_get_custom_attrs_info_checked (obj, error);
10427         return_val_if_nok (error, NULL);
10428         if (cinfo) {
10429                 result = mono_custom_attrs_construct_by_type (cinfo, attr_klass, error);
10430                 if (!result)
10431                         return NULL;
10432                 if (!cinfo->cached)
10433                         mono_custom_attrs_free (cinfo);
10434         } else {
10435                 mono_loader_assert_no_error ();
10436                 result = mono_array_new_cached (mono_domain_get (), mono_defaults.attribute_class, 0);
10437         }
10438
10439         return result;
10440 }
10441
10442 /*
10443  * mono_reflection_get_custom_attrs:
10444  * @obj: a reflection object handle
10445  *
10446  * Return an array with all the custom attributes defined of the
10447  * reflection handle @obj. The objects are fully build. Return NULL if a loading error
10448  * occurs.
10449  */
10450 MonoArray*
10451 mono_reflection_get_custom_attrs (MonoObject *obj)
10452 {
10453         MonoError error;
10454
10455         return mono_reflection_get_custom_attrs_by_type (obj, NULL, &error);
10456 }
10457
10458 /*
10459  * mono_reflection_get_custom_attrs_data:
10460  * @obj: a reflection obj handle
10461  *
10462  * Returns an array of System.Reflection.CustomAttributeData,
10463  * which include information about attributes reflected on
10464  * types loaded using the Reflection Only methods
10465  */
10466 MonoArray*
10467 mono_reflection_get_custom_attrs_data (MonoObject *obj)
10468 {
10469         MonoError error;
10470         MonoArray* result;
10471         result = mono_reflection_get_custom_attrs_data_checked (obj, &error);
10472         mono_error_cleanup (&error); /* FIXME new API that doesn't swallow the error */
10473         return result;
10474 }
10475
10476 /*
10477  * mono_reflection_get_custom_attrs_data_checked:
10478  * @obj: a reflection obj handle
10479  * @error: set on error
10480  *
10481  * Returns an array of System.Reflection.CustomAttributeData,
10482  * which include information about attributes reflected on
10483  * types loaded using the Reflection Only methods
10484  */
10485 MonoArray*
10486 mono_reflection_get_custom_attrs_data_checked (MonoObject *obj, MonoError *error)
10487 {
10488         MonoArray *result;
10489         MonoCustomAttrInfo *cinfo;
10490
10491         mono_error_init (error);
10492
10493         cinfo = mono_reflection_get_custom_attrs_info_checked (obj, error);
10494         return_val_if_nok (error, NULL);
10495         if (cinfo) {
10496                 result = mono_custom_attrs_data_construct (cinfo, error);
10497                 return_val_if_nok (error, NULL);
10498                 if (!cinfo->cached)
10499                         mono_custom_attrs_free (cinfo);
10500         } else
10501                 result = mono_array_new (mono_domain_get (), mono_defaults.customattribute_data_class, 0);
10502
10503         if (mono_loader_get_last_error ())
10504                 mono_error_set_from_loader_error (error);
10505
10506         return result;
10507 }
10508
10509 static MonoReflectionType*
10510 mono_reflection_type_get_underlying_system_type (MonoReflectionType* t, MonoError *error)
10511 {
10512         static MonoMethod *method_get_underlying_system_type = NULL;
10513         MonoReflectionType *rt;
10514         MonoMethod *usertype_method;
10515
10516         mono_error_init (error);
10517
10518         if (!method_get_underlying_system_type)
10519                 method_get_underlying_system_type = mono_class_get_method_from_name (mono_defaults.systemtype_class, "get_UnderlyingSystemType", 0);
10520
10521         usertype_method = mono_object_get_virtual_method ((MonoObject *) t, method_get_underlying_system_type);
10522
10523         rt = (MonoReflectionType *) mono_runtime_invoke_checked (usertype_method, t, NULL, error);
10524
10525         return rt;
10526 }
10527
10528
10529 static gboolean
10530 is_corlib_type (MonoClass *klass)
10531 {
10532         return klass->image == mono_defaults.corlib;
10533 }
10534
10535 #define check_corlib_type_cached(_class, _namespace, _name) do { \
10536         static MonoClass *cached_class; \
10537         if (cached_class) \
10538                 return cached_class == _class; \
10539         if (is_corlib_type (_class) && !strcmp (_name, _class->name) && !strcmp (_namespace, _class->name_space)) { \
10540                 cached_class = _class; \
10541                 return TRUE; \
10542         } \
10543         return FALSE; \
10544 } while (0) \
10545
10546
10547 #ifndef DISABLE_REFLECTION_EMIT
10548 static gboolean
10549 is_sre_array (MonoClass *klass)
10550 {
10551         check_corlib_type_cached (klass, "System.Reflection.Emit", "ArrayType");
10552 }
10553
10554 static gboolean
10555 is_sre_byref (MonoClass *klass)
10556 {
10557         check_corlib_type_cached (klass, "System.Reflection.Emit", "ByRefType");
10558 }
10559
10560 static gboolean
10561 is_sre_pointer (MonoClass *klass)
10562 {
10563         check_corlib_type_cached (klass, "System.Reflection.Emit", "PointerType");
10564 }
10565
10566 static gboolean
10567 is_sre_generic_instance (MonoClass *klass)
10568 {
10569         check_corlib_type_cached (klass, "System.Reflection", "MonoGenericClass");
10570 }
10571
10572 static gboolean
10573 is_sre_type_builder (MonoClass *klass)
10574 {
10575         check_corlib_type_cached (klass, "System.Reflection.Emit", "TypeBuilder");
10576 }
10577
10578 static gboolean
10579 is_sre_method_builder (MonoClass *klass)
10580 {
10581         check_corlib_type_cached (klass, "System.Reflection.Emit", "MethodBuilder");
10582 }
10583
10584 static gboolean
10585 is_sre_ctor_builder (MonoClass *klass)
10586 {
10587         check_corlib_type_cached (klass, "System.Reflection.Emit", "ConstructorBuilder");
10588 }
10589
10590 static gboolean
10591 is_sre_field_builder (MonoClass *klass)
10592 {
10593         check_corlib_type_cached (klass, "System.Reflection.Emit", "FieldBuilder");
10594 }
10595
10596 static gboolean
10597 is_sre_method_on_tb_inst (MonoClass *klass)
10598 {
10599         check_corlib_type_cached (klass, "System.Reflection.Emit", "MethodOnTypeBuilderInst");
10600 }
10601
10602 static gboolean
10603 is_sre_ctor_on_tb_inst (MonoClass *klass)
10604 {
10605         check_corlib_type_cached (klass, "System.Reflection.Emit", "ConstructorOnTypeBuilderInst");
10606 }
10607
10608 MonoType*
10609 mono_reflection_type_get_handle (MonoReflectionType* ref, MonoError *error)
10610 {
10611         MonoClass *klass;
10612         mono_error_init (error);
10613
10614         if (!ref)
10615                 return NULL;
10616         if (ref->type)
10617                 return ref->type;
10618
10619         if (is_usertype (ref)) {
10620                 ref = mono_reflection_type_get_underlying_system_type (ref, error);
10621                 if (ref == NULL || is_usertype (ref) || !is_ok (error))
10622                         return NULL;
10623                 if (ref->type)
10624                         return ref->type;
10625         }
10626
10627         klass = mono_object_class (ref);
10628
10629         if (is_sre_array (klass)) {
10630                 MonoType *res;
10631                 MonoReflectionArrayType *sre_array = (MonoReflectionArrayType*)ref;
10632                 MonoType *base = mono_reflection_type_get_handle (sre_array->element_type, error);
10633                 return_val_if_nok (error, NULL);
10634                 g_assert (base);
10635                 if (sre_array->rank == 0) //single dimentional array
10636                         res = &mono_array_class_get (mono_class_from_mono_type (base), 1)->byval_arg;
10637                 else
10638                         res = &mono_bounded_array_class_get (mono_class_from_mono_type (base), sre_array->rank, TRUE)->byval_arg;
10639                 sre_array->type.type = res;
10640                 return res;
10641         } else if (is_sre_byref (klass)) {
10642                 MonoType *res;
10643                 MonoReflectionDerivedType *sre_byref = (MonoReflectionDerivedType*)ref;
10644                 MonoType *base = mono_reflection_type_get_handle (sre_byref->element_type, error);
10645                 return_val_if_nok (error, NULL);
10646                 g_assert (base);
10647                 res = &mono_class_from_mono_type (base)->this_arg;
10648                 sre_byref->type.type = res;
10649                 return res;
10650         } else if (is_sre_pointer (klass)) {
10651                 MonoType *res;
10652                 MonoReflectionDerivedType *sre_pointer = (MonoReflectionDerivedType*)ref;
10653                 MonoType *base = mono_reflection_type_get_handle (sre_pointer->element_type, error);
10654                 return_val_if_nok (error, NULL);
10655                 g_assert (base);
10656                 res = &mono_ptr_class_get (base)->byval_arg;
10657                 sre_pointer->type.type = res;
10658                 return res;
10659         } else if (is_sre_generic_instance (klass)) {
10660                 MonoType *res, **types;
10661                 MonoReflectionGenericClass *gclass = (MonoReflectionGenericClass*)ref;
10662                 int i, count;
10663
10664                 count = mono_array_length (gclass->type_arguments);
10665                 types = g_new0 (MonoType*, count);
10666                 for (i = 0; i < count; ++i) {
10667                         MonoReflectionType *t = (MonoReflectionType *)mono_array_get (gclass->type_arguments, gpointer, i);
10668                         types [i] = mono_reflection_type_get_handle (t, error);
10669                         if (!types[i] || !is_ok (error)) {
10670                                 g_free (types);
10671                                 return NULL;
10672                         }
10673                 }
10674
10675                 res = mono_reflection_bind_generic_parameters (gclass->generic_type, count, types, error);
10676                 g_free (types);
10677                 g_assert (res);
10678                 gclass->type.type = res;
10679                 return res;
10680         }
10681
10682         g_error ("Cannot handle corlib user type %s", mono_type_full_name (&mono_object_class(ref)->byval_arg));
10683         return NULL;
10684 }
10685
10686 void
10687 mono_reflection_create_unmanaged_type (MonoReflectionType *type)
10688 {
10689         MonoError error;
10690         mono_reflection_type_get_handle (type, &error);
10691         mono_error_set_pending_exception (&error);
10692 }
10693
10694 static gboolean
10695 reflection_register_with_runtime (MonoReflectionType *type, MonoError *error)
10696 {
10697         MonoDomain *domain = mono_object_domain ((MonoObject*)type);
10698         MonoClass *klass;
10699
10700         mono_error_init (error);
10701
10702         MonoType *res = mono_reflection_type_get_handle (type, error);
10703
10704         if (!res && is_ok (error)) {
10705                 mono_error_set_argument (error, NULL, "Invalid generic instantiation, one or more arguments are not proper user types");
10706         }
10707         return_val_if_nok (error, FALSE);
10708
10709         klass = mono_class_from_mono_type (res);
10710
10711         mono_loader_lock (); /*same locking as mono_type_get_object_checked */
10712         mono_domain_lock (domain);
10713
10714         if (!image_is_dynamic (klass->image)) {
10715                 mono_class_setup_supertypes (klass);
10716         } else {
10717                 if (!domain->type_hash)
10718                         domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash,
10719                                         (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection types table");
10720                 mono_g_hash_table_insert (domain->type_hash, res, type);
10721         }
10722         mono_domain_unlock (domain);
10723         mono_loader_unlock ();
10724
10725         return TRUE;
10726 }
10727
10728 void
10729 mono_reflection_register_with_runtime (MonoReflectionType *type)
10730 {
10731         MonoError error;
10732         (void) reflection_register_with_runtime (type, &error);
10733         mono_error_set_pending_exception (&error);
10734 }
10735
10736 /**
10737  * LOCKING: Assumes the loader lock is held.
10738  */
10739 static MonoMethodSignature*
10740 parameters_to_signature (MonoImage *image, MonoArray *parameters, MonoError *error) {
10741         MonoMethodSignature *sig;
10742         int count, i;
10743
10744         mono_error_init (error);
10745
10746         count = parameters? mono_array_length (parameters): 0;
10747
10748         sig = (MonoMethodSignature *)image_g_malloc0 (image, MONO_SIZEOF_METHOD_SIGNATURE + sizeof (MonoType*) * count);
10749         sig->param_count = count;
10750         sig->sentinelpos = -1; /* FIXME */
10751         for (i = 0; i < count; ++i) {
10752                 sig->params [i] = mono_type_array_get_and_resolve (parameters, i, error);
10753                 if (!is_ok (error)) {
10754                         image_g_free (image, sig);
10755                         return NULL;
10756                 }
10757         }
10758         return sig;
10759 }
10760
10761 /**
10762  * LOCKING: Assumes the loader lock is held.
10763  */
10764 static MonoMethodSignature*
10765 ctor_builder_to_signature (MonoImage *image, MonoReflectionCtorBuilder *ctor, MonoError *error) {
10766         MonoMethodSignature *sig;
10767
10768         mono_error_init (error);
10769
10770         sig = parameters_to_signature (image, ctor->parameters, error);
10771         return_val_if_nok (error, NULL);
10772         sig->hasthis = ctor->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
10773         sig->ret = &mono_defaults.void_class->byval_arg;
10774         return sig;
10775 }
10776
10777 /**
10778  * LOCKING: Assumes the loader lock is held.
10779  */
10780 static MonoMethodSignature*
10781 method_builder_to_signature (MonoImage *image, MonoReflectionMethodBuilder *method, MonoError *error) {
10782         MonoMethodSignature *sig;
10783
10784         mono_error_init (error);
10785
10786         sig = parameters_to_signature (image, method->parameters, error);
10787         return_val_if_nok (error, NULL);
10788         sig->hasthis = method->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
10789         if (method->rtype) {
10790                 sig->ret = mono_reflection_type_get_handle ((MonoReflectionType*)method->rtype, error);
10791                 if (!is_ok (error)) {
10792                         image_g_free (image, sig);
10793                         return NULL;
10794                 }
10795         } else {
10796                 sig->ret = &mono_defaults.void_class->byval_arg;
10797         }
10798         sig->generic_param_count = method->generic_params ? mono_array_length (method->generic_params) : 0;
10799         return sig;
10800 }
10801
10802 static MonoMethodSignature*
10803 dynamic_method_to_signature (MonoReflectionDynamicMethod *method, MonoError *error) {
10804         MonoMethodSignature *sig;
10805
10806         mono_error_init (error);
10807
10808         sig = parameters_to_signature (NULL, method->parameters, error);
10809         return_val_if_nok (error, NULL);
10810         sig->hasthis = method->attrs & METHOD_ATTRIBUTE_STATIC? 0: 1;
10811         if (method->rtype) {
10812                 sig->ret = mono_reflection_type_get_handle (method->rtype, error);
10813                 if (!is_ok (error)) {
10814                         g_free (sig);
10815                         return NULL;
10816                 }
10817         } else {
10818                 sig->ret = &mono_defaults.void_class->byval_arg;
10819         }
10820         sig->generic_param_count = 0;
10821         return sig;
10822 }
10823
10824 static void
10825 get_prop_name_and_type (MonoObject *prop, char **name, MonoType **type, MonoError *error)
10826 {
10827         mono_error_init (error);
10828         MonoClass *klass = mono_object_class (prop);
10829         if (strcmp (klass->name, "PropertyBuilder") == 0) {
10830                 MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *)prop;
10831                 *name = mono_string_to_utf8 (pb->name);
10832                 *type = mono_reflection_type_get_handle ((MonoReflectionType*)pb->type, error);
10833         } else {
10834                 MonoReflectionProperty *p = (MonoReflectionProperty *)prop;
10835                 *name = g_strdup (p->property->name);
10836                 if (p->property->get)
10837                         *type = mono_method_signature (p->property->get)->ret;
10838                 else
10839                         *type = mono_method_signature (p->property->set)->params [mono_method_signature (p->property->set)->param_count - 1];
10840         }
10841 }
10842
10843 static void
10844 get_field_name_and_type (MonoObject *field, char **name, MonoType **type, MonoError *error)
10845 {
10846         mono_error_init (error);
10847         MonoClass *klass = mono_object_class (field);
10848         if (strcmp (klass->name, "FieldBuilder") == 0) {
10849                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)field;
10850                 *name = mono_string_to_utf8 (fb->name);
10851                 *type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
10852         } else {
10853                 MonoReflectionField *f = (MonoReflectionField *)field;
10854                 *name = g_strdup (mono_field_get_name (f->field));
10855                 *type = f->field->type;
10856         }
10857 }
10858
10859 #else /* DISABLE_REFLECTION_EMIT */
10860
10861 void
10862 mono_reflection_register_with_runtime (MonoReflectionType *type)
10863 {
10864         /* This is empty */
10865 }
10866
10867 static gboolean
10868 is_sre_type_builder (MonoClass *klass)
10869 {
10870         return FALSE;
10871 }
10872
10873 static gboolean
10874 is_sre_generic_instance (MonoClass *klass)
10875 {
10876         return FALSE;
10877 }
10878
10879 static void
10880 init_type_builder_generics (MonoObject *type)
10881 {
10882 }
10883
10884 #endif /* !DISABLE_REFLECTION_EMIT */
10885
10886
10887 static gboolean
10888 is_sr_mono_field (MonoClass *klass)
10889 {
10890         check_corlib_type_cached (klass, "System.Reflection", "MonoField");
10891 }
10892
10893 static gboolean
10894 is_sr_mono_property (MonoClass *klass)
10895 {
10896         check_corlib_type_cached (klass, "System.Reflection", "MonoProperty");
10897 }
10898
10899 static gboolean
10900 is_sr_mono_method (MonoClass *klass)
10901 {
10902         check_corlib_type_cached (klass, "System.Reflection", "MonoMethod");
10903 }
10904
10905 static gboolean
10906 is_sr_mono_cmethod (MonoClass *klass)
10907 {
10908         check_corlib_type_cached (klass, "System.Reflection", "MonoCMethod");
10909 }
10910
10911 static gboolean
10912 is_sr_mono_generic_method (MonoClass *klass)
10913 {
10914         check_corlib_type_cached (klass, "System.Reflection", "MonoGenericMethod");
10915 }
10916
10917 static gboolean
10918 is_sr_mono_generic_cmethod (MonoClass *klass)
10919 {
10920         check_corlib_type_cached (klass, "System.Reflection", "MonoGenericCMethod");
10921 }
10922
10923 gboolean
10924 mono_class_is_reflection_method_or_constructor (MonoClass *klass)
10925 {
10926         return is_sr_mono_method (klass) || is_sr_mono_cmethod (klass) || is_sr_mono_generic_method (klass) || is_sr_mono_generic_cmethod (klass);
10927 }
10928
10929 static gboolean
10930 is_usertype (MonoReflectionType *ref)
10931 {
10932         MonoClass *klass = mono_object_class (ref);
10933         return klass->image != mono_defaults.corlib || strcmp ("TypeDelegator", klass->name) == 0;
10934 }
10935
10936 static MonoReflectionType*
10937 mono_reflection_type_resolve_user_types (MonoReflectionType *type, MonoError *error)
10938 {
10939         mono_error_init (error);
10940         if (!type || type->type)
10941                 return type;
10942
10943         if (is_usertype (type)) {
10944                 type = mono_reflection_type_get_underlying_system_type (type, error);
10945                 return_val_if_nok (error, NULL);
10946                 if (is_usertype (type)) {
10947                         mono_error_set_not_supported (error, "User defined subclasses of System.Type are not yet supported22");
10948                         return NULL;
10949                 }
10950         }
10951
10952         return type;
10953 }
10954 /**
10955  * encode_cattr_value:
10956  * Encode a value in a custom attribute stream of bytes.
10957  * The value to encode is either supplied as an object in argument val
10958  * (valuetypes are boxed), or as a pointer to the data in the
10959  * argument argval.
10960  * @type represents the type of the value
10961  * @buffer is the start of the buffer
10962  * @p the current position in the buffer
10963  * @buflen contains the size of the buffer and is used to return the new buffer size
10964  * if this needs to be realloced.
10965  * @retbuffer and @retp return the start and the position of the buffer
10966  * @error set on error.
10967  */
10968 static void
10969 encode_cattr_value (MonoAssembly *assembly, char *buffer, char *p, char **retbuffer, char **retp, guint32 *buflen, MonoType *type, MonoObject *arg, char *argval, MonoError *error)
10970 {
10971         MonoTypeEnum simple_type;
10972
10973         mono_error_init (error);
10974         if ((p-buffer) + 10 >= *buflen) {
10975                 char *newbuf;
10976                 *buflen *= 2;
10977                 newbuf = (char *)g_realloc (buffer, *buflen);
10978                 p = newbuf + (p-buffer);
10979                 buffer = newbuf;
10980         }
10981         if (!argval)
10982                 argval = ((char*)arg + sizeof (MonoObject));
10983         simple_type = type->type;
10984 handle_enum:
10985         switch (simple_type) {
10986         case MONO_TYPE_BOOLEAN:
10987         case MONO_TYPE_U1:
10988         case MONO_TYPE_I1:
10989                 *p++ = *argval;
10990                 break;
10991         case MONO_TYPE_CHAR:
10992         case MONO_TYPE_U2:
10993         case MONO_TYPE_I2:
10994                 swap_with_size (p, argval, 2, 1);
10995                 p += 2;
10996                 break;
10997         case MONO_TYPE_U4:
10998         case MONO_TYPE_I4:
10999         case MONO_TYPE_R4:
11000                 swap_with_size (p, argval, 4, 1);
11001                 p += 4;
11002                 break;
11003         case MONO_TYPE_R8:
11004                 swap_with_size (p, argval, 8, 1);
11005                 p += 8;
11006                 break;
11007         case MONO_TYPE_U8:
11008         case MONO_TYPE_I8:
11009                 swap_with_size (p, argval, 8, 1);
11010                 p += 8;
11011                 break;
11012         case MONO_TYPE_VALUETYPE:
11013                 if (type->data.klass->enumtype) {
11014                         simple_type = mono_class_enum_basetype (type->data.klass)->type;
11015                         goto handle_enum;
11016                 } else {
11017                         g_warning ("generic valutype %s not handled in custom attr value decoding", type->data.klass->name);
11018                 }
11019                 break;
11020         case MONO_TYPE_STRING: {
11021                 char *str;
11022                 guint32 slen;
11023                 if (!arg) {
11024                         *p++ = 0xFF;
11025                         break;
11026                 }
11027                 str = mono_string_to_utf8 ((MonoString*)arg);
11028                 slen = strlen (str);
11029                 if ((p-buffer) + 10 + slen >= *buflen) {
11030                         char *newbuf;
11031                         *buflen *= 2;
11032                         *buflen += slen;
11033                         newbuf = (char *)g_realloc (buffer, *buflen);
11034                         p = newbuf + (p-buffer);
11035                         buffer = newbuf;
11036                 }
11037                 mono_metadata_encode_value (slen, p, &p);
11038                 memcpy (p, str, slen);
11039                 p += slen;
11040                 g_free (str);
11041                 break;
11042         }
11043         case MONO_TYPE_CLASS: {
11044                 char *str;
11045                 guint32 slen;
11046                 MonoType *arg_type;
11047                 if (!arg) {
11048                         *p++ = 0xFF;
11049                         break;
11050                 }
11051 handle_type:
11052                 arg_type = mono_reflection_type_get_handle ((MonoReflectionType*)arg, error);
11053                 return_if_nok (error);
11054
11055                 str = type_get_qualified_name (arg_type, NULL);
11056                 slen = strlen (str);
11057                 if ((p-buffer) + 10 + slen >= *buflen) {
11058                         char *newbuf;
11059                         *buflen *= 2;
11060                         *buflen += slen;
11061                         newbuf = (char *)g_realloc (buffer, *buflen);
11062                         p = newbuf + (p-buffer);
11063                         buffer = newbuf;
11064                 }
11065                 mono_metadata_encode_value (slen, p, &p);
11066                 memcpy (p, str, slen);
11067                 p += slen;
11068                 g_free (str);
11069                 break;
11070         }
11071         case MONO_TYPE_SZARRAY: {
11072                 int len, i;
11073                 MonoClass *eclass, *arg_eclass;
11074
11075                 if (!arg) {
11076                         *p++ = 0xff; *p++ = 0xff; *p++ = 0xff; *p++ = 0xff;
11077                         break;
11078                 }
11079                 len = mono_array_length ((MonoArray*)arg);
11080                 *p++ = len & 0xff;
11081                 *p++ = (len >> 8) & 0xff;
11082                 *p++ = (len >> 16) & 0xff;
11083                 *p++ = (len >> 24) & 0xff;
11084                 *retp = p;
11085                 *retbuffer = buffer;
11086                 eclass = type->data.klass;
11087                 arg_eclass = mono_object_class (arg)->element_class;
11088
11089                 if (!eclass) {
11090                         /* Happens when we are called from the MONO_TYPE_OBJECT case below */
11091                         eclass = mono_defaults.object_class;
11092                 }
11093                 if (eclass == mono_defaults.object_class && arg_eclass->valuetype) {
11094                         char *elptr = mono_array_addr ((MonoArray*)arg, char, 0);
11095                         int elsize = mono_class_array_element_size (arg_eclass);
11096                         for (i = 0; i < len; ++i) {
11097                                 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &arg_eclass->byval_arg, NULL, elptr, error);
11098                                 return_if_nok (error);
11099                                 elptr += elsize;
11100                         }
11101                 } else if (eclass->valuetype && arg_eclass->valuetype) {
11102                         char *elptr = mono_array_addr ((MonoArray*)arg, char, 0);
11103                         int elsize = mono_class_array_element_size (eclass);
11104                         for (i = 0; i < len; ++i) {
11105                                 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &eclass->byval_arg, NULL, elptr, error);
11106                                 return_if_nok (error);
11107                                 elptr += elsize;
11108                         }
11109                 } else {
11110                         for (i = 0; i < len; ++i) {
11111                                 encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &eclass->byval_arg, mono_array_get ((MonoArray*)arg, MonoObject*, i), NULL, error);
11112                                 return_if_nok (error);
11113                         }
11114                 }
11115                 break;
11116         }
11117         case MONO_TYPE_OBJECT: {
11118                 MonoClass *klass;
11119                 char *str;
11120                 guint32 slen;
11121
11122                 /*
11123                  * The parameter type is 'object' but the type of the actual
11124                  * argument is not. So we have to add type information to the blob
11125                  * too. This is completely undocumented in the spec.
11126                  */
11127
11128                 if (arg == NULL) {
11129                         *p++ = MONO_TYPE_STRING;        // It's same hack as MS uses
11130                         *p++ = 0xFF;
11131                         break;
11132                 }
11133
11134                 klass = mono_object_class (arg);
11135
11136                 if (mono_object_isinst (arg, mono_defaults.systemtype_class)) {
11137                         *p++ = 0x50;
11138                         goto handle_type;
11139                 } else if (klass->enumtype) {
11140                         *p++ = 0x55;
11141                 } else if (klass == mono_defaults.string_class) {
11142                         simple_type = MONO_TYPE_STRING;
11143                         *p++ = 0x0E;
11144                         goto handle_enum;
11145                 } else if (klass->rank == 1) {
11146                         *p++ = 0x1D;
11147                         if (klass->element_class->byval_arg.type == MONO_TYPE_OBJECT)
11148                                 /* See Partition II, Appendix B3 */
11149                                 *p++ = 0x51;
11150                         else
11151                                 *p++ = klass->element_class->byval_arg.type;
11152                         encode_cattr_value (assembly, buffer, p, &buffer, &p, buflen, &klass->byval_arg, arg, NULL, error);
11153                         return_if_nok (error);
11154                         break;
11155                 } else if (klass->byval_arg.type >= MONO_TYPE_BOOLEAN && klass->byval_arg.type <= MONO_TYPE_R8) {
11156                         *p++ = simple_type = klass->byval_arg.type;
11157                         goto handle_enum;
11158                 } else {
11159                         g_error ("unhandled type in custom attr");
11160                 }
11161                 str = type_get_qualified_name (mono_class_get_type(klass), NULL);
11162                 slen = strlen (str);
11163                 if ((p-buffer) + 10 + slen >= *buflen) {
11164                         char *newbuf;
11165                         *buflen *= 2;
11166                         *buflen += slen;
11167                         newbuf = (char *)g_realloc (buffer, *buflen);
11168                         p = newbuf + (p-buffer);
11169                         buffer = newbuf;
11170                 }
11171                 mono_metadata_encode_value (slen, p, &p);
11172                 memcpy (p, str, slen);
11173                 p += slen;
11174                 g_free (str);
11175                 simple_type = mono_class_enum_basetype (klass)->type;
11176                 goto handle_enum;
11177         }
11178         default:
11179                 g_error ("type 0x%02x not yet supported in custom attr encoder", simple_type);
11180         }
11181         *retp = p;
11182         *retbuffer = buffer;
11183 }
11184
11185 static void
11186 encode_field_or_prop_type (MonoType *type, char *p, char **retp)
11187 {
11188         if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
11189                 char *str = type_get_qualified_name (type, NULL);
11190                 int slen = strlen (str);
11191
11192                 *p++ = 0x55;
11193                 /*
11194                  * This seems to be optional...
11195                  * *p++ = 0x80;
11196                  */
11197                 mono_metadata_encode_value (slen, p, &p);
11198                 memcpy (p, str, slen);
11199                 p += slen;
11200                 g_free (str);
11201         } else if (type->type == MONO_TYPE_OBJECT) {
11202                 *p++ = 0x51;
11203         } else if (type->type == MONO_TYPE_CLASS) {
11204                 /* it should be a type: encode_cattr_value () has the check */
11205                 *p++ = 0x50;
11206         } else {
11207                 mono_metadata_encode_value (type->type, p, &p);
11208                 if (type->type == MONO_TYPE_SZARRAY)
11209                         /* See the examples in Partition VI, Annex B */
11210                         encode_field_or_prop_type (&type->data.klass->byval_arg, p, &p);
11211         }
11212
11213         *retp = p;
11214 }
11215
11216 #ifndef DISABLE_REFLECTION_EMIT
11217 static void
11218 encode_named_val (MonoReflectionAssembly *assembly, char *buffer, char *p, char **retbuffer, char **retp, guint32 *buflen, MonoType *type, char *name, MonoObject *value, MonoError *error)
11219 {
11220         int len;
11221
11222         mono_error_init (error);
11223
11224         /* Preallocate a large enough buffer */
11225         if (type->type == MONO_TYPE_VALUETYPE && type->data.klass->enumtype) {
11226                 char *str = type_get_qualified_name (type, NULL);
11227                 len = strlen (str);
11228                 g_free (str);
11229         } else if (type->type == MONO_TYPE_SZARRAY && type->data.klass->enumtype) {
11230                 char *str = type_get_qualified_name (&type->data.klass->byval_arg, NULL);
11231                 len = strlen (str);
11232                 g_free (str);
11233         } else {
11234                 len = 0;
11235         }
11236         len += strlen (name);
11237
11238         if ((p-buffer) + 20 + len >= *buflen) {
11239                 char *newbuf;
11240                 *buflen *= 2;
11241                 *buflen += len;
11242                 newbuf = (char *)g_realloc (buffer, *buflen);
11243                 p = newbuf + (p-buffer);
11244                 buffer = newbuf;
11245         }
11246
11247         encode_field_or_prop_type (type, p, &p);
11248
11249         len = strlen (name);
11250         mono_metadata_encode_value (len, p, &p);
11251         memcpy (p, name, len);
11252         p += len;
11253         encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, buflen, type, value, NULL, error);
11254         return_if_nok (error);
11255         *retp = p;
11256         *retbuffer = buffer;
11257 }
11258
11259 /**
11260  * mono_reflection_get_custom_attrs_blob:
11261  * @ctor: custom attribute constructor
11262  * @ctorArgs: arguments o the constructor
11263  * @properties:
11264  * @propValues:
11265  * @fields:
11266  * @fieldValues:
11267  *
11268  * Creates the blob of data that needs to be saved in the metadata and that represents
11269  * the custom attributed described by @ctor, @ctorArgs etc.
11270  * Returns: a Byte array representing the blob of data.
11271  */
11272 MonoArray*
11273 mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
11274 {
11275         MonoError error;
11276         MonoArray *result = mono_reflection_get_custom_attrs_blob_checked (assembly, ctor, ctorArgs, properties, propValues, fields, fieldValues, &error);
11277         mono_error_cleanup (&error); /* FIXME better API that doesn't swallow the error */
11278         return result;
11279 }
11280
11281 /**
11282  * mono_reflection_get_custom_attrs_blob_checked:
11283  * @ctor: custom attribute constructor
11284  * @ctorArgs: arguments o the constructor
11285  * @properties:
11286  * @propValues:
11287  * @fields:
11288  * @fieldValues:
11289  * @error: set on error
11290  *
11291  * Creates the blob of data that needs to be saved in the metadata and that represents
11292  * the custom attributed described by @ctor, @ctorArgs etc.
11293  * Returns: a Byte array representing the blob of data.  On failure returns NULL and sets @error.
11294  */
11295 MonoArray*
11296 mono_reflection_get_custom_attrs_blob_checked (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues, MonoError *error)
11297 {
11298         MonoArray *result = NULL;
11299         MonoMethodSignature *sig;
11300         MonoObject *arg;
11301         char *buffer, *p;
11302         guint32 buflen, i;
11303
11304         mono_error_init (error);
11305
11306         if (strcmp (ctor->vtable->klass->name, "MonoCMethod")) {
11307                 /* sig is freed later so allocate it in the heap */
11308                 sig = ctor_builder_to_signature (NULL, (MonoReflectionCtorBuilder*)ctor, error);
11309                 if (!is_ok (error)) {
11310                         g_free (sig);
11311                         return NULL;
11312                 }
11313         } else {
11314                 sig = mono_method_signature (((MonoReflectionMethod*)ctor)->method);
11315         }
11316
11317         g_assert (mono_array_length (ctorArgs) == sig->param_count);
11318         buflen = 256;
11319         p = buffer = (char *)g_malloc (buflen);
11320         /* write the prolog */
11321         *p++ = 1;
11322         *p++ = 0;
11323         for (i = 0; i < sig->param_count; ++i) {
11324                 arg = mono_array_get (ctorArgs, MonoObject*, i);
11325                 encode_cattr_value (assembly->assembly, buffer, p, &buffer, &p, &buflen, sig->params [i], arg, NULL, error);
11326                 if (!is_ok (error)) goto leave;
11327         }
11328         i = 0;
11329         if (properties)
11330                 i += mono_array_length (properties);
11331         if (fields)
11332                 i += mono_array_length (fields);
11333         *p++ = i & 0xff;
11334         *p++ = (i >> 8) & 0xff;
11335         if (properties) {
11336                 MonoObject *prop;
11337                 for (i = 0; i < mono_array_length (properties); ++i) {
11338                         MonoType *ptype;
11339                         char *pname;
11340
11341                         prop = (MonoObject *)mono_array_get (properties, gpointer, i);
11342                         get_prop_name_and_type (prop, &pname, &ptype, error);
11343                         if (!is_ok (error)) goto leave;
11344                         *p++ = 0x54; /* PROPERTY signature */
11345                         encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ptype, pname, (MonoObject*)mono_array_get (propValues, gpointer, i), error);
11346                         g_free (pname);
11347                         if (!is_ok (error)) goto leave;
11348                 }
11349         }
11350
11351         if (fields) {
11352                 MonoObject *field;
11353                 for (i = 0; i < mono_array_length (fields); ++i) {
11354                         MonoType *ftype;
11355                         char *fname;
11356
11357                         field = (MonoObject *)mono_array_get (fields, gpointer, i);
11358                         get_field_name_and_type (field, &fname, &ftype, error);
11359                         if (!is_ok (error)) goto leave;
11360                         *p++ = 0x53; /* FIELD signature */
11361                         encode_named_val (assembly, buffer, p, &buffer, &p, &buflen, ftype, fname, (MonoObject*)mono_array_get (fieldValues, gpointer, i), error);
11362                         g_free (fname);
11363                         if (!is_ok (error)) goto leave;
11364                 }
11365         }
11366
11367         g_assert (p - buffer <= buflen);
11368         buflen = p - buffer;
11369         result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
11370         p = mono_array_addr (result, char, 0);
11371         memcpy (p, buffer, buflen);
11372 leave:
11373         g_free (buffer);
11374         if (strcmp (ctor->vtable->klass->name, "MonoCMethod"))
11375                 g_free (sig);
11376         return result;
11377 }
11378
11379 /**
11380  * reflection_setup_internal_class:
11381  * @tb: a TypeBuilder object
11382  * @error: set on error
11383  *
11384  * Creates a MonoClass that represents the TypeBuilder.
11385  * This is a trick that lets us simplify a lot of reflection code
11386  * (and will allow us to support Build and Run assemblies easier).
11387  *
11388  * Returns TRUE on success. On failure, returns FALSE and sets @error.
11389  */
11390 static gboolean
11391 reflection_setup_internal_class (MonoReflectionTypeBuilder *tb, MonoError *error)
11392 {
11393         MonoClass *klass, *parent;
11394
11395         mono_error_init (error);
11396         RESOLVE_TYPE (tb->parent, error);
11397         return_val_if_nok (error, FALSE);
11398
11399         mono_loader_lock ();
11400
11401         if (tb->parent) {
11402                 MonoType *parent_type = mono_reflection_type_get_handle ((MonoReflectionType*)tb->parent, error);
11403                 if (!is_ok (error)) {
11404                         mono_loader_unlock ();
11405                         return FALSE;
11406                 }
11407                 /* check so we can compile corlib correctly */
11408                 if (strcmp (mono_object_class (tb->parent)->name, "TypeBuilder") == 0) {
11409                         /* mono_class_setup_mono_type () guaranteess type->data.klass is valid */
11410                         parent = parent_type->data.klass;
11411                 } else {
11412                         parent = mono_class_from_mono_type (parent_type);
11413                 }
11414         } else {
11415                 parent = NULL;
11416         }
11417
11418         /* the type has already being created: it means we just have to change the parent */
11419         if (tb->type.type) {
11420                 klass = mono_class_from_mono_type (tb->type.type);
11421                 klass->parent = NULL;
11422                 /* fool mono_class_setup_parent */
11423                 klass->supertypes = NULL;
11424                 mono_class_setup_parent (klass, parent);
11425                 mono_class_setup_mono_type (klass);
11426                 mono_loader_unlock ();
11427                 return TRUE;
11428         }
11429
11430         klass = (MonoClass *)mono_image_alloc0 (&tb->module->dynamic_image->image, sizeof (MonoClass));
11431
11432         klass->image = &tb->module->dynamic_image->image;
11433
11434         klass->inited = 1; /* we lie to the runtime */
11435         klass->name = mono_string_to_utf8_image (klass->image, tb->name, error);
11436         if (!is_ok (error))
11437                 goto failure;
11438         klass->name_space = mono_string_to_utf8_image (klass->image, tb->nspace, error);
11439         if (!is_ok (error))
11440                 goto failure;
11441         klass->type_token = MONO_TOKEN_TYPE_DEF | tb->table_idx;
11442         klass->flags = tb->attrs;
11443
11444         mono_profiler_class_event (klass, MONO_PROFILE_START_LOAD);
11445
11446         klass->element_class = klass;
11447
11448         if (mono_class_get_ref_info (klass) == NULL) {
11449
11450                 mono_class_set_ref_info (klass, tb);
11451
11452                 /* Put into cache so mono_class_get_checked () will find it.
11453                 Skip nested types as those should not be available on the global scope. */
11454                 if (!tb->nesting_type)
11455                         mono_image_add_to_name_cache (klass->image, klass->name_space, klass->name, tb->table_idx);
11456
11457                 /*
11458                 We must register all types as we cannot rely on the name_cache hashtable since we find the class
11459                 by performing a mono_class_get which does the full resolution.
11460
11461                 Working around this semantics would require us to write a lot of code for no clear advantage.
11462                 */
11463                 mono_image_append_class_to_reflection_info_set (klass);
11464         } else {
11465                 g_assert (mono_class_get_ref_info (klass) == tb);
11466         }
11467
11468         register_dyn_token (tb->module->dynamic_image, MONO_TOKEN_TYPE_DEF | tb->table_idx, (MonoObject*)tb);
11469
11470         if (parent != NULL) {
11471                 mono_class_setup_parent (klass, parent);
11472         } else if (strcmp (klass->name, "Object") == 0 && strcmp (klass->name_space, "System") == 0) {
11473                 const char *old_n = klass->name;
11474                 /* trick to get relative numbering right when compiling corlib */
11475                 klass->name = "BuildingObject";
11476                 mono_class_setup_parent (klass, mono_defaults.object_class);
11477                 klass->name = old_n;
11478         }
11479
11480         if ((!strcmp (klass->name, "ValueType") && !strcmp (klass->name_space, "System")) ||
11481                         (!strcmp (klass->name, "Object") && !strcmp (klass->name_space, "System")) ||
11482                         (!strcmp (klass->name, "Enum") && !strcmp (klass->name_space, "System"))) {
11483                 klass->instance_size = sizeof (MonoObject);
11484                 klass->size_inited = 1;
11485                 mono_class_setup_vtable_general (klass, NULL, 0, NULL);
11486         }
11487
11488         mono_class_setup_mono_type (klass);
11489
11490         mono_class_setup_supertypes (klass);
11491
11492         /*
11493          * FIXME: handle interfaces.
11494          */
11495
11496         tb->type.type = &klass->byval_arg;
11497
11498         if (tb->nesting_type) {
11499                 g_assert (tb->nesting_type->type);
11500                 MonoType *nesting_type = mono_reflection_type_get_handle (tb->nesting_type, error);
11501                 if (!is_ok (error)) goto failure;
11502                 klass->nested_in = mono_class_from_mono_type (nesting_type);
11503         }
11504
11505         /*g_print ("setup %s as %s (%p)\n", klass->name, ((MonoObject*)tb)->vtable->klass->name, tb);*/
11506
11507         mono_profiler_class_loaded (klass, MONO_PROFILE_OK);
11508
11509         mono_loader_unlock ();
11510         return TRUE;
11511
11512 failure:
11513         mono_loader_unlock ();
11514         return FALSE;
11515 }
11516
11517 /**
11518  * mono_reflection_setup_internal_class:
11519  * @tb: a TypeBuilder object
11520  *
11521  * (icall)
11522  * Creates a MonoClass that represents the TypeBuilder.
11523  * This is a trick that lets us simplify a lot of reflection code
11524  * (and will allow us to support Build and Run assemblies easier).
11525  *
11526  */
11527 void
11528 mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb)
11529 {
11530         MonoError error;
11531         (void) reflection_setup_internal_class (tb, &error);
11532         mono_error_set_pending_exception (&error);
11533 }
11534
11535 /*
11536  * mono_reflection_setup_generic_class:
11537  * @tb: a TypeBuilder object
11538  *
11539  * Setup the generic class before adding the first generic parameter.
11540  */
11541 void
11542 mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb)
11543 {
11544 }
11545
11546 /*
11547  * mono_reflection_create_generic_class:
11548  * @tb: a TypeBuilder object
11549  *
11550  * Creates the generic class after all generic parameters have been added.
11551  */
11552 void
11553 mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb)
11554 {
11555         MonoError error;
11556         MonoClass *klass;
11557         int count, i;
11558
11559         klass = mono_class_from_mono_type (tb->type.type);
11560
11561         count = tb->generic_params ? mono_array_length (tb->generic_params) : 0;
11562
11563         if (klass->generic_container || (count == 0))
11564                 return;
11565
11566         g_assert (tb->generic_container && (tb->generic_container->owner.klass == klass));
11567
11568         klass->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
11569
11570         klass->generic_container->owner.klass = klass;
11571         klass->generic_container->type_argc = count;
11572         klass->generic_container->type_params = (MonoGenericParamFull *)mono_image_alloc0 (klass->image, sizeof (MonoGenericParamFull) * count);
11573
11574         klass->is_generic = 1;
11575
11576         for (i = 0; i < count; i++) {
11577                 MonoReflectionGenericParam *gparam = (MonoReflectionGenericParam *)mono_array_get (tb->generic_params, gpointer, i);
11578                 MonoType *param_type = mono_reflection_type_get_handle ((MonoReflectionType*)gparam, &error);
11579                 mono_error_raise_exception (&error); /* FIXME don't raise here */
11580                 MonoGenericParamFull *param = (MonoGenericParamFull *) param_type->data.generic_param;
11581                 klass->generic_container->type_params [i] = *param;
11582                 /*Make sure we are a diferent type instance */
11583                 klass->generic_container->type_params [i].param.owner = klass->generic_container;
11584                 klass->generic_container->type_params [i].info.pklass = NULL;
11585                 klass->generic_container->type_params [i].info.flags = gparam->attrs;
11586
11587                 g_assert (klass->generic_container->type_params [i].param.owner);
11588         }
11589
11590         klass->generic_container->context.class_inst = mono_get_shared_generic_inst (klass->generic_container);
11591 }
11592
11593 /**
11594  * reflection_create_internal_class:
11595  * @tb: a TypeBuilder object
11596  * @error: set on error
11597  *
11598  * Actually create the MonoClass that is associated with the TypeBuilder.
11599  * On success returns TRUE, on failure returns FALSE and sets @error.
11600  *
11601  */
11602 static gboolean
11603 reflection_create_internal_class (MonoReflectionTypeBuilder *tb, MonoError *error)
11604 {
11605
11606         MonoClass *klass;
11607
11608         mono_error_init (error);
11609         klass = mono_class_from_mono_type (tb->type.type);
11610
11611         mono_loader_lock ();
11612         if (klass->enumtype && mono_class_enum_basetype (klass) == NULL) {
11613                 MonoReflectionFieldBuilder *fb;
11614                 MonoClass *ec;
11615                 MonoType *enum_basetype;
11616
11617                 g_assert (tb->fields != NULL);
11618                 g_assert (mono_array_length (tb->fields) >= 1);
11619
11620                 fb = mono_array_get (tb->fields, MonoReflectionFieldBuilder*, 0);
11621
11622                 MonoType *field_type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
11623                 if (!is_ok (error)) {
11624                         mono_loader_unlock ();
11625                         return FALSE;
11626                 }
11627                 if (!mono_type_is_valid_enum_basetype (field_type)) {
11628                         mono_loader_unlock ();
11629                         return TRUE;
11630                 }
11631
11632                 enum_basetype = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
11633                 if (!is_ok (error)) {
11634                         mono_loader_unlock ();
11635                         return FALSE;
11636                 }
11637                 klass->element_class = mono_class_from_mono_type (enum_basetype);
11638                 if (!klass->element_class)
11639                         klass->element_class = mono_class_from_mono_type (enum_basetype);
11640
11641                 /*
11642                  * get the element_class from the current corlib.
11643                  */
11644                 ec = default_class_from_mono_type (enum_basetype);
11645                 klass->instance_size = ec->instance_size;
11646                 klass->size_inited = 1;
11647                 /*
11648                  * this is almost safe to do with enums and it's needed to be able
11649                  * to create objects of the enum type (for use in SetConstant).
11650                  */
11651                 /* FIXME: Does this mean enums can't have method overrides ? */
11652                 mono_class_setup_vtable_general (klass, NULL, 0, NULL);
11653         }
11654         mono_loader_unlock ();
11655         return TRUE;
11656 }
11657
11658 /**
11659  * mono_reflection_create_internal_class:
11660  * @tb: a TypeBuilder object
11661  *
11662  * (icall)
11663  * Actually create the MonoClass that is associated with the TypeBuilder.
11664  */
11665 void
11666 mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb)
11667 {
11668         MonoError error;
11669         (void) reflection_create_internal_class (tb, &error);
11670         mono_error_set_pending_exception (&error);
11671 }
11672
11673 static MonoMarshalSpec*
11674 mono_marshal_spec_from_builder (MonoImage *image, MonoAssembly *assembly,
11675                                 MonoReflectionMarshal *minfo, MonoError *error)
11676 {
11677         MonoMarshalSpec *res;
11678
11679         mono_error_init (error);
11680
11681         res = image_g_new0 (image, MonoMarshalSpec, 1);
11682         res->native = (MonoMarshalNative)minfo->type;
11683
11684         switch (minfo->type) {
11685         case MONO_NATIVE_LPARRAY:
11686                 res->data.array_data.elem_type = (MonoMarshalNative)minfo->eltype;
11687                 if (minfo->has_size) {
11688                         res->data.array_data.param_num = minfo->param_num;
11689                         res->data.array_data.num_elem = minfo->count;
11690                         res->data.array_data.elem_mult = minfo->param_num == -1 ? 0 : 1;
11691                 }
11692                 else {
11693                         res->data.array_data.param_num = -1;
11694                         res->data.array_data.num_elem = -1;
11695                         res->data.array_data.elem_mult = -1;
11696                 }
11697                 break;
11698
11699         case MONO_NATIVE_BYVALTSTR:
11700         case MONO_NATIVE_BYVALARRAY:
11701                 res->data.array_data.num_elem = minfo->count;
11702                 break;
11703
11704         case MONO_NATIVE_CUSTOM:
11705                 if (minfo->marshaltyperef) {
11706                         MonoType *marshaltyperef = mono_reflection_type_get_handle ((MonoReflectionType*)minfo->marshaltyperef, error);
11707                         if (!is_ok (error)) {
11708                                 image_g_free (image, res);
11709                                 return NULL;
11710                         }
11711                         res->data.custom_data.custom_name =
11712                                 type_get_fully_qualified_name (marshaltyperef);
11713                 }
11714                 if (minfo->mcookie)
11715                         res->data.custom_data.cookie = mono_string_to_utf8 (minfo->mcookie);
11716                 break;
11717
11718         default:
11719                 break;
11720         }
11721
11722         return res;
11723 }
11724 #endif /* !DISABLE_REFLECTION_EMIT */
11725
11726 MonoReflectionMarshalAsAttribute*
11727 mono_reflection_marshal_as_attribute_from_marshal_spec (MonoDomain *domain, MonoClass *klass,
11728                                                         MonoMarshalSpec *spec, MonoError *error)
11729 {
11730         MonoReflectionType *rt;
11731         MonoReflectionMarshalAsAttribute *minfo;
11732         MonoType *mtype;
11733
11734         mono_error_init (error);
11735
11736         minfo = (MonoReflectionMarshalAsAttribute*)mono_object_new_checked (domain, mono_class_get_marshal_as_attribute_class (), error);
11737         if (!minfo)
11738                 return NULL;
11739         minfo->utype = spec->native;
11740
11741         switch (minfo->utype) {
11742         case MONO_NATIVE_LPARRAY:
11743                 minfo->array_subtype = spec->data.array_data.elem_type;
11744                 minfo->size_const = spec->data.array_data.num_elem;
11745                 if (spec->data.array_data.param_num != -1)
11746                         minfo->size_param_index = spec->data.array_data.param_num;
11747                 break;
11748
11749         case MONO_NATIVE_BYVALTSTR:
11750         case MONO_NATIVE_BYVALARRAY:
11751                 minfo->size_const = spec->data.array_data.num_elem;
11752                 break;
11753
11754         case MONO_NATIVE_CUSTOM:
11755                 if (spec->data.custom_data.custom_name) {
11756                         mtype = mono_reflection_type_from_name_checked (spec->data.custom_data.custom_name, klass->image, error);
11757                         return_val_if_nok  (error, NULL);
11758
11759                         if (mtype) {
11760                                 rt = mono_type_get_object_checked (domain, mtype, error);
11761                                 if (!rt)
11762                                         return NULL;
11763
11764                                 MONO_OBJECT_SETREF (minfo, marshal_type_ref, rt);
11765                         }
11766
11767                         MONO_OBJECT_SETREF (minfo, marshal_type, mono_string_new (domain, spec->data.custom_data.custom_name));
11768                 }
11769                 if (spec->data.custom_data.cookie)
11770                         MONO_OBJECT_SETREF (minfo, marshal_cookie, mono_string_new (domain, spec->data.custom_data.cookie));
11771                 break;
11772
11773         default:
11774                 break;
11775         }
11776
11777         return minfo;
11778 }
11779
11780 #ifndef DISABLE_REFLECTION_EMIT
11781 static MonoMethod*
11782 reflection_methodbuilder_to_mono_method (MonoClass *klass,
11783                                          ReflectionMethodBuilder *rmb,
11784                                          MonoMethodSignature *sig)
11785 {
11786         MonoError error;
11787         MonoMethod *m;
11788         MonoMethodWrapper *wrapperm;
11789         MonoMarshalSpec **specs;
11790         MonoReflectionMethodAux *method_aux;
11791         MonoImage *image;
11792         gboolean dynamic;
11793         int i;
11794
11795         mono_error_init (&error);
11796         /*
11797          * Methods created using a MethodBuilder should have their memory allocated
11798          * inside the image mempool, while dynamic methods should have their memory
11799          * malloc'd.
11800          */
11801         dynamic = rmb->refs != NULL;
11802         image = dynamic ? NULL : klass->image;
11803
11804         if (!dynamic)
11805                 g_assert (!klass->generic_class);
11806
11807         mono_loader_lock ();
11808
11809         if ((rmb->attrs & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
11810                         (rmb->iattrs & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
11811                 m = (MonoMethod *)image_g_new0 (image, MonoMethodPInvoke, 1);
11812         else
11813                 m = (MonoMethod *)image_g_new0 (image, MonoMethodWrapper, 1);
11814
11815         wrapperm = (MonoMethodWrapper*)m;
11816
11817         m->dynamic = dynamic;
11818         m->slot = -1;
11819         m->flags = rmb->attrs;
11820         m->iflags = rmb->iattrs;
11821         m->name = mono_string_to_utf8_image_ignore (image, rmb->name);
11822         m->klass = klass;
11823         m->signature = sig;
11824         m->sre_method = TRUE;
11825         m->skip_visibility = rmb->skip_visibility;
11826         if (rmb->table_idx)
11827                 m->token = MONO_TOKEN_METHOD_DEF | (*rmb->table_idx);
11828
11829         if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
11830                 if (klass == mono_defaults.string_class && !strcmp (m->name, ".ctor"))
11831                         m->string_ctor = 1;
11832
11833                 m->signature->pinvoke = 1;
11834         } else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
11835                 m->signature->pinvoke = 1;
11836
11837                 method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
11838
11839                 method_aux->dllentry = rmb->dllentry ? mono_string_to_utf8_image (image, rmb->dllentry, &error) : image_strdup (image, m->name);
11840                 g_assert (mono_error_ok (&error));
11841                 method_aux->dll = mono_string_to_utf8_image (image, rmb->dll, &error);
11842                 g_assert (mono_error_ok (&error));
11843
11844                 ((MonoMethodPInvoke*)m)->piflags = (rmb->native_cc << 8) | (rmb->charset ? (rmb->charset - 1) * 2 : 0) | rmb->extra_flags;
11845
11846                 if (image_is_dynamic (klass->image))
11847                         g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
11848
11849                 mono_loader_unlock ();
11850
11851                 return m;
11852         } else if (!(m->flags & METHOD_ATTRIBUTE_ABSTRACT) &&
11853                            !(m->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME)) {
11854                 MonoMethodHeader *header;
11855                 guint32 code_size;
11856                 gint32 max_stack, i;
11857                 gint32 num_locals = 0;
11858                 gint32 num_clauses = 0;
11859                 guint8 *code;
11860
11861                 if (rmb->ilgen) {
11862                         code = mono_array_addr (rmb->ilgen->code, guint8, 0);
11863                         code_size = rmb->ilgen->code_len;
11864                         max_stack = rmb->ilgen->max_stack;
11865                         num_locals = rmb->ilgen->locals ? mono_array_length (rmb->ilgen->locals) : 0;
11866                         if (rmb->ilgen->ex_handlers)
11867                                 num_clauses = method_count_clauses (rmb->ilgen);
11868                 } else {
11869                         if (rmb->code) {
11870                                 code = mono_array_addr (rmb->code, guint8, 0);
11871                                 code_size = mono_array_length (rmb->code);
11872                                 /* we probably need to run a verifier on the code... */
11873                                 max_stack = 8;
11874                         }
11875                         else {
11876                                 code = NULL;
11877                                 code_size = 0;
11878                                 max_stack = 8;
11879                         }
11880                 }
11881
11882                 header = (MonoMethodHeader *)image_g_malloc0 (image, MONO_SIZEOF_METHOD_HEADER + num_locals * sizeof (MonoType*));
11883                 header->code_size = code_size;
11884                 header->code = (const unsigned char *)image_g_malloc (image, code_size);
11885                 memcpy ((char*)header->code, code, code_size);
11886                 header->max_stack = max_stack;
11887                 header->init_locals = rmb->init_locals;
11888                 header->num_locals = num_locals;
11889
11890                 for (i = 0; i < num_locals; ++i) {
11891                         MonoReflectionLocalBuilder *lb =
11892                                 mono_array_get (rmb->ilgen->locals, MonoReflectionLocalBuilder*, i);
11893
11894                         header->locals [i] = image_g_new0 (image, MonoType, 1);
11895                         MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)lb->type, &error);
11896                         mono_error_assert_ok (&error);
11897                         memcpy (header->locals [i], type, MONO_SIZEOF_TYPE);
11898                 }
11899
11900                 header->num_clauses = num_clauses;
11901                 if (num_clauses) {
11902                         header->clauses = method_encode_clauses (image, (MonoDynamicImage*)klass->image,
11903                                                                  rmb->ilgen, num_clauses, &error);
11904                         mono_error_assert_ok (&error);
11905                 }
11906
11907                 wrapperm->header = header;
11908         }
11909
11910         if (rmb->generic_params) {
11911                 int count = mono_array_length (rmb->generic_params);
11912                 MonoGenericContainer *container = rmb->generic_container;
11913
11914                 g_assert (container);
11915
11916                 container->type_argc = count;
11917                 container->type_params = image_g_new0 (image, MonoGenericParamFull, count);
11918                 container->owner.method = m;
11919                 container->is_anonymous = FALSE; // Method is now known, container is no longer anonymous
11920
11921                 m->is_generic = TRUE;
11922                 mono_method_set_generic_container (m, container);
11923
11924                 for (i = 0; i < count; i++) {
11925                         MonoReflectionGenericParam *gp =
11926                                 mono_array_get (rmb->generic_params, MonoReflectionGenericParam*, i);
11927                         MonoType *gp_type = mono_reflection_type_get_handle ((MonoReflectionType*)gp, &error);
11928                         mono_error_assert_ok (&error);
11929                         MonoGenericParamFull *param = (MonoGenericParamFull *) gp_type->data.generic_param;
11930                         container->type_params [i] = *param;
11931                 }
11932
11933                 /*
11934                  * The method signature might have pointers to generic parameters that belong to other methods.
11935                  * This is a valid SRE case, but the resulting method signature must be encoded using the proper
11936                  * generic parameters.
11937                  */
11938                 for (i = 0; i < m->signature->param_count; ++i) {
11939                         MonoType *t = m->signature->params [i];
11940                         if (t->type == MONO_TYPE_MVAR) {
11941                                 MonoGenericParam *gparam =  t->data.generic_param;
11942                                 if (gparam->num < count) {
11943                                         m->signature->params [i] = mono_metadata_type_dup (image, m->signature->params [i]);
11944                                         m->signature->params [i]->data.generic_param = mono_generic_container_get_param (container, gparam->num);
11945                                 }
11946
11947                         }
11948                 }
11949
11950                 if (klass->generic_container) {
11951                         container->parent = klass->generic_container;
11952                         container->context.class_inst = klass->generic_container->context.class_inst;
11953                 }
11954                 container->context.method_inst = mono_get_shared_generic_inst (container);
11955         }
11956
11957         if (rmb->refs) {
11958                 MonoMethodWrapper *mw = (MonoMethodWrapper*)m;
11959                 int i;
11960                 void **data;
11961
11962                 m->wrapper_type = MONO_WRAPPER_DYNAMIC_METHOD;
11963
11964                 mw->method_data = data = image_g_new (image, gpointer, rmb->nrefs + 1);
11965                 data [0] = GUINT_TO_POINTER (rmb->nrefs);
11966                 for (i = 0; i < rmb->nrefs; ++i)
11967                         data [i + 1] = rmb->refs [i];
11968         }
11969
11970         method_aux = NULL;
11971
11972         /* Parameter info */
11973         if (rmb->pinfo) {
11974                 if (!method_aux)
11975                         method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
11976                 method_aux->param_names = image_g_new0 (image, char *, mono_method_signature (m)->param_count + 1);
11977                 for (i = 0; i <= m->signature->param_count; ++i) {
11978                         MonoReflectionParamBuilder *pb;
11979                         if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) {
11980                                 if ((i > 0) && (pb->attrs)) {
11981                                         /* Make a copy since it might point to a shared type structure */
11982                                         m->signature->params [i - 1] = mono_metadata_type_dup (klass->image, m->signature->params [i - 1]);
11983                                         m->signature->params [i - 1]->attrs = pb->attrs;
11984                                 }
11985
11986                                 if (pb->attrs & PARAM_ATTRIBUTE_HAS_DEFAULT) {
11987                                         MonoDynamicImage *assembly;
11988                                         guint32 idx, len;
11989                                         MonoTypeEnum def_type;
11990                                         char *p;
11991                                         const char *p2;
11992
11993                                         if (!method_aux->param_defaults) {
11994                                                 method_aux->param_defaults = image_g_new0 (image, guint8*, m->signature->param_count + 1);
11995                                                 method_aux->param_default_types = image_g_new0 (image, guint32, m->signature->param_count + 1);
11996                                         }
11997                                         assembly = (MonoDynamicImage*)klass->image;
11998                                         idx = encode_constant (assembly, pb->def_value, &def_type);
11999                                         /* Copy the data from the blob since it might get realloc-ed */
12000                                         p = assembly->blob.data + idx;
12001                                         len = mono_metadata_decode_blob_size (p, &p2);
12002                                         len += p2 - p;
12003                                         method_aux->param_defaults [i] = (uint8_t *)image_g_malloc (image, len);
12004                                         method_aux->param_default_types [i] = def_type;
12005                                         memcpy ((gpointer)method_aux->param_defaults [i], p, len);
12006                                 }
12007
12008                                 if (pb->name) {
12009                                         method_aux->param_names [i] = mono_string_to_utf8_image (image, pb->name, &error);
12010                                         g_assert (mono_error_ok (&error));
12011                                 }
12012                                 if (pb->cattrs) {
12013                                         if (!method_aux->param_cattr)
12014                                                 method_aux->param_cattr = image_g_new0 (image, MonoCustomAttrInfo*, m->signature->param_count + 1);
12015                                         method_aux->param_cattr [i] = mono_custom_attrs_from_builders (image, klass->image, pb->cattrs);
12016                                 }
12017                         }
12018                 }
12019         }
12020
12021         /* Parameter marshalling */
12022         specs = NULL;
12023         if (rmb->pinfo)
12024                 for (i = 0; i < mono_array_length (rmb->pinfo); ++i) {
12025                         MonoReflectionParamBuilder *pb;
12026                         if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) {
12027                                 if (pb->marshal_info) {
12028                                         if (specs == NULL)
12029                                                 specs = image_g_new0 (image, MonoMarshalSpec*, sig->param_count + 1);
12030                                         specs [pb->position] =
12031                                                 mono_marshal_spec_from_builder (image, klass->image->assembly, pb->marshal_info, &error);
12032                                         if (!is_ok (&error)) {
12033                                                 mono_loader_unlock ();
12034                                                 image_g_free (image, specs);
12035                                                 mono_error_raise_exception (&error); /* FIXME don't raise here */
12036                                         }
12037                                 }
12038                         }
12039                 }
12040         if (specs != NULL) {
12041                 if (!method_aux)
12042                         method_aux = image_g_new0 (image, MonoReflectionMethodAux, 1);
12043                 method_aux->param_marshall = specs;
12044         }
12045
12046         if (image_is_dynamic (klass->image) && method_aux)
12047                 g_hash_table_insert (((MonoDynamicImage*)klass->image)->method_aux_hash, m, method_aux);
12048
12049         mono_loader_unlock ();
12050
12051         return m;
12052 }
12053
12054 static MonoMethod*
12055 ctorbuilder_to_mono_method (MonoClass *klass, MonoReflectionCtorBuilder* mb, MonoError *error)
12056 {
12057         ReflectionMethodBuilder rmb;
12058         MonoMethodSignature *sig;
12059
12060         mono_loader_lock ();
12061         g_assert (klass->image != NULL);
12062         sig = ctor_builder_to_signature (klass->image, mb, error);
12063         mono_loader_unlock ();
12064         return_val_if_nok (error, NULL);
12065
12066         if (!reflection_methodbuilder_from_ctor_builder (&rmb, mb, error))
12067                 return NULL;
12068
12069         mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
12070         mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
12071
12072         /* If we are in a generic class, we might be called multiple times from inflate_method */
12073         if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save && !klass->generic_container) {
12074                 /* ilgen is no longer needed */
12075                 mb->ilgen = NULL;
12076         }
12077
12078         return mb->mhandle;
12079 }
12080
12081 static MonoMethod*
12082 methodbuilder_to_mono_method (MonoClass *klass, MonoReflectionMethodBuilder* mb, MonoError *error)
12083 {
12084         ReflectionMethodBuilder rmb;
12085         MonoMethodSignature *sig;
12086
12087         mono_error_init (error);
12088
12089         mono_loader_lock ();
12090         g_assert (klass->image != NULL);
12091         sig = method_builder_to_signature (klass->image, mb, error);
12092         mono_loader_unlock ();
12093         return_val_if_nok (error, NULL);
12094
12095         if (!reflection_methodbuilder_from_method_builder (&rmb, mb, error))
12096                 return NULL;
12097
12098         mb->mhandle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
12099         mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs);
12100
12101         /* If we are in a generic class, we might be called multiple times from inflate_method */
12102         if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save && !klass->generic_container) {
12103                 /* ilgen is no longer needed */
12104                 mb->ilgen = NULL;
12105         }
12106         return mb->mhandle;
12107 }
12108
12109 static MonoClassField*
12110 fieldbuilder_to_mono_class_field (MonoClass *klass, MonoReflectionFieldBuilder* fb, MonoError *error)
12111 {
12112         MonoClassField *field;
12113         MonoType *custom;
12114
12115         mono_error_init (error);
12116
12117         field = g_new0 (MonoClassField, 1);
12118
12119         field->name = mono_string_to_utf8_image (klass->image, fb->name, error);
12120         mono_error_assert_ok (error);
12121         if (fb->attrs || fb->modreq || fb->modopt) {
12122                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
12123                 if (!is_ok (error)) {
12124                         g_free (field);
12125                         return NULL;
12126                 }
12127                 field->type = mono_metadata_type_dup (NULL, type);
12128                 field->type->attrs = fb->attrs;
12129
12130                 g_assert (image_is_dynamic (klass->image));
12131                 custom = add_custom_modifiers ((MonoDynamicImage*)klass->image, field->type, fb->modreq, fb->modopt, error);
12132                 g_free (field->type);
12133                 if (!is_ok (error)) {
12134                         g_free (field);
12135                         return NULL;
12136                 }
12137                 field->type = mono_metadata_type_dup (klass->image, custom);
12138                 g_free (custom);
12139         } else {
12140                 field->type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
12141                 if (!is_ok (error)) {
12142                         g_free (field);
12143                         return NULL;
12144                 }
12145         }
12146         if (fb->offset != -1)
12147                 field->offset = fb->offset;
12148         field->parent = klass;
12149         mono_save_custom_attrs (klass->image, field, fb->cattrs);
12150
12151         // FIXME: Can't store fb->def_value/RVA, is it needed for field_on_insts ?
12152
12153         return field;
12154 }
12155 #endif
12156
12157 /**
12158  * mono_reflection_bind_generic_parameters:
12159  * @type: a managed type object (which should be some kind of generic (instance? definition?))
12160  * @type_args: the number of type arguments to bind
12161  * @types: array of type arguments
12162  * @error: set on error
12163  *
12164  * Given a managed type object for a generic type instance, binds each of its arguments to the specified types.
12165  * Returns the MonoType* for the resulting type instantiation.  On failure returns NULL and sets @error.
12166  */
12167 MonoType*
12168 mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types, MonoError *error)
12169 {
12170         MonoClass *klass;
12171         MonoReflectionTypeBuilder *tb = NULL;
12172         gboolean is_dynamic = FALSE;
12173         MonoClass *geninst;
12174
12175         mono_error_init (error);
12176
12177         mono_loader_lock ();
12178
12179         if (is_sre_type_builder (mono_object_class (type))) {
12180                 tb = (MonoReflectionTypeBuilder *) type;
12181
12182                 is_dynamic = TRUE;
12183         } else if (is_sre_generic_instance (mono_object_class (type))) {
12184                 MonoReflectionGenericClass *rgi = (MonoReflectionGenericClass *) type;
12185                 MonoReflectionType *gtd = rgi->generic_type;
12186
12187                 if (is_sre_type_builder (mono_object_class (gtd))) {
12188                         tb = (MonoReflectionTypeBuilder *)gtd;
12189                         is_dynamic = TRUE;
12190                 }
12191         }
12192
12193         /* FIXME: fix the CreateGenericParameters protocol to avoid the two stage setup of TypeBuilders */
12194         if (tb && tb->generic_container)
12195                 mono_reflection_create_generic_class (tb);
12196
12197         MonoType *t = mono_reflection_type_get_handle (type, error);
12198         if (!is_ok (error)) {
12199                 mono_loader_unlock ();
12200                 return NULL;
12201         }
12202
12203         klass = mono_class_from_mono_type (t);
12204         if (!klass->generic_container) {
12205                 mono_loader_unlock ();
12206                 mono_error_set_type_load_class (error, klass, "Cannot bind generic parameters of a non-generic type");
12207                 return NULL;
12208         }
12209
12210         if (klass->wastypebuilder) {
12211                 tb = (MonoReflectionTypeBuilder *) mono_class_get_ref_info (klass);
12212
12213                 is_dynamic = TRUE;
12214         }
12215
12216         mono_loader_unlock ();
12217
12218         geninst = mono_class_bind_generic_parameters (klass, type_argc, types, is_dynamic);
12219
12220         return &geninst->byval_arg;
12221 }
12222
12223 MonoClass*
12224 mono_class_bind_generic_parameters (MonoClass *klass, int type_argc, MonoType **types, gboolean is_dynamic)
12225 {
12226         MonoGenericClass *gclass;
12227         MonoGenericInst *inst;
12228
12229         g_assert (klass->generic_container);
12230
12231         inst = mono_metadata_get_generic_inst (type_argc, types);
12232         gclass = mono_metadata_lookup_generic_class (klass, inst, is_dynamic);
12233
12234         return mono_generic_class_get_class (gclass);
12235 }
12236
12237 MonoReflectionMethod*
12238 mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types)
12239 {
12240         MonoError error;
12241         MonoClass *klass;
12242         MonoMethod *method, *inflated;
12243         MonoMethodInflated *imethod;
12244         MonoGenericContext tmp_context;
12245         MonoGenericInst *ginst;
12246         MonoType **type_argv;
12247         int count, i;
12248
12249         /*FIXME but this no longer should happen*/
12250         if (!strcmp (rmethod->object.vtable->klass->name, "MethodBuilder")) {
12251 #ifndef DISABLE_REFLECTION_EMIT
12252                 MonoReflectionMethodBuilder *mb = NULL;
12253                 MonoType *tb;
12254                 MonoClass *klass;
12255
12256                 mb = (MonoReflectionMethodBuilder *) rmethod;
12257                 tb = mono_reflection_type_get_handle ((MonoReflectionType*)mb->type, &error);
12258                 mono_error_raise_exception (&error); /* FIXME don't raise here */
12259                 klass = mono_class_from_mono_type (tb);
12260
12261                 method = methodbuilder_to_mono_method (klass, mb, &error);
12262                 if (!method)
12263                         mono_error_raise_exception (&error); /* FIXME don't raise here */
12264 #else
12265                 g_assert_not_reached ();
12266                 method = NULL;
12267 #endif
12268         } else {
12269                 method = rmethod->method;
12270         }
12271
12272         klass = method->klass;
12273
12274         if (method->is_inflated)
12275                 method = ((MonoMethodInflated *) method)->declaring;
12276
12277         count = mono_method_signature (method)->generic_param_count;
12278         if (count != mono_array_length (types))
12279                 return NULL;
12280
12281         type_argv = g_new0 (MonoType *, count);
12282         for (i = 0; i < count; i++) {
12283                 MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (types, gpointer, i);
12284                 type_argv [i] = mono_reflection_type_get_handle (garg, &error);
12285                 if (!is_ok (&error)) {
12286                         g_free (type_argv);
12287                         mono_error_raise_exception (&error); /* FIXME don't raise here */
12288                 }
12289         }
12290         ginst = mono_metadata_get_generic_inst (count, type_argv);
12291         g_free (type_argv);
12292
12293         tmp_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL;
12294         tmp_context.method_inst = ginst;
12295
12296         inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, &error);
12297         g_assert (mono_error_ok (&error)); /* FIXME don't swallow the error */
12298         imethod = (MonoMethodInflated *) inflated;
12299
12300         /*FIXME but I think this is no longer necessary*/
12301         if (image_is_dynamic (method->klass->image)) {
12302                 MonoDynamicImage *image = (MonoDynamicImage*)method->klass->image;
12303                 /*
12304                  * This table maps metadata structures representing inflated methods/fields
12305                  * to the reflection objects representing their generic definitions.
12306                  */
12307                 mono_image_lock ((MonoImage*)image);
12308                 mono_g_hash_table_insert (image->generic_def_objects, imethod, rmethod);
12309                 mono_image_unlock ((MonoImage*)image);
12310         }
12311
12312         if (!mono_verifier_is_method_valid_generic_instantiation (inflated))
12313                 mono_raise_exception (mono_get_exception_argument ("typeArguments", "Invalid generic arguments"));
12314
12315         MonoReflectionMethod *ret = mono_method_get_object_checked (mono_object_domain (rmethod), inflated, NULL, &error);
12316         mono_error_raise_exception (&error); /* FIXME don't raise here */
12317         return ret;
12318 }
12319
12320 #ifndef DISABLE_REFLECTION_EMIT
12321
12322 static MonoMethod *
12323 inflate_mono_method (MonoClass *klass, MonoMethod *method, MonoObject *obj)
12324 {
12325         MonoMethodInflated *imethod;
12326         MonoGenericContext *context;
12327         int i;
12328
12329         /*
12330          * With generic code sharing the klass might not be inflated.
12331          * This can happen because classes inflated with their own
12332          * type arguments are "normalized" to the uninflated class.
12333          */
12334         if (!klass->generic_class)
12335                 return method;
12336
12337         context = mono_class_get_context (klass);
12338
12339         if (klass->method.count && klass->methods) {
12340                 /* Find the already created inflated method */
12341                 for (i = 0; i < klass->method.count; ++i) {
12342                         g_assert (klass->methods [i]->is_inflated);
12343                         if (((MonoMethodInflated*)klass->methods [i])->declaring == method)
12344                                 break;
12345                 }
12346                 g_assert (i < klass->method.count);
12347                 imethod = (MonoMethodInflated*)klass->methods [i];
12348         } else {
12349                 MonoError error;
12350                 imethod = (MonoMethodInflated *) mono_class_inflate_generic_method_full_checked (method, klass, context, &error);
12351                 mono_error_assert_ok (&error);
12352         }
12353
12354         if (method->is_generic && image_is_dynamic (method->klass->image)) {
12355                 MonoDynamicImage *image = (MonoDynamicImage*)method->klass->image;
12356
12357                 mono_image_lock ((MonoImage*)image);
12358                 mono_g_hash_table_insert (image->generic_def_objects, imethod, obj);
12359                 mono_image_unlock ((MonoImage*)image);
12360         }
12361         return (MonoMethod *) imethod;
12362 }
12363
12364 static MonoMethod *
12365 inflate_method (MonoReflectionType *type, MonoObject *obj, MonoError *error)
12366 {
12367         MonoMethod *method;
12368         MonoClass *gklass;
12369
12370         mono_error_init (error);
12371
12372         MonoClass *type_class = mono_object_class (type);
12373
12374         if (is_sre_generic_instance (type_class)) {
12375                 MonoReflectionGenericClass *mgc = (MonoReflectionGenericClass*)type;
12376                 MonoType *generic_type = mono_reflection_type_get_handle ((MonoReflectionType*)mgc->generic_type, error);
12377                 return_val_if_nok (error, NULL);
12378                 gklass = mono_class_from_mono_type (generic_type);
12379         } else if (is_sre_type_builder (type_class)) {
12380                 MonoType *t = mono_reflection_type_get_handle (type, error);
12381                 return_val_if_nok (error, NULL);
12382                 gklass = mono_class_from_mono_type (t);
12383         } else if (type->type) {
12384                 gklass = mono_class_from_mono_type (type->type);
12385                 gklass = mono_class_get_generic_type_definition (gklass);
12386         } else {
12387                 g_error ("Can't handle type %s", mono_type_get_full_name (mono_object_class (type)));
12388         }
12389
12390         if (!strcmp (obj->vtable->klass->name, "MethodBuilder"))
12391                 if (((MonoReflectionMethodBuilder*)obj)->mhandle)
12392                         method = ((MonoReflectionMethodBuilder*)obj)->mhandle;
12393                 else {
12394                         method = methodbuilder_to_mono_method (gklass, (MonoReflectionMethodBuilder *) obj, error);
12395                         if (!method)
12396                                 return NULL;
12397                 }
12398         else if (!strcmp (obj->vtable->klass->name, "ConstructorBuilder")) {
12399                 method = ctorbuilder_to_mono_method (gklass, (MonoReflectionCtorBuilder *) obj, error);
12400                 if (!method)
12401                         return NULL;
12402         } else if (!strcmp (obj->vtable->klass->name, "MonoMethod") || !strcmp (obj->vtable->klass->name, "MonoCMethod"))
12403                 method = ((MonoReflectionMethod *) obj)->method;
12404         else {
12405                 method = NULL; /* prevent compiler warning */
12406                 g_error ("can't handle type %s", obj->vtable->klass->name);
12407         }
12408
12409         MonoType *t = mono_reflection_type_get_handle (type, error);
12410         return_val_if_nok (error, NULL);
12411         return inflate_mono_method (mono_class_from_mono_type (t), method, obj);
12412 }
12413
12414 /*TODO avoid saving custom attrs for generic classes as it's enough to have them on the generic type definition.*/
12415 static gboolean
12416 reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields, MonoError *error)
12417 {
12418         MonoGenericClass *gclass;
12419         MonoDynamicGenericClass *dgclass;
12420         MonoClass *klass, *gklass;
12421         MonoType *gtype;
12422         int i;
12423
12424         mono_error_init (error);
12425
12426         gtype = mono_reflection_type_get_handle ((MonoReflectionType*)type, error);
12427         return_val_if_nok (error, FALSE);
12428         klass = mono_class_from_mono_type (gtype);
12429         g_assert (gtype->type == MONO_TYPE_GENERICINST);
12430         gclass = gtype->data.generic_class;
12431
12432         if (!gclass->is_dynamic)
12433                 return TRUE;
12434
12435         dgclass = (MonoDynamicGenericClass *) gclass;
12436
12437         if (dgclass->initialized)
12438                 return TRUE;
12439
12440         gklass = gclass->container_class;
12441         mono_class_init (gklass);
12442
12443         dgclass->count_fields = fields ? mono_array_length (fields) : 0;
12444
12445         dgclass->fields = mono_image_set_new0 (gclass->owner, MonoClassField, dgclass->count_fields);
12446         dgclass->field_objects = mono_image_set_new0 (gclass->owner, MonoObject*, dgclass->count_fields);
12447         dgclass->field_generic_types = mono_image_set_new0 (gclass->owner, MonoType*, dgclass->count_fields);
12448
12449         for (i = 0; i < dgclass->count_fields; i++) {
12450                 MonoObject *obj = (MonoObject *)mono_array_get (fields, gpointer, i);
12451                 MonoClassField *field, *inflated_field = NULL;
12452
12453                 if (!strcmp (obj->vtable->klass->name, "FieldBuilder")) {
12454                         inflated_field = field = fieldbuilder_to_mono_class_field (klass, (MonoReflectionFieldBuilder *) obj, error);
12455                         return_val_if_nok (error, FALSE);
12456                 } else if (!strcmp (obj->vtable->klass->name, "MonoField"))
12457                         field = ((MonoReflectionField *) obj)->field;
12458                 else {
12459                         field = NULL; /* prevent compiler warning */
12460                         g_assert_not_reached ();
12461                 }
12462
12463                 dgclass->fields [i] = *field;
12464                 dgclass->fields [i].parent = klass;
12465                 dgclass->fields [i].type = mono_class_inflate_generic_type_checked (
12466                         field->type, mono_generic_class_get_context ((MonoGenericClass *) dgclass), error);
12467                 mono_error_assert_ok (error); /* FIXME don't swallow the error */
12468                 dgclass->field_generic_types [i] = field->type;
12469                 MONO_GC_REGISTER_ROOT_IF_MOVING (dgclass->field_objects [i], MONO_ROOT_SOURCE_REFLECTION, "dynamic generic class field object");
12470                 dgclass->field_objects [i] = obj;
12471
12472                 if (inflated_field) {
12473                         g_free (inflated_field);
12474                 } else {
12475                         dgclass->fields [i].name = mono_image_set_strdup (gclass->owner, dgclass->fields [i].name);
12476                 }
12477         }
12478
12479         dgclass->initialized = TRUE;
12480         return TRUE;
12481 }
12482
12483 void
12484 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields)
12485 {
12486         MonoError error;
12487         (void) reflection_generic_class_initialize (type, fields, &error);
12488         mono_error_set_pending_exception (&error);
12489 }
12490
12491 void
12492 mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass)
12493 {
12494         MonoDynamicGenericClass *dgclass;
12495         int i;
12496
12497         g_assert (gclass->is_dynamic);
12498
12499         dgclass = (MonoDynamicGenericClass *)gclass;
12500
12501         for (i = 0; i < dgclass->count_fields; ++i) {
12502                 MonoClassField *field = dgclass->fields + i;
12503                 mono_metadata_free_type (field->type);
12504                 MONO_GC_UNREGISTER_ROOT_IF_MOVING (dgclass->field_objects [i]);
12505         }
12506 }
12507
12508 /**
12509  * fix_partial_generic_class:
12510  * @klass: a generic instantiation MonoClass
12511  * @error: set on error
12512  *
12513  * Assumes that the generic container of @klass has its vtable
12514  * initialized, and updates the parent class, insterfaces, methods and
12515  * fields of @klass by inflating the types using the generic context.
12516  *
12517  * On success returns TRUE, on failure returns FALSE and sets @error.
12518  *
12519  */
12520 static gboolean
12521 fix_partial_generic_class (MonoClass *klass, MonoError *error)
12522 {
12523         MonoClass *gklass = klass->generic_class->container_class;
12524         MonoDynamicGenericClass *dgclass;
12525         int i;
12526
12527         mono_error_init (error);
12528
12529         if (klass->wastypebuilder)
12530                 return TRUE;
12531
12532         dgclass = (MonoDynamicGenericClass *)  klass->generic_class;
12533         if (klass->parent != gklass->parent) {
12534                 MonoType *parent_type = mono_class_inflate_generic_type_checked (&gklass->parent->byval_arg, &klass->generic_class->context, error);
12535                 if (mono_error_ok (error)) {
12536                         MonoClass *parent = mono_class_from_mono_type (parent_type);
12537                         mono_metadata_free_type (parent_type);
12538                         if (parent != klass->parent) {
12539                                 /*fool mono_class_setup_parent*/
12540                                 klass->supertypes = NULL;
12541                                 mono_class_setup_parent (klass, parent);
12542                         }
12543                 } else {
12544                         if (gklass->wastypebuilder)
12545                                 klass->wastypebuilder = TRUE;
12546                         return FALSE;
12547                 }
12548         }
12549
12550         if (!dgclass->initialized)
12551                 return TRUE;
12552
12553         if (klass->method.count != gklass->method.count) {
12554                 klass->method.count = gklass->method.count;
12555                 klass->methods = (MonoMethod **)mono_image_alloc (klass->image, sizeof (MonoMethod*) * (klass->method.count + 1));
12556
12557                 for (i = 0; i < klass->method.count; i++) {
12558                         klass->methods [i] = mono_class_inflate_generic_method_full_checked (
12559                                 gklass->methods [i], klass, mono_class_get_context (klass), error);
12560                         mono_error_assert_ok (error);
12561                 }
12562         }
12563
12564         if (klass->interface_count && klass->interface_count != gklass->interface_count) {
12565                 klass->interface_count = gklass->interface_count;
12566                 klass->interfaces = (MonoClass **)mono_image_alloc (klass->image, sizeof (MonoClass*) * gklass->interface_count);
12567                 klass->interfaces_packed = NULL; /*make setup_interface_offsets happy*/
12568
12569                 for (i = 0; i < gklass->interface_count; ++i) {
12570                         MonoType *iface_type = mono_class_inflate_generic_type_checked (&gklass->interfaces [i]->byval_arg, mono_class_get_context (klass), error);
12571                         return_val_if_nok (error, FALSE);
12572
12573                         klass->interfaces [i] = mono_class_from_mono_type (iface_type);
12574                         mono_metadata_free_type (iface_type);
12575
12576                         if (!ensure_runtime_vtable (klass->interfaces [i], error))
12577                                 return FALSE;
12578                 }
12579                 klass->interfaces_inited = 1;
12580         }
12581
12582         if (klass->field.count != gklass->field.count) {
12583                 klass->field.count = gklass->field.count;
12584                 klass->fields = image_g_new0 (klass->image, MonoClassField, klass->field.count);
12585
12586                 for (i = 0; i < klass->field.count; i++) {
12587                         klass->fields [i] = gklass->fields [i];
12588                         klass->fields [i].parent = klass;
12589                         klass->fields [i].type = mono_class_inflate_generic_type_checked (gklass->fields [i].type, mono_class_get_context (klass), error);
12590                         return_val_if_nok (error, FALSE);
12591                 }
12592         }
12593
12594         /*We can only finish with this klass once it's parent has as well*/
12595         if (gklass->wastypebuilder)
12596                 klass->wastypebuilder = TRUE;
12597         return TRUE;
12598 }
12599
12600 /**
12601  * ensure_generic_class_runtime_vtable:
12602  * @klass a generic class
12603  * @error set on error
12604  *
12605  * Ensures that the generic container of @klass has a vtable and
12606  * returns TRUE on success.  On error returns FALSE and sets @error.
12607  */
12608 static gboolean
12609 ensure_generic_class_runtime_vtable (MonoClass *klass, MonoError *error)
12610 {
12611         MonoClass *gklass = klass->generic_class->container_class;
12612
12613         mono_error_init (error);
12614
12615         if (!ensure_runtime_vtable (gklass, error))
12616                 return FALSE;
12617
12618         return fix_partial_generic_class (klass, error);
12619 }
12620
12621 /**
12622  * ensure_runtime_vtable:
12623  * @klass the class
12624  * @error set on error
12625  *
12626  * Ensures that @klass has a vtable and returns TRUE on success. On
12627  * error returns FALSE and sets @error.
12628  */
12629 static gboolean
12630 ensure_runtime_vtable (MonoClass *klass, MonoError *error)
12631 {
12632         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
12633         int i, num, j;
12634
12635         mono_error_init (error);
12636
12637         if (!image_is_dynamic (klass->image) || (!tb && !klass->generic_class) || klass->wastypebuilder)
12638                 return TRUE;
12639         if (klass->parent)
12640                 if (!ensure_runtime_vtable (klass->parent, error))
12641                         return FALSE;
12642
12643         if (tb) {
12644                 num = tb->ctors? mono_array_length (tb->ctors): 0;
12645                 num += tb->num_methods;
12646                 klass->method.count = num;
12647                 klass->methods = (MonoMethod **)mono_image_alloc (klass->image, sizeof (MonoMethod*) * num);
12648                 num = tb->ctors? mono_array_length (tb->ctors): 0;
12649                 for (i = 0; i < num; ++i) {
12650                         MonoMethod *ctor = ctorbuilder_to_mono_method (klass, mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i), error);
12651                         if (!ctor)
12652                                 return FALSE;
12653                         klass->methods [i] = ctor;
12654                 }
12655                 num = tb->num_methods;
12656                 j = i;
12657                 for (i = 0; i < num; ++i) {
12658                         MonoMethod *meth = methodbuilder_to_mono_method (klass, mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i), error);
12659                         if (!meth)
12660                                 return FALSE;
12661                         klass->methods [j++] = meth;
12662                 }
12663
12664                 if (tb->interfaces) {
12665                         klass->interface_count = mono_array_length (tb->interfaces);
12666                         klass->interfaces = (MonoClass **)mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
12667                         for (i = 0; i < klass->interface_count; ++i) {
12668                                 MonoType *iface = mono_type_array_get_and_resolve (tb->interfaces, i, error);
12669                                 return_val_if_nok (error, FALSE);
12670                                 klass->interfaces [i] = mono_class_from_mono_type (iface);
12671                                 if (!ensure_runtime_vtable (klass->interfaces [i], error))
12672                                         return FALSE;
12673                         }
12674                         klass->interfaces_inited = 1;
12675                 }
12676         } else if (klass->generic_class){
12677                 if (!ensure_generic_class_runtime_vtable (klass, error)) {
12678                         mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
12679                         return FALSE;
12680                 }
12681         }
12682
12683         if (klass->flags & TYPE_ATTRIBUTE_INTERFACE) {
12684                 int slot_num = 0;
12685                 for (i = 0; i < klass->method.count; ++i) {
12686                         MonoMethod *im = klass->methods [i];
12687                         if (!(im->flags & METHOD_ATTRIBUTE_STATIC))
12688                                 im->slot = slot_num++;
12689                 }
12690
12691                 klass->interfaces_packed = NULL; /*make setup_interface_offsets happy*/
12692                 mono_class_setup_interface_offsets (klass);
12693                 mono_class_setup_interface_id (klass);
12694         }
12695
12696         /*
12697          * The generic vtable is needed even if image->run is not set since some
12698          * runtime code like ves_icall_Type_GetMethodsByName depends on
12699          * method->slot being defined.
12700          */
12701
12702         /*
12703          * tb->methods could not be freed since it is used for determining
12704          * overrides during dynamic vtable construction.
12705          */
12706
12707         return TRUE;
12708 }
12709
12710 static MonoMethod*
12711 mono_reflection_method_get_handle (MonoObject *method, MonoError *error)
12712 {
12713         mono_error_init (error);
12714         MonoClass *klass = mono_object_class (method);
12715         if (is_sr_mono_method (klass) || is_sr_mono_generic_method (klass)) {
12716                 MonoReflectionMethod *sr_method = (MonoReflectionMethod*)method;
12717                 return sr_method->method;
12718         }
12719         if (is_sre_method_builder (klass)) {
12720                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)method;
12721                 return mb->mhandle;
12722         }
12723         if (is_sre_method_on_tb_inst (klass)) {
12724                 MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)method;
12725                 MonoMethod *result;
12726                 /*FIXME move this to a proper method and unify with resolve_object*/
12727                 if (m->method_args) {
12728                         result = mono_reflection_method_on_tb_inst_get_handle (m, error);
12729                 } else {
12730                         MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)m->inst, error);
12731                         return_val_if_nok (error, NULL);
12732                         MonoClass *inflated_klass = mono_class_from_mono_type (type);
12733                         MonoMethod *mono_method;
12734
12735                         if (is_sre_method_builder (mono_object_class (m->mb)))
12736                                 mono_method = ((MonoReflectionMethodBuilder *)m->mb)->mhandle;
12737                         else if (is_sr_mono_method (mono_object_class (m->mb)))
12738                                 mono_method = ((MonoReflectionMethod *)m->mb)->method;
12739                         else
12740                                 g_error ("resolve_object:: can't handle a MTBI with base_method of type %s", mono_type_get_full_name (mono_object_class (m->mb)));
12741
12742                         result = inflate_mono_method (inflated_klass, mono_method, (MonoObject*)m->mb);
12743                 }
12744                 return result;
12745         }
12746
12747         g_error ("Can't handle methods of type %s:%s", klass->name_space, klass->name);
12748         return NULL;
12749 }
12750
12751 void
12752 mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error)
12753 {
12754         MonoReflectionTypeBuilder *tb;
12755         int i, j, onum;
12756         MonoReflectionMethod *m;
12757
12758         mono_error_init (error);
12759         *overrides = NULL;
12760         *num_overrides = 0;
12761
12762         g_assert (image_is_dynamic (klass->image));
12763
12764         if (!mono_class_get_ref_info (klass))
12765                 return;
12766
12767         g_assert (strcmp (((MonoObject*)mono_class_get_ref_info (klass))->vtable->klass->name, "TypeBuilder") == 0);
12768
12769         tb = (MonoReflectionTypeBuilder*)mono_class_get_ref_info (klass);
12770
12771         onum = 0;
12772         if (tb->methods) {
12773                 for (i = 0; i < tb->num_methods; ++i) {
12774                         MonoReflectionMethodBuilder *mb =
12775                                 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
12776                         if (mb->override_methods)
12777                                 onum += mono_array_length (mb->override_methods);
12778                 }
12779         }
12780
12781         if (onum) {
12782                 *overrides = g_new0 (MonoMethod*, onum * 2);
12783
12784                 onum = 0;
12785                 for (i = 0; i < tb->num_methods; ++i) {
12786                         MonoReflectionMethodBuilder *mb =
12787                                 mono_array_get (tb->methods, MonoReflectionMethodBuilder*, i);
12788                         if (mb->override_methods) {
12789                                 for (j = 0; j < mono_array_length (mb->override_methods); ++j) {
12790                                         m = mono_array_get (mb->override_methods, MonoReflectionMethod*, j);
12791
12792                                         (*overrides) [onum * 2] = mono_reflection_method_get_handle ((MonoObject*)m, error);
12793                                         return_if_nok (error);
12794                                         (*overrides) [onum * 2 + 1] = mb->mhandle;
12795
12796                                         g_assert (mb->mhandle);
12797
12798                                         onum ++;
12799                                 }
12800                         }
12801                 }
12802         }
12803
12804         *num_overrides = onum;
12805 }
12806
12807 static void
12808 typebuilder_setup_fields (MonoClass *klass, MonoError *error)
12809 {
12810         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
12811         MonoReflectionFieldBuilder *fb;
12812         MonoClassField *field;
12813         MonoImage *image = klass->image;
12814         const char *p, *p2;
12815         int i;
12816         guint32 len, idx, real_size = 0;
12817
12818         klass->field.count = tb->num_fields;
12819         klass->field.first = 0;
12820
12821         mono_error_init (error);
12822
12823         if (tb->class_size) {
12824                 if ((tb->packing_size & 0xffffff00) != 0) {
12825                         char *err_msg = g_strdup_printf ("Could not load struct '%s' with packing size %d >= 256", klass->name, tb->packing_size);
12826                         mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, err_msg);
12827                         return;
12828                 }
12829                 klass->packing_size = tb->packing_size;
12830                 real_size = klass->instance_size + tb->class_size;
12831         }
12832
12833         if (!klass->field.count) {
12834                 klass->instance_size = MAX (klass->instance_size, real_size);
12835                 return;
12836         }
12837
12838         klass->fields = image_g_new0 (image, MonoClassField, klass->field.count);
12839         mono_class_alloc_ext (klass);
12840         klass->ext->field_def_values = image_g_new0 (image, MonoFieldDefaultValue, klass->field.count);
12841         /*
12842         This is, guess what, a hack.
12843         The issue is that the runtime doesn't know how to setup the fields of a typebuider and crash.
12844         On the static path no field class is resolved, only types are built. This is the right thing to do
12845         but we suck.
12846         Setting size_inited is harmless because we're doing the same job as mono_class_setup_fields anyway.
12847         */
12848         klass->size_inited = 1;
12849
12850         for (i = 0; i < klass->field.count; ++i) {
12851                 MonoArray *rva_data;
12852                 fb = (MonoReflectionFieldBuilder *)mono_array_get (tb->fields, gpointer, i);
12853                 field = &klass->fields [i];
12854                 field->name = mono_string_to_utf8_image (image, fb->name, error);
12855                 if (!mono_error_ok (error))
12856                         return;
12857                 if (fb->attrs) {
12858                         MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
12859                         return_if_nok (error);
12860                         field->type = mono_metadata_type_dup (klass->image, type);
12861                         field->type->attrs = fb->attrs;
12862                 } else {
12863                         field->type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error);
12864                         return_if_nok (error);
12865                 }
12866
12867                 if ((fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) && (rva_data = fb->rva_data)) {
12868                         char *base = mono_array_addr (rva_data, char, 0);
12869                         size_t size = mono_array_length (rva_data);
12870                         char *data = (char *)mono_image_alloc (klass->image, size);
12871                         memcpy (data, base, size);
12872                         klass->ext->field_def_values [i].data = data;
12873                 }
12874                 if (fb->offset != -1)
12875                         field->offset = fb->offset;
12876                 field->parent = klass;
12877                 fb->handle = field;
12878                 mono_save_custom_attrs (klass->image, field, fb->cattrs);
12879
12880                 if (klass->enumtype && !(field->type->attrs & FIELD_ATTRIBUTE_STATIC)) {
12881                         klass->cast_class = klass->element_class = mono_class_from_mono_type (field->type);
12882                 }
12883                 if (fb->def_value) {
12884                         MonoDynamicImage *assembly = (MonoDynamicImage*)klass->image;
12885                         field->type->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
12886                         idx = encode_constant (assembly, fb->def_value, &klass->ext->field_def_values [i].def_type);
12887                         /* Copy the data from the blob since it might get realloc-ed */
12888                         p = assembly->blob.data + idx;
12889                         len = mono_metadata_decode_blob_size (p, &p2);
12890                         len += p2 - p;
12891                         klass->ext->field_def_values [i].data = (const char *)mono_image_alloc (image, len);
12892                         memcpy ((gpointer)klass->ext->field_def_values [i].data, p, len);
12893                 }
12894         }
12895
12896         klass->instance_size = MAX (klass->instance_size, real_size);
12897         mono_class_layout_fields (klass, klass->instance_size);
12898 }
12899
12900 static void
12901 typebuilder_setup_properties (MonoClass *klass, MonoError *error)
12902 {
12903         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
12904         MonoReflectionPropertyBuilder *pb;
12905         MonoImage *image = klass->image;
12906         MonoProperty *properties;
12907         int i;
12908
12909         mono_error_init (error);
12910
12911         if (!klass->ext)
12912                 klass->ext = image_g_new0 (image, MonoClassExt, 1);
12913
12914         klass->ext->property.count = tb->properties ? mono_array_length (tb->properties) : 0;
12915         klass->ext->property.first = 0;
12916
12917         properties = image_g_new0 (image, MonoProperty, klass->ext->property.count);
12918         klass->ext->properties = properties;
12919         for (i = 0; i < klass->ext->property.count; ++i) {
12920                 pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i);
12921                 properties [i].parent = klass;
12922                 properties [i].attrs = pb->attrs;
12923                 properties [i].name = mono_string_to_utf8_image (image, pb->name, error);
12924                 if (!mono_error_ok (error))
12925                         return;
12926                 if (pb->get_method)
12927                         properties [i].get = pb->get_method->mhandle;
12928                 if (pb->set_method)
12929                         properties [i].set = pb->set_method->mhandle;
12930
12931                 mono_save_custom_attrs (klass->image, &properties [i], pb->cattrs);
12932                 if (pb->def_value) {
12933                         guint32 len, idx;
12934                         const char *p, *p2;
12935                         MonoDynamicImage *assembly = (MonoDynamicImage*)klass->image;
12936                         if (!klass->ext->prop_def_values)
12937                                 klass->ext->prop_def_values = image_g_new0 (image, MonoFieldDefaultValue, klass->ext->property.count);
12938                         properties [i].attrs |= PROPERTY_ATTRIBUTE_HAS_DEFAULT;
12939                         idx = encode_constant (assembly, pb->def_value, &klass->ext->prop_def_values [i].def_type);
12940                         /* Copy the data from the blob since it might get realloc-ed */
12941                         p = assembly->blob.data + idx;
12942                         len = mono_metadata_decode_blob_size (p, &p2);
12943                         len += p2 - p;
12944                         klass->ext->prop_def_values [i].data = (const char *)mono_image_alloc (image, len);
12945                         memcpy ((gpointer)klass->ext->prop_def_values [i].data, p, len);
12946                 }
12947         }
12948 }
12949
12950 static MonoReflectionEvent *
12951 reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb, MonoError *error)
12952 {
12953         mono_error_init (error);
12954
12955         MonoEvent *event = g_new0 (MonoEvent, 1);
12956         MonoClass *klass;
12957
12958         MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error);
12959         if (!is_ok (error)) {
12960                 g_free (event);
12961                 return NULL;
12962         }
12963         klass = mono_class_from_mono_type (type);
12964
12965         event->parent = klass;
12966         event->attrs = eb->attrs;
12967         event->name = mono_string_to_utf8 (eb->name);
12968         if (eb->add_method)
12969                 event->add = eb->add_method->mhandle;
12970         if (eb->remove_method)
12971                 event->remove = eb->remove_method->mhandle;
12972         if (eb->raise_method)
12973                 event->raise = eb->raise_method->mhandle;
12974
12975 #ifndef MONO_SMALL_CONFIG
12976         if (eb->other_methods) {
12977                 int j;
12978                 event->other = g_new0 (MonoMethod*, mono_array_length (eb->other_methods) + 1);
12979                 for (j = 0; j < mono_array_length (eb->other_methods); ++j) {
12980                         MonoReflectionMethodBuilder *mb =
12981                                 mono_array_get (eb->other_methods,
12982                                                 MonoReflectionMethodBuilder*, j);
12983                         event->other [j] = mb->mhandle;
12984                 }
12985         }
12986 #endif
12987
12988         MonoReflectionEvent *ev_obj = mono_event_get_object_checked (mono_object_domain (tb), klass, event, error);
12989         if (!is_ok (error)) {
12990 #ifndef MONO_SMALL_CONFIG
12991                 g_free (event->other);
12992 #endif
12993                 g_free (event);
12994                 return NULL;
12995         }
12996         return ev_obj;
12997 }
12998
12999 MonoReflectionEvent *
13000 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb)
13001 {
13002         MonoError error;
13003         MonoReflectionEvent *result = reflection_event_builder_get_event_info (tb, eb, &error);
13004         mono_error_set_pending_exception (&error);
13005         return result;
13006 }
13007
13008 static void
13009 typebuilder_setup_events (MonoClass *klass, MonoError *error)
13010 {
13011         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
13012         MonoReflectionEventBuilder *eb;
13013         MonoImage *image = klass->image;
13014         MonoEvent *events;
13015         int i;
13016
13017         mono_error_init (error);
13018
13019         if (!klass->ext)
13020                 klass->ext = image_g_new0 (image, MonoClassExt, 1);
13021
13022         klass->ext->event.count = tb->events ? mono_array_length (tb->events) : 0;
13023         klass->ext->event.first = 0;
13024
13025         events = image_g_new0 (image, MonoEvent, klass->ext->event.count);
13026         klass->ext->events = events;
13027         for (i = 0; i < klass->ext->event.count; ++i) {
13028                 eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i);
13029                 events [i].parent = klass;
13030                 events [i].attrs = eb->attrs;
13031                 events [i].name = mono_string_to_utf8_image (image, eb->name, error);
13032                 if (!mono_error_ok (error))
13033                         return;
13034                 if (eb->add_method)
13035                         events [i].add = eb->add_method->mhandle;
13036                 if (eb->remove_method)
13037                         events [i].remove = eb->remove_method->mhandle;
13038                 if (eb->raise_method)
13039                         events [i].raise = eb->raise_method->mhandle;
13040
13041 #ifndef MONO_SMALL_CONFIG
13042                 if (eb->other_methods) {
13043                         int j;
13044                         events [i].other = image_g_new0 (image, MonoMethod*, mono_array_length (eb->other_methods) + 1);
13045                         for (j = 0; j < mono_array_length (eb->other_methods); ++j) {
13046                                 MonoReflectionMethodBuilder *mb =
13047                                         mono_array_get (eb->other_methods,
13048                                                                         MonoReflectionMethodBuilder*, j);
13049                                 events [i].other [j] = mb->mhandle;
13050                         }
13051                 }
13052 #endif
13053                 mono_save_custom_attrs (klass->image, &events [i], eb->cattrs);
13054         }
13055 }
13056
13057 struct remove_instantiations_user_data
13058 {
13059         MonoClass *klass;
13060         MonoError *error;
13061 };
13062
13063 static gboolean
13064 remove_instantiations_of_and_ensure_contents (gpointer key,
13065                                                   gpointer value,
13066                                                   gpointer user_data)
13067 {
13068         struct remove_instantiations_user_data *data = (struct remove_instantiations_user_data*)user_data;
13069         MonoType *type = (MonoType*)key;
13070         MonoClass *klass = data->klass;
13071         gboolean already_failed = !is_ok (data->error);
13072         MonoError lerror;
13073         MonoError *error = already_failed ? &lerror : data->error;
13074
13075         if ((type->type == MONO_TYPE_GENERICINST) && (type->data.generic_class->container_class == klass)) {
13076                 MonoClass *inst_klass = mono_class_from_mono_type (type);
13077                 //Ensure it's safe to use it.
13078                 if (!fix_partial_generic_class (inst_klass, error)) {
13079                         mono_class_set_failure (inst_klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
13080                         // Marked the class with failure, but since some other instantiation already failed,
13081                         // just report that one, and swallow the error from this one.
13082                         if (already_failed)
13083                                 mono_error_cleanup (error);
13084                 }
13085                 return TRUE;
13086         } else
13087                 return FALSE;
13088 }
13089
13090 static void
13091 check_array_for_usertypes (MonoArray *arr, MonoError *error)
13092 {
13093         mono_error_init (error);
13094         int i;
13095
13096         if (!arr)
13097                 return;
13098
13099         for (i = 0; i < mono_array_length (arr); ++i) {
13100                 RESOLVE_ARRAY_TYPE_ELEMENT (arr, i, error);
13101                 if (!mono_error_ok (error))
13102                         break;
13103         }
13104 }
13105
13106 MonoReflectionType*
13107 mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
13108 {
13109         MonoError error;
13110         MonoClass *klass;
13111         MonoDomain* domain;
13112         MonoReflectionType* res;
13113         int i, j;
13114
13115         mono_error_init (&error);
13116
13117         domain = mono_object_domain (tb);
13118         klass = mono_class_from_mono_type (tb->type.type);
13119
13120         /*
13121          * Check for user defined Type subclasses.
13122          */
13123         RESOLVE_TYPE (tb->parent, &error);
13124         if (!is_ok (&error))
13125                 goto failure_unlocked;
13126         check_array_for_usertypes (tb->interfaces, &error);
13127         if (!is_ok (&error))
13128                 goto failure_unlocked;
13129         if (tb->fields) {
13130                 for (i = 0; i < mono_array_length (tb->fields); ++i) {
13131                         MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)mono_array_get (tb->fields, gpointer, i);
13132                         if (fb) {
13133                                 RESOLVE_TYPE (fb->type, &error);
13134                                 if (!is_ok (&error))
13135                                         goto failure_unlocked;
13136                                 check_array_for_usertypes (fb->modreq, &error);
13137                                 if (!is_ok (&error))
13138                                         goto failure_unlocked;
13139                                 check_array_for_usertypes (fb->modopt, &error);
13140                                 if (!is_ok (&error))
13141                                         goto failure_unlocked;
13142                                 if (fb->marshal_info && fb->marshal_info->marshaltyperef) {
13143                                         RESOLVE_TYPE (fb->marshal_info->marshaltyperef, &error);
13144                                         if (!is_ok (&error))
13145                                                 goto failure_unlocked;
13146                                 }
13147                         }
13148                 }
13149         }
13150         if (tb->methods) {
13151                 for (i = 0; i < mono_array_length (tb->methods); ++i) {
13152                         MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)mono_array_get (tb->methods, gpointer, i);
13153                         if (mb) {
13154                                 RESOLVE_TYPE (mb->rtype, &error);
13155                                 if (!is_ok (&error))
13156                                         goto failure_unlocked;
13157                                 check_array_for_usertypes (mb->return_modreq, &error);
13158                                 if (!is_ok (&error))
13159                                         goto failure_unlocked;
13160                                 check_array_for_usertypes (mb->return_modopt, &error);
13161                                 if (!is_ok (&error))
13162                                         goto failure_unlocked;
13163                                 check_array_for_usertypes (mb->parameters, &error);
13164                                 if (!is_ok (&error))
13165                                         goto failure_unlocked;
13166                                 if (mb->param_modreq)
13167                                         for (j = 0; j < mono_array_length (mb->param_modreq); ++j) {
13168                                                 check_array_for_usertypes (mono_array_get (mb->param_modreq, MonoArray*, j), &error);
13169                                                 if (!is_ok (&error))
13170                                                         goto failure_unlocked;
13171                                         }
13172                                 if (mb->param_modopt)
13173                                         for (j = 0; j < mono_array_length (mb->param_modopt); ++j) {
13174                                                 check_array_for_usertypes (mono_array_get (mb->param_modopt, MonoArray*, j), &error);
13175                                                 if (!is_ok (&error))
13176                                                         goto failure_unlocked;
13177                                         }
13178                         }
13179                 }
13180         }
13181         if (tb->ctors) {
13182                 for (i = 0; i < mono_array_length (tb->ctors); ++i) {
13183                         MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)mono_array_get (tb->ctors, gpointer, i);
13184                         if (mb) {
13185                                 check_array_for_usertypes (mb->parameters, &error);
13186                                 if (!is_ok (&error))
13187                                         goto failure_unlocked;
13188                                 if (mb->param_modreq)
13189                                         for (j = 0; j < mono_array_length (mb->param_modreq); ++j) {
13190                                                 check_array_for_usertypes (mono_array_get (mb->param_modreq, MonoArray*, j), &error);
13191                                                 if (!is_ok (&error))
13192                                                         goto failure_unlocked;
13193                                         }
13194                                 if (mb->param_modopt)
13195                                         for (j = 0; j < mono_array_length (mb->param_modopt); ++j) {
13196                                                 check_array_for_usertypes (mono_array_get (mb->param_modopt, MonoArray*, j), &error);
13197                                                 if (!is_ok (&error))
13198                                                         goto failure_unlocked;
13199                                         }
13200                         }
13201                 }
13202         }
13203
13204         mono_save_custom_attrs (klass->image, klass, tb->cattrs);
13205
13206         /*
13207          * we need to lock the domain because the lock will be taken inside
13208          * So, we need to keep the locking order correct.
13209          */
13210         mono_loader_lock ();
13211         mono_domain_lock (domain);
13212         if (klass->wastypebuilder) {
13213                 mono_domain_unlock (domain);
13214                 mono_loader_unlock ();
13215
13216                 res = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
13217                 mono_error_set_pending_exception (&error);
13218
13219                 return res;
13220         }
13221         /*
13222          * Fields to set in klass:
13223          * the various flags: delegate/unicode/contextbound etc.
13224          */
13225         klass->flags = tb->attrs;
13226         klass->has_cctor = 1;
13227         klass->has_finalize = 1;
13228         klass->has_finalize_inited = 1;
13229
13230         mono_class_setup_parent (klass, klass->parent);
13231         /* fool mono_class_setup_supertypes */
13232         klass->supertypes = NULL;
13233         mono_class_setup_supertypes (klass);
13234         mono_class_setup_mono_type (klass);
13235
13236 #if 0
13237         if (!((MonoDynamicImage*)klass->image)->run) {
13238                 if (klass->generic_container) {
13239                         /* FIXME: The code below can't handle generic classes */
13240                         klass->wastypebuilder = TRUE;
13241                         mono_loader_unlock ();
13242                         mono_domain_unlock (domain);
13243
13244                         res = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
13245                         mono_error_set_pending_exception (&error);
13246
13247                         return res;
13248                 }
13249         }
13250 #endif
13251
13252         /* enums are done right away */
13253         if (!klass->enumtype)
13254                 if (!ensure_runtime_vtable (klass, &error))
13255                         goto failure;
13256
13257         if (tb->subtypes) {
13258                 for (i = 0; i < mono_array_length (tb->subtypes); ++i) {
13259                         MonoReflectionTypeBuilder *subtb = mono_array_get (tb->subtypes, MonoReflectionTypeBuilder*, i);
13260                         mono_class_alloc_ext (klass);
13261                         MonoType *subtype = mono_reflection_type_get_handle ((MonoReflectionType*)subtb, &error);
13262                         if (!is_ok (&error)) goto failure;
13263                         klass->ext->nested_classes = g_list_prepend_image (klass->image, klass->ext->nested_classes, mono_class_from_mono_type (subtype));
13264                 }
13265         }
13266
13267         klass->nested_classes_inited = TRUE;
13268
13269         /* fields and object layout */
13270         if (klass->parent) {
13271                 if (!klass->parent->size_inited)
13272                         mono_class_init (klass->parent);
13273                 klass->instance_size = klass->parent->instance_size;
13274                 klass->sizes.class_size = 0;
13275                 klass->min_align = klass->parent->min_align;
13276                 /* if the type has no fields we won't call the field_setup
13277                  * routine which sets up klass->has_references.
13278                  */
13279                 klass->has_references |= klass->parent->has_references;
13280         } else {
13281                 klass->instance_size = sizeof (MonoObject);
13282                 klass->min_align = 1;
13283         }
13284
13285         /* FIXME: handle packing_size and instance_size */
13286         typebuilder_setup_fields (klass, &error);
13287         if (!mono_error_ok (&error))
13288                 goto failure;
13289         typebuilder_setup_properties (klass, &error);
13290         if (!mono_error_ok (&error))
13291                 goto failure;
13292
13293         typebuilder_setup_events (klass, &error);
13294         if (!mono_error_ok (&error))
13295                 goto failure;
13296
13297         klass->wastypebuilder = TRUE;
13298
13299         /*
13300          * If we are a generic TypeBuilder, there might be instantiations in the type cache
13301          * which have type System.Reflection.MonoGenericClass, but after the type is created,
13302          * we want to return normal System.MonoType objects, so clear these out from the cache.
13303          *
13304          * Together with this we must ensure the contents of all instances to match the created type.
13305          */
13306         if (domain->type_hash && klass->generic_container) {
13307                 struct remove_instantiations_user_data data;
13308                 data.klass = klass;
13309                 data.error = &error;
13310                 mono_error_assert_ok (&error);
13311                 mono_g_hash_table_foreach_remove (domain->type_hash, remove_instantiations_of_and_ensure_contents, &data);
13312                 if (!is_ok (&error))
13313                         goto failure;
13314         }
13315
13316         mono_domain_unlock (domain);
13317         mono_loader_unlock ();
13318
13319         if (klass->enumtype && !mono_class_is_valid_enum (klass)) {
13320                 mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
13321                 mono_error_set_type_load_class (&error, klass, "Not a valid enumeration");
13322                 goto failure_unlocked;
13323         }
13324
13325         res = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error);
13326         if (!is_ok (&error))
13327                 goto failure_unlocked;
13328
13329         g_assert (res != (MonoReflectionType*)tb);
13330
13331         return res;
13332
13333 failure:
13334         mono_class_set_failure (klass, MONO_EXCEPTION_TYPE_LOAD, NULL);
13335         klass->wastypebuilder = TRUE;
13336         mono_domain_unlock (domain);
13337         mono_loader_unlock ();
13338 failure_unlocked:
13339         mono_error_set_pending_exception (&error);
13340         return NULL;
13341 }
13342
13343 static gboolean
13344 reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam, MonoError *error)
13345 {
13346         MonoGenericParamFull *param;
13347         MonoImage *image;
13348         MonoClass *pklass;
13349
13350         mono_error_init (error);
13351
13352         image = &gparam->tbuilder->module->dynamic_image->image;
13353
13354         param = mono_image_new0 (image, MonoGenericParamFull, 1);
13355
13356         param->info.name = mono_string_to_utf8_image (image, gparam->name, error);
13357         mono_error_assert_ok (error);
13358         param->param.num = gparam->index;
13359
13360         if (gparam->mbuilder) {
13361                 if (!gparam->mbuilder->generic_container) {
13362                         MonoType *tb = mono_reflection_type_get_handle ((MonoReflectionType*)gparam->mbuilder->type, error);
13363                         return_val_if_nok (error, FALSE);
13364
13365                         MonoClass *klass = mono_class_from_mono_type (tb);
13366                         gparam->mbuilder->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
13367                         gparam->mbuilder->generic_container->is_method = TRUE;
13368                         /*
13369                          * Cannot set owner.method, since the MonoMethod is not created yet.
13370                          * Set the image field instead, so type_in_image () works.
13371                          */
13372                         gparam->mbuilder->generic_container->is_anonymous = TRUE;
13373                         gparam->mbuilder->generic_container->owner.image = klass->image;
13374                 }
13375                 param->param.owner = gparam->mbuilder->generic_container;
13376         } else if (gparam->tbuilder) {
13377                 if (!gparam->tbuilder->generic_container) {
13378                         MonoType *tb = mono_reflection_type_get_handle ((MonoReflectionType*)gparam->tbuilder, error);
13379                         return_val_if_nok (error, FALSE);
13380                         MonoClass *klass = mono_class_from_mono_type (tb);
13381                         gparam->tbuilder->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
13382                         gparam->tbuilder->generic_container->owner.klass = klass;
13383                 }
13384                 param->param.owner = gparam->tbuilder->generic_container;
13385         }
13386
13387         pklass = mono_class_from_generic_parameter_internal ((MonoGenericParam *) param);
13388
13389         gparam->type.type = &pklass->byval_arg;
13390
13391         mono_class_set_ref_info (pklass, gparam);
13392         mono_image_append_class_to_reflection_info_set (pklass);
13393
13394         return TRUE;
13395 }
13396
13397 void
13398 mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam)
13399 {
13400         MonoError error;
13401         (void) reflection_initialize_generic_parameter (gparam, &error);
13402         mono_error_set_pending_exception (&error);
13403 }
13404
13405
13406 MonoArray *
13407 mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
13408 {
13409         MonoError error;
13410         MonoReflectionModuleBuilder *module = sig->module;
13411         MonoDynamicImage *assembly = module != NULL ? module->dynamic_image : NULL;
13412         guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
13413         guint32 buflen, i;
13414         MonoArray *result;
13415         SigBuffer buf;
13416
13417         check_array_for_usertypes (sig->arguments, &error);
13418         mono_error_raise_exception (&error); /* FIXME: don't raise here */
13419
13420         sigbuffer_init (&buf, 32);
13421
13422         sigbuffer_add_value (&buf, 0x07);
13423         sigbuffer_add_value (&buf, na);
13424         if (assembly != NULL){
13425                 for (i = 0; i < na; ++i) {
13426                         MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType*, i);
13427                         encode_reflection_type (assembly, type, &buf, &error);
13428                         if (!is_ok (&error)) goto fail;
13429                 }
13430         }
13431
13432         buflen = buf.p - buf.buf;
13433         result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
13434         memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
13435         sigbuffer_free (&buf);
13436         return result;
13437 fail:
13438         sigbuffer_free (&buf);
13439         mono_error_raise_exception (&error); /* FIXME don't raise here */
13440         return NULL;
13441 }
13442
13443 MonoArray *
13444 mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
13445 {
13446         MonoError error;
13447         MonoDynamicImage *assembly = sig->module->dynamic_image;
13448         guint32 na = sig->arguments ? mono_array_length (sig->arguments) : 0;
13449         guint32 buflen, i;
13450         MonoArray *result;
13451         SigBuffer buf;
13452
13453         check_array_for_usertypes (sig->arguments, &error);
13454         mono_error_raise_exception (&error); /* FIXME: don't raise here */
13455
13456         sigbuffer_init (&buf, 32);
13457
13458         sigbuffer_add_value (&buf, 0x06);
13459         for (i = 0; i < na; ++i) {
13460                 MonoReflectionType *type = mono_array_get (sig->arguments, MonoReflectionType*, i);
13461                 encode_reflection_type (assembly, type, &buf, &error);
13462                 if (!is_ok (&error))
13463                         goto fail;
13464         }
13465
13466         buflen = buf.p - buf.buf;
13467         result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, buflen);
13468         memcpy (mono_array_addr (result, char, 0), buf.buf, buflen);
13469         sigbuffer_free (&buf);
13470
13471         return result;
13472 fail:
13473         sigbuffer_free (&buf);
13474         mono_error_raise_exception (&error); /* FIXME don't raise here */
13475         return NULL;
13476 }
13477
13478 typedef struct {
13479         MonoMethod *handle;
13480         MonoDomain *domain;
13481 } DynamicMethodReleaseData;
13482
13483 /*
13484  * The runtime automatically clean up those after finalization.
13485 */
13486 static MonoReferenceQueue *dynamic_method_queue;
13487
13488 static void
13489 free_dynamic_method (void *dynamic_method)
13490 {
13491         DynamicMethodReleaseData *data = (DynamicMethodReleaseData *)dynamic_method;
13492         MonoDomain *domain = data->domain;
13493         MonoMethod *method = data->handle;
13494         guint32 dis_link;
13495
13496         mono_domain_lock (domain);
13497         dis_link = (guint32)(size_t)g_hash_table_lookup (domain->method_to_dyn_method, method);
13498         g_hash_table_remove (domain->method_to_dyn_method, method);
13499         mono_domain_unlock (domain);
13500         g_assert (dis_link);
13501         mono_gchandle_free (dis_link);
13502
13503         mono_runtime_free_method (domain, method);
13504         g_free (data);
13505 }
13506
13507 static gboolean
13508 reflection_create_dynamic_method (MonoReflectionDynamicMethod *mb, MonoError *error)
13509 {
13510         MonoReferenceQueue *queue;
13511         MonoMethod *handle;
13512         DynamicMethodReleaseData *release_data;
13513         ReflectionMethodBuilder rmb;
13514         MonoMethodSignature *sig;
13515         MonoClass *klass;
13516         MonoDomain *domain;
13517         GSList *l;
13518         int i;
13519
13520         mono_error_init (error);
13521
13522         if (mono_runtime_is_shutting_down ()) {
13523                 mono_error_set_generic_error (error, "System", "InvalidOperationException", "");
13524                 return FALSE;
13525         }
13526
13527         if (!(queue = dynamic_method_queue)) {
13528                 mono_loader_lock ();
13529                 if (!(queue = dynamic_method_queue))
13530                         queue = dynamic_method_queue = mono_gc_reference_queue_new (free_dynamic_method);
13531                 mono_loader_unlock ();
13532         }
13533
13534         sig = dynamic_method_to_signature (mb, error);
13535         return_val_if_nok (error, FALSE);
13536
13537         reflection_methodbuilder_from_dynamic_method (&rmb, mb);
13538
13539         /*
13540          * Resolve references.
13541          */
13542         /*
13543          * Every second entry in the refs array is reserved for storing handle_class,
13544          * which is needed by the ldtoken implementation in the JIT.
13545          */
13546         rmb.nrefs = mb->nrefs;
13547         rmb.refs = g_new0 (gpointer, mb->nrefs + 1);
13548         for (i = 0; i < mb->nrefs; i += 2) {
13549                 MonoClass *handle_class;
13550                 gpointer ref;
13551                 MonoObject *obj = mono_array_get (mb->refs, MonoObject*, i);
13552
13553                 if (strcmp (obj->vtable->klass->name, "DynamicMethod") == 0) {
13554                         MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)obj;
13555                         /*
13556                          * The referenced DynamicMethod should already be created by the managed
13557                          * code, except in the case of circular references. In that case, we store
13558                          * method in the refs array, and fix it up later when the referenced
13559                          * DynamicMethod is created.
13560                          */
13561                         if (method->mhandle) {
13562                                 ref = method->mhandle;
13563                         } else {
13564                                 /* FIXME: GC object stored in unmanaged memory */
13565                                 ref = method;
13566
13567                                 /* FIXME: GC object stored in unmanaged memory */
13568                                 method->referenced_by = g_slist_append (method->referenced_by, mb);
13569                         }
13570                         handle_class = mono_defaults.methodhandle_class;
13571                 } else {
13572                         MonoException *ex = NULL;
13573                         ref = resolve_object (mb->module->image, obj, &handle_class, NULL, error);
13574                         if (!is_ok  (error)) {
13575                                 g_free (rmb.refs);
13576                                 return FALSE;
13577                         }
13578                         if (!ref)
13579                                 ex = mono_get_exception_type_load (NULL, NULL);
13580                         else if (mono_security_core_clr_enabled ())
13581                                 ex = mono_security_core_clr_ensure_dynamic_method_resolved_object (ref, handle_class);
13582
13583                         if (ex) {
13584                                 g_free (rmb.refs);
13585                                 mono_error_set_exception_instance (error, ex);
13586                                 return FALSE;
13587                         }
13588                 }
13589
13590                 rmb.refs [i] = ref; /* FIXME: GC object stored in unmanaged memory (change also resolve_object() signature) */
13591                 rmb.refs [i + 1] = handle_class;
13592         }
13593
13594         if (mb->owner) {
13595                 MonoType *owner_type = mono_reflection_type_get_handle ((MonoReflectionType*)mb->owner, error);
13596                 if (!is_ok (error)) {
13597                         g_free (rmb.refs);
13598                         return FALSE;
13599                 }
13600                 klass = mono_class_from_mono_type (owner_type);
13601         } else {
13602                 klass = mono_defaults.object_class;
13603         }
13604
13605         mb->mhandle = handle = reflection_methodbuilder_to_mono_method (klass, &rmb, sig);
13606         release_data = g_new (DynamicMethodReleaseData, 1);
13607         release_data->handle = handle;
13608         release_data->domain = mono_object_get_domain ((MonoObject*)mb);
13609         if (!mono_gc_reference_queue_add (queue, (MonoObject*)mb, release_data))
13610                 g_free (release_data);
13611
13612         /* Fix up refs entries pointing at us */
13613         for (l = mb->referenced_by; l; l = l->next) {
13614                 MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)l->data;
13615                 MonoMethodWrapper *wrapper = (MonoMethodWrapper*)method->mhandle;
13616                 gpointer *data;
13617
13618                 g_assert (method->mhandle);
13619
13620                 data = (gpointer*)wrapper->method_data;
13621                 for (i = 0; i < GPOINTER_TO_UINT (data [0]); i += 2) {
13622                         if ((data [i + 1] == mb) && (data [i + 1 + 1] == mono_defaults.methodhandle_class))
13623                                 data [i + 1] = mb->mhandle;
13624                 }
13625         }
13626         g_slist_free (mb->referenced_by);
13627
13628         g_free (rmb.refs);
13629
13630         /* ilgen is no longer needed */
13631         mb->ilgen = NULL;
13632
13633         domain = mono_domain_get ();
13634         mono_domain_lock (domain);
13635         if (!domain->method_to_dyn_method)
13636                 domain->method_to_dyn_method = g_hash_table_new (NULL, NULL);
13637         g_hash_table_insert (domain->method_to_dyn_method, handle, (gpointer)(size_t)mono_gchandle_new_weakref ((MonoObject *)mb, TRUE));
13638         mono_domain_unlock (domain);
13639
13640         return TRUE;
13641 }
13642
13643 void
13644 mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *mb)
13645 {
13646         MonoError error;
13647         (void) reflection_create_dynamic_method (mb, &error);
13648         mono_error_set_pending_exception (&error);
13649 }
13650
13651 #endif /* DISABLE_REFLECTION_EMIT */
13652
13653 /**
13654  *
13655  * mono_reflection_is_valid_dynamic_token:
13656  *
13657  * Returns TRUE if token is valid.
13658  *
13659  */
13660 gboolean
13661 mono_reflection_is_valid_dynamic_token (MonoDynamicImage *image, guint32 token)
13662 {
13663         return lookup_dyn_token (image, token) != NULL;
13664 }
13665
13666 MonoMethodSignature *
13667 mono_reflection_lookup_signature (MonoImage *image, MonoMethod *method, guint32 token, MonoError *error)
13668 {
13669         MonoMethodSignature *sig;
13670         g_assert (image_is_dynamic (image));
13671
13672         mono_error_init (error);
13673
13674         sig = (MonoMethodSignature *)g_hash_table_lookup (((MonoDynamicImage*)image)->vararg_aux_hash, GUINT_TO_POINTER (token));
13675         if (sig)
13676                 return sig;
13677
13678         return mono_method_signature_checked (method, error);
13679 }
13680
13681 #ifndef DISABLE_REFLECTION_EMIT
13682
13683 /**
13684  * mono_reflection_lookup_dynamic_token:
13685  *
13686  * Finish the Builder object pointed to by TOKEN and return the corresponding
13687  * runtime structure. If HANDLE_CLASS is not NULL, it is set to the class required by
13688  * mono_ldtoken. If valid_token is TRUE, assert if it is not found in the token->object
13689  * mapping table.
13690  *
13691  * LOCKING: Take the loader lock
13692  */
13693 gpointer
13694 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
13695 {
13696         MonoError error;
13697         MonoDynamicImage *assembly = (MonoDynamicImage*)image;
13698         MonoObject *obj;
13699         MonoClass *klass;
13700
13701         obj = lookup_dyn_token (assembly, token);
13702         if (!obj) {
13703                 if (valid_token)
13704                         g_error ("Could not find required dynamic token 0x%08x", token);
13705                 else
13706                         return NULL;
13707         }
13708
13709         if (!handle_class)
13710                 handle_class = &klass;
13711         gpointer result = resolve_object (image, obj, handle_class, context, &error);
13712         mono_error_raise_exception (&error); /* FIXME don't raise here */
13713         return result;
13714 }
13715
13716 /*
13717  * ensure_complete_type:
13718  *
13719  *   Ensure that KLASS is completed if it is a dynamic type, or references
13720  * dynamic types.
13721  */
13722 static void
13723 ensure_complete_type (MonoClass *klass, MonoError *error)
13724 {
13725         mono_error_init (error);
13726
13727         if (image_is_dynamic (klass->image) && !klass->wastypebuilder && mono_class_get_ref_info (klass)) {
13728                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mono_class_get_ref_info (klass);
13729
13730                 mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error);
13731                 return_if_nok (error);
13732
13733                 // Asserting here could break a lot of code
13734                 //g_assert (klass->wastypebuilder);
13735         }
13736
13737         if (klass->generic_class) {
13738                 MonoGenericInst *inst = klass->generic_class->context.class_inst;
13739                 int i;
13740
13741                 for (i = 0; i < inst->type_argc; ++i) {
13742                         ensure_complete_type (mono_class_from_mono_type (inst->type_argv [i]), error);
13743                         return_if_nok (error);
13744                 }
13745         }
13746 }
13747
13748 static gpointer
13749 resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context, MonoError *error)
13750 {
13751         gpointer result = NULL;
13752
13753         mono_error_init (error);
13754
13755         if (strcmp (obj->vtable->klass->name, "String") == 0) {
13756                 result = mono_string_intern_checked ((MonoString*)obj, error);
13757                 return_val_if_nok (error, NULL);
13758                 *handle_class = mono_defaults.string_class;
13759                 g_assert (result);
13760         } else if (strcmp (obj->vtable->klass->name, "MonoType") == 0) {
13761                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error);
13762                 return_val_if_nok (error, NULL);
13763                 MonoClass *mc = mono_class_from_mono_type (type);
13764                 if (!mono_class_init (mc)) {
13765                         mono_error_set_exception_instance (error, mono_class_get_exception_for_failure (mc));
13766                         return NULL;
13767                 }
13768
13769                 if (context) {
13770                         MonoType *inflated = mono_class_inflate_generic_type_checked (type, context, error);
13771                         return_val_if_nok (error, NULL);
13772
13773                         result = mono_class_from_mono_type (inflated);
13774                         mono_metadata_free_type (inflated);
13775                 } else {
13776                         result = mono_class_from_mono_type (type);
13777                 }
13778                 *handle_class = mono_defaults.typehandle_class;
13779                 g_assert (result);
13780         } else if (strcmp (obj->vtable->klass->name, "MonoMethod") == 0 ||
13781                    strcmp (obj->vtable->klass->name, "MonoCMethod") == 0 ||
13782                    strcmp (obj->vtable->klass->name, "MonoGenericCMethod") == 0 ||
13783                    strcmp (obj->vtable->klass->name, "MonoGenericMethod") == 0) {
13784                 result = ((MonoReflectionMethod*)obj)->method;
13785                 if (context) {
13786                         result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error);
13787                         mono_error_assert_ok (error);
13788                 }
13789                 *handle_class = mono_defaults.methodhandle_class;
13790                 g_assert (result);
13791         } else if (strcmp (obj->vtable->klass->name, "MethodBuilder") == 0) {
13792                 MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)obj;
13793                 result = mb->mhandle;
13794                 if (!result) {
13795                         /* Type is not yet created */
13796                         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type;
13797
13798                         mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error);
13799                         return_val_if_nok (error, NULL);
13800
13801                         /*
13802                          * Hopefully this has been filled in by calling CreateType() on the
13803                          * TypeBuilder.
13804                          */
13805                         /*
13806                          * TODO: This won't work if the application finishes another
13807                          * TypeBuilder instance instead of this one.
13808                          */
13809                         result = mb->mhandle;
13810                 }
13811                 if (context) {
13812                         result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error);
13813                         mono_error_assert_ok (error);
13814                 }
13815                 *handle_class = mono_defaults.methodhandle_class;
13816         } else if (strcmp (obj->vtable->klass->name, "ConstructorBuilder") == 0) {
13817                 MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder*)obj;
13818
13819                 result = cb->mhandle;
13820                 if (!result) {
13821                         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)cb->type;
13822
13823                         mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error);
13824                         return_val_if_nok (error, NULL);
13825                         result = cb->mhandle;
13826                 }
13827                 if (context) {
13828                         result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error);
13829                         mono_error_assert_ok (error);
13830                 }
13831                 *handle_class = mono_defaults.methodhandle_class;
13832         } else if (strcmp (obj->vtable->klass->name, "MonoField") == 0) {
13833                 MonoClassField *field = ((MonoReflectionField*)obj)->field;
13834
13835                 ensure_complete_type (field->parent, error);
13836                 return_val_if_nok (error, NULL);
13837
13838                 if (context) {
13839                         MonoType *inflated = mono_class_inflate_generic_type_checked (&field->parent->byval_arg, context, error);
13840                         return_val_if_nok (error, NULL);
13841
13842                         MonoClass *klass = mono_class_from_mono_type (inflated);
13843                         MonoClassField *inflated_field;
13844                         gpointer iter = NULL;
13845                         mono_metadata_free_type (inflated);
13846                         while ((inflated_field = mono_class_get_fields (klass, &iter))) {
13847                                 if (!strcmp (field->name, inflated_field->name))
13848                                         break;
13849                         }
13850                         g_assert (inflated_field && !strcmp (field->name, inflated_field->name));
13851                         result = inflated_field;
13852                 } else {
13853                         result = field;
13854                 }
13855                 *handle_class = mono_defaults.fieldhandle_class;
13856                 g_assert (result);
13857         } else if (strcmp (obj->vtable->klass->name, "FieldBuilder") == 0) {
13858                 MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder*)obj;
13859                 result = fb->handle;
13860
13861                 if (!result) {
13862                         MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)fb->typeb;
13863
13864                         mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error);
13865                         return_val_if_nok (error, NULL);
13866                         result = fb->handle;
13867                 }
13868
13869                 if (fb->handle && fb->handle->parent->generic_container) {
13870                         MonoClass *klass = fb->handle->parent;
13871                         MonoType *type = mono_class_inflate_generic_type_checked (&klass->byval_arg, context, error);
13872                         return_val_if_nok (error, NULL);
13873
13874                         MonoClass *inflated = mono_class_from_mono_type (type);
13875
13876                         result = mono_class_get_field_from_name (inflated, mono_field_get_name (fb->handle));
13877                         g_assert (result);
13878                         mono_metadata_free_type (type);
13879                 }
13880                 *handle_class = mono_defaults.fieldhandle_class;
13881         } else if (strcmp (obj->vtable->klass->name, "TypeBuilder") == 0) {
13882                 MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)obj;
13883                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error);
13884                 return_val_if_nok (error, NULL);
13885                 MonoClass *klass;
13886
13887                 klass = type->data.klass;
13888                 if (klass->wastypebuilder) {
13889                         /* Already created */
13890                         result = klass;
13891                 }
13892                 else {
13893                         mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error);
13894                         return_val_if_nok (error, NULL);
13895                         result = type->data.klass;
13896                         g_assert (result);
13897                 }
13898                 *handle_class = mono_defaults.typehandle_class;
13899         } else if (strcmp (obj->vtable->klass->name, "SignatureHelper") == 0) {
13900                 MonoReflectionSigHelper *helper = (MonoReflectionSigHelper*)obj;
13901                 MonoMethodSignature *sig;
13902                 int nargs, i;
13903
13904                 if (helper->arguments)
13905                         nargs = mono_array_length (helper->arguments);
13906                 else
13907                         nargs = 0;
13908
13909                 sig = mono_metadata_signature_alloc (image, nargs);
13910                 sig->explicit_this = helper->call_conv & 64 ? 1 : 0;
13911                 sig->hasthis = helper->call_conv & 32 ? 1 : 0;
13912
13913                 if (helper->unmanaged_call_conv) { /* unmanaged */
13914                         sig->call_convention = helper->unmanaged_call_conv - 1;
13915                         sig->pinvoke = TRUE;
13916                 } else if (helper->call_conv & 0x02) {
13917                         sig->call_convention = MONO_CALL_VARARG;
13918                 } else {
13919                         sig->call_convention = MONO_CALL_DEFAULT;
13920                 }
13921
13922                 sig->param_count = nargs;
13923                 /* TODO: Copy type ? */
13924                 sig->ret = helper->return_type->type;
13925                 for (i = 0; i < nargs; ++i) {
13926                         sig->params [i] = mono_type_array_get_and_resolve (helper->arguments, i, error);
13927                         if (!is_ok (error)) {
13928                                 image_g_free (image, sig);
13929                                 return NULL;
13930                         }
13931                 }
13932
13933                 result = sig;
13934                 *handle_class = NULL;
13935         } else if (strcmp (obj->vtable->klass->name, "DynamicMethod") == 0) {
13936                 MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)obj;
13937                 /* Already created by the managed code */
13938                 g_assert (method->mhandle);
13939                 result = method->mhandle;
13940                 *handle_class = mono_defaults.methodhandle_class;
13941         } else if (strcmp (obj->vtable->klass->name, "GenericTypeParameterBuilder") == 0) {
13942                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error);
13943                 return_val_if_nok (error, NULL);
13944                 type = mono_class_inflate_generic_type_checked (type, context, error);
13945                 return_val_if_nok (error, NULL);
13946
13947                 result = mono_class_from_mono_type (type);
13948                 *handle_class = mono_defaults.typehandle_class;
13949                 g_assert (result);
13950                 mono_metadata_free_type (type);
13951         } else if (strcmp (obj->vtable->klass->name, "MonoGenericClass") == 0) {
13952                 MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error);
13953                 return_val_if_nok (error, NULL);
13954                 type = mono_class_inflate_generic_type_checked (type, context, error);
13955                 return_val_if_nok (error, NULL);
13956
13957                 result = mono_class_from_mono_type (type);
13958                 *handle_class = mono_defaults.typehandle_class;
13959                 g_assert (result);
13960                 mono_metadata_free_type (type);
13961         } else if (strcmp (obj->vtable->klass->name, "FieldOnTypeBuilderInst") == 0) {
13962                 MonoReflectionFieldOnTypeBuilderInst *f = (MonoReflectionFieldOnTypeBuilderInst*)obj;
13963                 MonoClass *inflated;
13964                 MonoType *type;
13965                 MonoClassField *field;
13966
13967                 if (is_sre_field_builder (mono_object_class (f->fb)))
13968                         field = ((MonoReflectionFieldBuilder*)f->fb)->handle;
13969                 else if (is_sr_mono_field (mono_object_class (f->fb)))
13970                         field = ((MonoReflectionField*)f->fb)->field;
13971                 else
13972                         g_error ("resolve_object:: can't handle a FTBI with base_method of type %s", mono_type_get_full_name (mono_object_class (f->fb)));
13973
13974                 MonoType *finst = mono_reflection_type_get_handle ((MonoReflectionType*)f->inst, error);
13975                 return_val_if_nok (error, NULL);
13976                 type = mono_class_inflate_generic_type_checked (finst, context, error);
13977                 return_val_if_nok (error, NULL);
13978
13979                 inflated = mono_class_from_mono_type (type);
13980
13981                 result = field = mono_class_get_field_from_name (inflated, mono_field_get_name (field));
13982                 ensure_complete_type (field->parent, error);
13983                 if (!is_ok (error)) {
13984                         mono_metadata_free_type (type);
13985                         return NULL;
13986                 }
13987
13988                 g_assert (result);
13989                 mono_metadata_free_type (type);
13990                 *handle_class = mono_defaults.fieldhandle_class;
13991         } else if (strcmp (obj->vtable->klass->name, "ConstructorOnTypeBuilderInst") == 0) {
13992                 MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)obj;
13993                 MonoType *cinst = mono_reflection_type_get_handle ((MonoReflectionType*)c->inst, error);
13994                 return_val_if_nok (error, NULL);
13995                 MonoType *type = mono_class_inflate_generic_type_checked (cinst, context, error);
13996                 return_val_if_nok (error, NULL);
13997
13998                 MonoClass *inflated_klass = mono_class_from_mono_type (type);
13999                 MonoMethod *method;
14000
14001                 if (is_sre_ctor_builder (mono_object_class (c->cb)))
14002                         method = ((MonoReflectionCtorBuilder *)c->cb)->mhandle;
14003                 else if (is_sr_mono_cmethod (mono_object_class (c->cb)))
14004                         method = ((MonoReflectionMethod *)c->cb)->method;
14005                 else
14006                         g_error ("resolve_object:: can't handle a CTBI with base_method of type %s", mono_type_get_full_name (mono_object_class (c->cb)));
14007
14008                 result = inflate_mono_method (inflated_klass, method, (MonoObject*)c->cb);
14009                 *handle_class = mono_defaults.methodhandle_class;
14010                 mono_metadata_free_type (type);
14011         } else if (strcmp (obj->vtable->klass->name, "MethodOnTypeBuilderInst") == 0) {
14012                 MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj;
14013                 if (m->method_args) {
14014                         result = mono_reflection_method_on_tb_inst_get_handle (m, error);
14015                         return_val_if_nok (error, NULL);
14016                         if (context) {
14017                                 result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error);
14018                                 mono_error_assert_ok (error);
14019                         }
14020                 } else {
14021                         MonoType *minst = mono_reflection_type_get_handle ((MonoReflectionType*)m->inst, error);
14022                         return_val_if_nok (error, NULL);
14023                         MonoType *type = mono_class_inflate_generic_type_checked (minst, context, error);
14024                         return_val_if_nok (error, NULL);
14025
14026                         MonoClass *inflated_klass = mono_class_from_mono_type (type);
14027                         MonoMethod *method;
14028
14029                         if (is_sre_method_builder (mono_object_class (m->mb)))
14030                                 method = ((MonoReflectionMethodBuilder *)m->mb)->mhandle;
14031                         else if (is_sr_mono_method (mono_object_class (m->mb)))
14032                                 method = ((MonoReflectionMethod *)m->mb)->method;
14033                         else
14034                                 g_error ("resolve_object:: can't handle a MTBI with base_method of type %s", mono_type_get_full_name (mono_object_class (m->mb)));
14035
14036                         result = inflate_mono_method (inflated_klass, method, (MonoObject*)m->mb);
14037                         mono_metadata_free_type (type);
14038                 }
14039                 *handle_class = mono_defaults.methodhandle_class;
14040         } else if (strcmp (obj->vtable->klass->name, "MonoArrayMethod") == 0) {
14041                 MonoReflectionArrayMethod *m = (MonoReflectionArrayMethod*)obj;
14042                 MonoType *mtype;
14043                 MonoClass *klass;
14044                 MonoMethod *method;
14045                 gpointer iter;
14046                 char *name;
14047
14048                 mtype = mono_reflection_type_get_handle (m->parent, error);
14049                 return_val_if_nok (error, NULL);
14050                 klass = mono_class_from_mono_type (mtype);
14051
14052                 /* Find the method */
14053
14054                 name = mono_string_to_utf8 (m->name);
14055                 iter = NULL;
14056                 while ((method = mono_class_get_methods (klass, &iter))) {
14057                         if (!strcmp (method->name, name))
14058                                 break;
14059                 }
14060                 g_free (name);
14061
14062                 // FIXME:
14063                 g_assert (method);
14064                 // FIXME: Check parameters/return value etc. match
14065
14066                 result = method;
14067                 *handle_class = mono_defaults.methodhandle_class;
14068         } else if (is_sre_array (mono_object_get_class(obj)) ||
14069                                 is_sre_byref (mono_object_get_class(obj)) ||
14070                                 is_sre_pointer (mono_object_get_class(obj))) {
14071                 MonoReflectionType *ref_type = (MonoReflectionType *)obj;
14072                 MonoType *type = mono_reflection_type_get_handle (ref_type, error);
14073                 return_val_if_nok (error, NULL);
14074
14075                 if (context) {
14076                         MonoType *inflated = mono_class_inflate_generic_type_checked (type, context, error);
14077                         return_val_if_nok (error, NULL);
14078
14079                         result = mono_class_from_mono_type (inflated);
14080                         mono_metadata_free_type (inflated);
14081                 } else {
14082                         result = mono_class_from_mono_type (type);
14083                 }
14084                 *handle_class = mono_defaults.typehandle_class;
14085         } else {
14086                 g_print ("%s\n", obj->vtable->klass->name);
14087                 g_assert_not_reached ();
14088         }
14089         return result;
14090 }
14091
14092 #else /* DISABLE_REFLECTION_EMIT */
14093
14094 MonoArray*
14095 mono_reflection_get_custom_attrs_blob (MonoReflectionAssembly *assembly, MonoObject *ctor, MonoArray *ctorArgs, MonoArray *properties, MonoArray *propValues, MonoArray *fields, MonoArray* fieldValues)
14096 {
14097         g_assert_not_reached ();
14098         return NULL;
14099 }
14100
14101 void
14102 mono_reflection_setup_internal_class (MonoReflectionTypeBuilder *tb)
14103 {
14104         g_assert_not_reached ();
14105 }
14106
14107 void
14108 mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb)
14109 {
14110         g_assert_not_reached ();
14111 }
14112
14113 void
14114 mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb)
14115 {
14116         g_assert_not_reached ();
14117 }
14118
14119 void
14120 mono_reflection_create_internal_class (MonoReflectionTypeBuilder *tb)
14121 {
14122         g_assert_not_reached ();
14123 }
14124
14125 void
14126 mono_image_basic_init (MonoReflectionAssemblyBuilder *assemblyb)
14127 {
14128         g_error ("This mono runtime was configured with --enable-minimal=reflection_emit, so System.Reflection.Emit is not supported.");
14129 }
14130
14131 void
14132 mono_image_module_basic_init (MonoReflectionModuleBuilder *moduleb)
14133 {
14134         g_assert_not_reached ();
14135 }
14136
14137 void
14138 mono_image_set_wrappers_type (MonoReflectionModuleBuilder *moduleb, MonoReflectionType *type)
14139 {
14140         g_assert_not_reached ();
14141 }
14142
14143 MonoReflectionModule *
14144 mono_image_load_module_dynamic (MonoReflectionAssemblyBuilder *ab, MonoString *fileName, MonoError *error)
14145 {
14146         g_assert_not_reached ();
14147         return NULL;
14148 }
14149
14150 guint32
14151 mono_image_insert_string (MonoReflectionModuleBuilder *module, MonoString *str)
14152 {
14153         g_assert_not_reached ();
14154         return 0;
14155 }
14156
14157 guint32
14158 mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, MonoArray *opt_param_types, MonoError *error)
14159 {
14160         g_assert_not_reached ();
14161         return 0;
14162 }
14163
14164 guint32
14165 mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj,
14166                          gboolean create_open_instance, gboolean register_token, MonoError *error)
14167 {
14168         g_assert_not_reached ();
14169         return 0;
14170 }
14171
14172 void
14173 mono_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObject *obj)
14174 {
14175 }
14176
14177 void
14178 mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields)
14179 {
14180         g_assert_not_reached ();
14181 }
14182
14183 void
14184 mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error)
14185 {
14186         mono_error_init (error);
14187         *overrides = NULL;
14188         *num_overrides = 0;
14189 }
14190
14191 MonoReflectionEvent *
14192 mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb)
14193 {
14194         g_assert_not_reached ();
14195         return NULL;
14196 }
14197
14198 MonoReflectionType*
14199 mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb)
14200 {
14201         g_assert_not_reached ();
14202         return NULL;
14203 }
14204
14205 void
14206 mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam)
14207 {
14208         g_assert_not_reached ();
14209 }
14210
14211 MonoArray *
14212 mono_reflection_sighelper_get_signature_local (MonoReflectionSigHelper *sig)
14213 {
14214         g_assert_not_reached ();
14215         return NULL;
14216 }
14217
14218 MonoArray *
14219 mono_reflection_sighelper_get_signature_field (MonoReflectionSigHelper *sig)
14220 {
14221         g_assert_not_reached ();
14222         return NULL;
14223 }
14224
14225 void
14226 mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *mb)
14227 {
14228 }
14229
14230 gpointer
14231 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context)
14232 {
14233         return NULL;
14234 }
14235
14236 MonoType*
14237 mono_reflection_type_get_handle (MonoReflectionType* ref, MonoError *error)
14238 {
14239         mono_error_init (error);
14240         if (!ref)
14241                 return NULL;
14242         return ref->type;
14243 }
14244
14245 void
14246 mono_reflection_free_dynamic_generic_class (MonoGenericClass *gclass)
14247 {
14248         g_assert_not_reached ();
14249 }
14250
14251 #endif /* DISABLE_REFLECTION_EMIT */
14252
14253 /* SECURITY_ACTION_* are defined in mono/metadata/tabledefs.h */
14254 const static guint32 declsec_flags_map[] = {
14255         0x00000000,                                     /* empty */
14256         MONO_DECLSEC_FLAG_REQUEST,                      /* SECURITY_ACTION_REQUEST                      (x01) */
14257         MONO_DECLSEC_FLAG_DEMAND,                       /* SECURITY_ACTION_DEMAND                       (x02) */
14258         MONO_DECLSEC_FLAG_ASSERT,                       /* SECURITY_ACTION_ASSERT                       (x03) */
14259         MONO_DECLSEC_FLAG_DENY,                         /* SECURITY_ACTION_DENY                         (x04) */
14260         MONO_DECLSEC_FLAG_PERMITONLY,                   /* SECURITY_ACTION_PERMITONLY                   (x05) */
14261         MONO_DECLSEC_FLAG_LINKDEMAND,                   /* SECURITY_ACTION_LINKDEMAND                   (x06) */
14262         MONO_DECLSEC_FLAG_INHERITANCEDEMAND,            /* SECURITY_ACTION_INHERITANCEDEMAND            (x07) */
14263         MONO_DECLSEC_FLAG_REQUEST_MINIMUM,              /* SECURITY_ACTION_REQUEST_MINIMUM              (x08) */
14264         MONO_DECLSEC_FLAG_REQUEST_OPTIONAL,             /* SECURITY_ACTION_REQUEST_OPTIONAL             (x09) */
14265         MONO_DECLSEC_FLAG_REQUEST_REFUSE,               /* SECURITY_ACTION_REQUEST_REFUSE               (x0A) */
14266         MONO_DECLSEC_FLAG_PREJIT_GRANT,                 /* SECURITY_ACTION_PREJIT_GRANT                 (x0B) */
14267         MONO_DECLSEC_FLAG_PREJIT_DENY,                  /* SECURITY_ACTION_PREJIT_DENY                  (x0C) */
14268         MONO_DECLSEC_FLAG_NONCAS_DEMAND,                /* SECURITY_ACTION_NONCAS_DEMAND                (x0D) */
14269         MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND,            /* SECURITY_ACTION_NONCAS_LINKDEMAND            (x0E) */
14270         MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND,     /* SECURITY_ACTION_NONCAS_INHERITANCEDEMAND     (x0F) */
14271         MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE,            /* SECURITY_ACTION_LINKDEMAND_CHOICE            (x10) */
14272         MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE,     /* SECURITY_ACTION_INHERITANCEDEMAND_CHOICE     (x11) */
14273         MONO_DECLSEC_FLAG_DEMAND_CHOICE,                /* SECURITY_ACTION_DEMAND_CHOICE                (x12) */
14274 };
14275
14276 /*
14277  * Returns flags that includes all available security action associated to the handle.
14278  * @token: metadata token (either for a class or a method)
14279  * @image: image where resides the metadata.
14280  */
14281 static guint32
14282 mono_declsec_get_flags (MonoImage *image, guint32 token)
14283 {
14284         int index = mono_metadata_declsec_from_index (image, token);
14285         MonoTableInfo *t = &image->tables [MONO_TABLE_DECLSECURITY];
14286         guint32 result = 0;
14287         guint32 action;
14288         int i;
14289
14290         /* HasSecurity can be present for other, not specially encoded, attributes,
14291            e.g. SuppressUnmanagedCodeSecurityAttribute */
14292         if (index < 0)
14293                 return 0;
14294
14295         for (i = index; i < t->rows; i++) {
14296                 guint32 cols [MONO_DECL_SECURITY_SIZE];
14297
14298                 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
14299                 if (cols [MONO_DECL_SECURITY_PARENT] != token)
14300                         break;
14301
14302                 action = cols [MONO_DECL_SECURITY_ACTION];
14303                 if ((action >= MONO_DECLSEC_ACTION_MIN) && (action <= MONO_DECLSEC_ACTION_MAX)) {
14304                         result |= declsec_flags_map [action];
14305                 } else {
14306                         g_assert_not_reached ();
14307                 }
14308         }
14309         return result;
14310 }
14311
14312 /*
14313  * Get the security actions (in the form of flags) associated with the specified method.
14314  *
14315  * @method: The method for which we want the declarative security flags.
14316  * Return the declarative security flags for the method (only).
14317  *
14318  * Note: To keep MonoMethod size down we do not cache the declarative security flags
14319  *       (except for the stack modifiers which are kept in the MonoJitInfo structure)
14320  */
14321 guint32
14322 mono_declsec_flags_from_method (MonoMethod *method)
14323 {
14324         if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
14325                 /* FIXME: No cache (for the moment) */
14326                 guint32 idx = mono_method_get_index (method);
14327                 idx <<= MONO_HAS_DECL_SECURITY_BITS;
14328                 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
14329                 return mono_declsec_get_flags (method->klass->image, idx);
14330         }
14331         return 0;
14332 }
14333
14334 /*
14335  * Get the security actions (in the form of flags) associated with the specified class.
14336  *
14337  * @klass: The class for which we want the declarative security flags.
14338  * Return the declarative security flags for the class.
14339  *
14340  * Note: We cache the flags inside the MonoClass structure as this will get
14341  *       called very often (at least for each method).
14342  */
14343 guint32
14344 mono_declsec_flags_from_class (MonoClass *klass)
14345 {
14346         if (klass->flags & TYPE_ATTRIBUTE_HAS_SECURITY) {
14347                 if (!klass->ext || !klass->ext->declsec_flags) {
14348                         guint32 idx;
14349
14350                         idx = mono_metadata_token_index (klass->type_token);
14351                         idx <<= MONO_HAS_DECL_SECURITY_BITS;
14352                         idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
14353                         mono_loader_lock ();
14354                         mono_class_alloc_ext (klass);
14355                         mono_loader_unlock ();
14356                         /* we cache the flags on classes */
14357                         klass->ext->declsec_flags = mono_declsec_get_flags (klass->image, idx);
14358                 }
14359                 return klass->ext->declsec_flags;
14360         }
14361         return 0;
14362 }
14363
14364 /*
14365  * Get the security actions (in the form of flags) associated with the specified assembly.
14366  *
14367  * @assembly: The assembly for which we want the declarative security flags.
14368  * Return the declarative security flags for the assembly.
14369  */
14370 guint32
14371 mono_declsec_flags_from_assembly (MonoAssembly *assembly)
14372 {
14373         guint32 idx = 1; /* there is only one assembly */
14374         idx <<= MONO_HAS_DECL_SECURITY_BITS;
14375         idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
14376         return mono_declsec_get_flags (assembly->image, idx);
14377 }
14378
14379
14380 /*
14381  * Fill actions for the specific index (which may either be an encoded class token or
14382  * an encoded method token) from the metadata image.
14383  * Returns TRUE if some actions requiring code generation are present, FALSE otherwise.
14384  */
14385 static MonoBoolean
14386 fill_actions_from_index (MonoImage *image, guint32 token, MonoDeclSecurityActions* actions,
14387         guint32 id_std, guint32 id_noncas, guint32 id_choice)
14388 {
14389         MonoBoolean result = FALSE;
14390         MonoTableInfo *t;
14391         guint32 cols [MONO_DECL_SECURITY_SIZE];
14392         int index = mono_metadata_declsec_from_index (image, token);
14393         int i;
14394
14395         t  = &image->tables [MONO_TABLE_DECLSECURITY];
14396         for (i = index; i < t->rows; i++) {
14397                 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
14398
14399                 if (cols [MONO_DECL_SECURITY_PARENT] != token)
14400                         return result;
14401
14402                 /* if present only replace (class) permissions with method permissions */
14403                 /* if empty accept either class or method permissions */
14404                 if (cols [MONO_DECL_SECURITY_ACTION] == id_std) {
14405                         if (!actions->demand.blob) {
14406                                 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
14407                                 actions->demand.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
14408                                 actions->demand.blob = (char*) (blob + 2);
14409                                 actions->demand.size = mono_metadata_decode_blob_size (blob, &blob);
14410                                 result = TRUE;
14411                         }
14412                 } else if (cols [MONO_DECL_SECURITY_ACTION] == id_noncas) {
14413                         if (!actions->noncasdemand.blob) {
14414                                 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
14415                                 actions->noncasdemand.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
14416                                 actions->noncasdemand.blob = (char*) (blob + 2);
14417                                 actions->noncasdemand.size = mono_metadata_decode_blob_size (blob, &blob);
14418                                 result = TRUE;
14419                         }
14420                 } else if (cols [MONO_DECL_SECURITY_ACTION] == id_choice) {
14421                         if (!actions->demandchoice.blob) {
14422                                 const char *blob = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
14423                                 actions->demandchoice.index = cols [MONO_DECL_SECURITY_PERMISSIONSET];
14424                                 actions->demandchoice.blob = (char*) (blob + 2);
14425                                 actions->demandchoice.size = mono_metadata_decode_blob_size (blob, &blob);
14426                                 result = TRUE;
14427                         }
14428                 }
14429         }
14430
14431         return result;
14432 }
14433
14434 static MonoBoolean
14435 mono_declsec_get_class_demands_params (MonoClass *klass, MonoDeclSecurityActions* demands,
14436         guint32 id_std, guint32 id_noncas, guint32 id_choice)
14437 {
14438         guint32 idx = mono_metadata_token_index (klass->type_token);
14439         idx <<= MONO_HAS_DECL_SECURITY_BITS;
14440         idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
14441         return fill_actions_from_index (klass->image, idx, demands, id_std, id_noncas, id_choice);
14442 }
14443
14444 static MonoBoolean
14445 mono_declsec_get_method_demands_params (MonoMethod *method, MonoDeclSecurityActions* demands,
14446         guint32 id_std, guint32 id_noncas, guint32 id_choice)
14447 {
14448         guint32 idx = mono_method_get_index (method);
14449         idx <<= MONO_HAS_DECL_SECURITY_BITS;
14450         idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
14451         return fill_actions_from_index (method->klass->image, idx, demands, id_std, id_noncas, id_choice);
14452 }
14453
14454 /*
14455  * Collect all actions (that requires to generate code in mini) assigned for
14456  * the specified method.
14457  * Note: Don't use the content of actions if the function return FALSE.
14458  */
14459 MonoBoolean
14460 mono_declsec_get_demands (MonoMethod *method, MonoDeclSecurityActions* demands)
14461 {
14462         guint32 mask = MONO_DECLSEC_FLAG_DEMAND | MONO_DECLSEC_FLAG_NONCAS_DEMAND |
14463                 MONO_DECLSEC_FLAG_DEMAND_CHOICE;
14464         MonoBoolean result = FALSE;
14465         guint32 flags;
14466
14467         /* quick exit if no declarative security is present in the metadata */
14468         if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
14469                 return FALSE;
14470
14471         /* we want the original as the wrapper is "free" of the security informations */
14472         if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
14473                 method = mono_marshal_method_from_wrapper (method);
14474                 if (!method)
14475                         return FALSE;
14476         }
14477
14478         /* First we look for method-level attributes */
14479         if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
14480                 mono_class_init (method->klass);
14481                 memset (demands, 0, sizeof (MonoDeclSecurityActions));
14482
14483                 result = mono_declsec_get_method_demands_params (method, demands,
14484                         SECURITY_ACTION_DEMAND, SECURITY_ACTION_NONCASDEMAND, SECURITY_ACTION_DEMANDCHOICE);
14485         }
14486
14487         /* Here we use (or create) the class declarative cache to look for demands */
14488         flags = mono_declsec_flags_from_class (method->klass);
14489         if (flags & mask) {
14490                 if (!result) {
14491                         mono_class_init (method->klass);
14492                         memset (demands, 0, sizeof (MonoDeclSecurityActions));
14493                 }
14494                 result |= mono_declsec_get_class_demands_params (method->klass, demands,
14495                         SECURITY_ACTION_DEMAND, SECURITY_ACTION_NONCASDEMAND, SECURITY_ACTION_DEMANDCHOICE);
14496         }
14497
14498         /* The boolean return value is used as a shortcut in case nothing needs to
14499            be generated (e.g. LinkDemand[Choice] and InheritanceDemand[Choice]) */
14500         return result;
14501 }
14502
14503
14504 /*
14505  * Collect all Link actions: LinkDemand, NonCasLinkDemand and LinkDemandChoice (2.0).
14506  *
14507  * Note: Don't use the content of actions if the function return FALSE.
14508  */
14509 MonoBoolean
14510 mono_declsec_get_linkdemands (MonoMethod *method, MonoDeclSecurityActions* klass, MonoDeclSecurityActions *cmethod)
14511 {
14512         MonoBoolean result = FALSE;
14513         guint32 flags;
14514
14515         /* quick exit if no declarative security is present in the metadata */
14516         if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
14517                 return FALSE;
14518
14519         /* we want the original as the wrapper is "free" of the security informations */
14520         if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
14521                 method = mono_marshal_method_from_wrapper (method);
14522                 if (!method)
14523                         return FALSE;
14524         }
14525
14526         /* results are independant - zeroize both */
14527         memset (cmethod, 0, sizeof (MonoDeclSecurityActions));
14528         memset (klass, 0, sizeof (MonoDeclSecurityActions));
14529
14530         /* First we look for method-level attributes */
14531         if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
14532                 mono_class_init (method->klass);
14533
14534                 result = mono_declsec_get_method_demands_params (method, cmethod,
14535                         SECURITY_ACTION_LINKDEMAND, SECURITY_ACTION_NONCASLINKDEMAND, SECURITY_ACTION_LINKDEMANDCHOICE);
14536         }
14537
14538         /* Here we use (or create) the class declarative cache to look for demands */
14539         flags = mono_declsec_flags_from_class (method->klass);
14540         if (flags & (MONO_DECLSEC_FLAG_LINKDEMAND | MONO_DECLSEC_FLAG_NONCAS_LINKDEMAND | MONO_DECLSEC_FLAG_LINKDEMAND_CHOICE)) {
14541                 mono_class_init (method->klass);
14542
14543                 result |= mono_declsec_get_class_demands_params (method->klass, klass,
14544                         SECURITY_ACTION_LINKDEMAND, SECURITY_ACTION_NONCASLINKDEMAND, SECURITY_ACTION_LINKDEMANDCHOICE);
14545         }
14546
14547         return result;
14548 }
14549
14550 /*
14551  * Collect all Inherit actions: InheritanceDemand, NonCasInheritanceDemand and InheritanceDemandChoice (2.0).
14552  *
14553  * @klass       The inherited class - this is the class that provides the security check (attributes)
14554  * @demans
14555  * return TRUE if inheritance demands (any kind) are present, FALSE otherwise.
14556  *
14557  * Note: Don't use the content of actions if the function return FALSE.
14558  */
14559 MonoBoolean
14560 mono_declsec_get_inheritdemands_class (MonoClass *klass, MonoDeclSecurityActions* demands)
14561 {
14562         MonoBoolean result = FALSE;
14563         guint32 flags;
14564
14565         /* quick exit if no declarative security is present in the metadata */
14566         if (!klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
14567                 return FALSE;
14568
14569         /* Here we use (or create) the class declarative cache to look for demands */
14570         flags = mono_declsec_flags_from_class (klass);
14571         if (flags & (MONO_DECLSEC_FLAG_INHERITANCEDEMAND | MONO_DECLSEC_FLAG_NONCAS_INHERITANCEDEMAND | MONO_DECLSEC_FLAG_INHERITANCEDEMAND_CHOICE)) {
14572                 mono_class_init (klass);
14573                 memset (demands, 0, sizeof (MonoDeclSecurityActions));
14574
14575                 result |= mono_declsec_get_class_demands_params (klass, demands,
14576                         SECURITY_ACTION_INHERITDEMAND, SECURITY_ACTION_NONCASINHERITANCE, SECURITY_ACTION_INHERITDEMANDCHOICE);
14577         }
14578
14579         return result;
14580 }
14581
14582 /*
14583  * Collect all Inherit actions: InheritanceDemand, NonCasInheritanceDemand and InheritanceDemandChoice (2.0).
14584  *
14585  * Note: Don't use the content of actions if the function return FALSE.
14586  */
14587 MonoBoolean
14588 mono_declsec_get_inheritdemands_method (MonoMethod *method, MonoDeclSecurityActions* demands)
14589 {
14590         /* quick exit if no declarative security is present in the metadata */
14591         if (!method->klass->image->tables [MONO_TABLE_DECLSECURITY].rows)
14592                 return FALSE;
14593
14594         /* we want the original as the wrapper is "free" of the security informations */
14595         if (method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE || method->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
14596                 method = mono_marshal_method_from_wrapper (method);
14597                 if (!method)
14598                         return FALSE;
14599         }
14600
14601         if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
14602                 mono_class_init (method->klass);
14603                 memset (demands, 0, sizeof (MonoDeclSecurityActions));
14604
14605                 return mono_declsec_get_method_demands_params (method, demands,
14606                         SECURITY_ACTION_INHERITDEMAND, SECURITY_ACTION_NONCASINHERITANCE, SECURITY_ACTION_INHERITDEMANDCHOICE);
14607         }
14608         return FALSE;
14609 }
14610
14611
14612 static MonoBoolean
14613 get_declsec_action (MonoImage *image, guint32 token, guint32 action, MonoDeclSecurityEntry *entry)
14614 {
14615         guint32 cols [MONO_DECL_SECURITY_SIZE];
14616         MonoTableInfo *t;
14617         int i;
14618
14619         int index = mono_metadata_declsec_from_index (image, token);
14620         if (index == -1)
14621                 return FALSE;
14622
14623         t =  &image->tables [MONO_TABLE_DECLSECURITY];
14624         for (i = index; i < t->rows; i++) {
14625                 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
14626
14627                 /* shortcut - index are ordered */
14628                 if (token != cols [MONO_DECL_SECURITY_PARENT])
14629                         return FALSE;
14630
14631                 if (cols [MONO_DECL_SECURITY_ACTION] == action) {
14632                         const char *metadata = mono_metadata_blob_heap (image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
14633                         entry->blob = (char*) (metadata + 2);
14634                         entry->size = mono_metadata_decode_blob_size (metadata, &metadata);
14635                         return TRUE;
14636                 }
14637         }
14638
14639         return FALSE;
14640 }
14641
14642 MonoBoolean
14643 mono_declsec_get_method_action (MonoMethod *method, guint32 action, MonoDeclSecurityEntry *entry)
14644 {
14645         if (method->flags & METHOD_ATTRIBUTE_HAS_SECURITY) {
14646                 guint32 idx = mono_method_get_index (method);
14647                 idx <<= MONO_HAS_DECL_SECURITY_BITS;
14648                 idx |= MONO_HAS_DECL_SECURITY_METHODDEF;
14649                 return get_declsec_action (method->klass->image, idx, action, entry);
14650         }
14651         return FALSE;
14652 }
14653
14654 MonoBoolean
14655 mono_declsec_get_class_action (MonoClass *klass, guint32 action, MonoDeclSecurityEntry *entry)
14656 {
14657         /* use cache */
14658         guint32 flags = mono_declsec_flags_from_class (klass);
14659         if (declsec_flags_map [action] & flags) {
14660                 guint32 idx = mono_metadata_token_index (klass->type_token);
14661                 idx <<= MONO_HAS_DECL_SECURITY_BITS;
14662                 idx |= MONO_HAS_DECL_SECURITY_TYPEDEF;
14663                 return get_declsec_action (klass->image, idx, action, entry);
14664         }
14665         return FALSE;
14666 }
14667
14668 MonoBoolean
14669 mono_declsec_get_assembly_action (MonoAssembly *assembly, guint32 action, MonoDeclSecurityEntry *entry)
14670 {
14671         guint32 idx = 1; /* there is only one assembly */
14672         idx <<= MONO_HAS_DECL_SECURITY_BITS;
14673         idx |= MONO_HAS_DECL_SECURITY_ASSEMBLY;
14674
14675         return get_declsec_action (assembly->image, idx, action, entry);
14676 }
14677
14678 gboolean
14679 mono_reflection_call_is_assignable_to (MonoClass *klass, MonoClass *oklass, MonoError *error)
14680 {
14681         MonoObject *res, *exc;
14682         void *params [1];
14683         static MonoMethod *method = NULL;
14684
14685         mono_error_init (error);
14686
14687         if (method == NULL) {
14688                 method = mono_class_get_method_from_name (mono_class_get_type_builder_class (), "IsAssignableTo", 1);
14689                 g_assert (method);
14690         }
14691
14692         /*
14693          * The result of mono_type_get_object_checked () might be a System.MonoType but we
14694          * need a TypeBuilder so use mono_class_get_ref_info (klass).
14695          */
14696         g_assert (mono_class_get_ref_info (klass));
14697         g_assert (!strcmp (((MonoObject*)(mono_class_get_ref_info (klass)))->vtable->klass->name, "TypeBuilder"));
14698
14699         params [0] = mono_type_get_object_checked (mono_domain_get (), &oklass->byval_arg, error);
14700         return_val_if_nok (error, FALSE);
14701
14702         res = mono_runtime_try_invoke (method, (MonoObject*)(mono_class_get_ref_info (klass)), params, &exc, error);
14703
14704         if (exc || !mono_error_ok (error)) {
14705                 mono_error_cleanup (error);
14706                 return FALSE;
14707         } else
14708                 return *(MonoBoolean*)mono_object_unbox (res);
14709 }
14710
14711 /**
14712  * mono_reflection_type_get_type:
14713  * @reftype: the System.Type object
14714  *
14715  * Returns the MonoType* associated with the C# System.Type object @reftype.
14716  */
14717 MonoType*
14718 mono_reflection_type_get_type (MonoReflectionType *reftype)
14719 {
14720         g_assert (reftype);
14721
14722         MonoError error;
14723         MonoType *result = mono_reflection_type_get_handle (reftype, &error);
14724         mono_error_assert_ok (&error);
14725         return result;
14726 }
14727
14728 /**
14729  * mono_reflection_assembly_get_assembly:
14730  * @refassembly: the System.Reflection.Assembly object
14731  *
14732  * Returns the MonoAssembly* associated with the C# System.Reflection.Assembly object @refassembly.
14733  */
14734 MonoAssembly*
14735 mono_reflection_assembly_get_assembly (MonoReflectionAssembly *refassembly)
14736 {
14737         g_assert (refassembly);
14738
14739         return refassembly->assembly;
14740 }
14741