mono/metadata/dynamic-image.c

   1 /**
   2  * \file
   3  * Images created at runtime.
   4  *
   5  *
   6  * Author:
   7  *   Paolo Molaro (lupus@ximian.com)
   8  *
   9  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  10  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  11  * Copyright 2011 Rodrigo Kumpera
  12  * Copyright 2016 Microsoft
  13  *
  14  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  15  */
  16
  17 #include <config.h>
  18 #include <glib.h>
  19 #include "mono/metadata/object.h"
  20 #include "mono/metadata/dynamic-image-internals.h"
  21 #include "mono/metadata/dynamic-stream-internals.h"
  22 #include "mono/metadata/gc-internals.h"
  23 #include "mono/metadata/metadata-internals.h"
  24 #include "mono/metadata/profiler-private.h"
  25 #include "mono/metadata/reflection-internals.h"
  26 #include "mono/metadata/sre-internals.h"
  27 #include "mono/utils/checked-build.h"
  28 #include "mono/utils/mono-error-internals.h"
  29 #include "mono/utils/mono-os-mutex.h"
  30
  31 const unsigned char table_sizes [MONO_TABLE_NUM] = {
  32         MONO_MODULE_SIZE,
  33         MONO_TYPEREF_SIZE,
  34         MONO_TYPEDEF_SIZE,
  35         0,
  36         MONO_FIELD_SIZE,
  37         0,
  38         MONO_METHOD_SIZE,
  39         0,
  40         MONO_PARAM_SIZE,
  41         MONO_INTERFACEIMPL_SIZE,
  42         MONO_MEMBERREF_SIZE,    /* 0x0A */
  43         MONO_CONSTANT_SIZE,
  44         MONO_CUSTOM_ATTR_SIZE,
  45         MONO_FIELD_MARSHAL_SIZE,
  46         MONO_DECL_SECURITY_SIZE,
  47         MONO_CLASS_LAYOUT_SIZE,
  48         MONO_FIELD_LAYOUT_SIZE, /* 0x10 */
  49         MONO_STAND_ALONE_SIGNATURE_SIZE,
  50         MONO_EVENT_MAP_SIZE,
  51         0,
  52         MONO_EVENT_SIZE,
  53         MONO_PROPERTY_MAP_SIZE,
  54         0,
  55         MONO_PROPERTY_SIZE,
  56         MONO_METHOD_SEMA_SIZE,
  57         MONO_METHODIMPL_SIZE,
  58         MONO_MODULEREF_SIZE,    /* 0x1A */
  59         MONO_TYPESPEC_SIZE,
  60         MONO_IMPLMAP_SIZE,
  61         MONO_FIELD_RVA_SIZE,
  62         0,
  63         0,
  64         MONO_ASSEMBLY_SIZE,     /* 0x20 */
  65         MONO_ASSEMBLY_PROCESSOR_SIZE,
  66         MONO_ASSEMBLYOS_SIZE,
  67         MONO_ASSEMBLYREF_SIZE,
  68         MONO_ASSEMBLYREFPROC_SIZE,
  69         MONO_ASSEMBLYREFOS_SIZE,
  70         MONO_FILE_SIZE,
  71         MONO_EXP_TYPE_SIZE,
  72         MONO_MANIFEST_SIZE,
  73         MONO_NESTED_CLASS_SIZE,
  74
  75         MONO_GENERICPARAM_SIZE, /* 0x2A */
  76         MONO_METHODSPEC_SIZE,
  77         MONO_GENPARCONSTRAINT_SIZE
  78
  79 };
  80
  81 // The dynamic images list is only needed to support the mempool reference tracking feature in checked-build.
  82 static GPtrArray *dynamic_images;
  83 static mono_mutex_t dynamic_images_mutex;
  84
  85 static inline void
  86 dynamic_images_lock (void)
  87 {
  88         mono_os_mutex_lock (&dynamic_images_mutex);
  89 }
  90
  91 static inline void
  92 dynamic_images_unlock (void)
  93 {
  94         mono_os_mutex_unlock (&dynamic_images_mutex);
  95 }
  96
  97 void
  98 mono_dynamic_images_init (void)
  99 {
 100         mono_os_mutex_init (&dynamic_images_mutex);
 101 }
 102
 103 #ifndef DISABLE_REFLECTION_EMIT
 104 static void
 105 string_heap_init (MonoDynamicStream *sh)
 106 {
 107         mono_dynstream_init (sh);
 108 }
 109 #endif
 110
 111 #ifndef DISABLE_REFLECTION_EMIT
 112 static int
 113 mono_blob_entry_hash (const char* str)
 114 {
 115         MONO_REQ_GC_NEUTRAL_MODE;
 116
 117         guint len, h;
 118         const char *end;
 119         len = mono_metadata_decode_blob_size (str, &str);
 120         if (len > 0) {
 121                 end = str + len;
 122                 h = *str;
 123                 for (str += 1; str < end; str++)
 124                         h = (h << 5) - h + *str;
 125                 return h;
 126         } else {
 127                 return 0;
 128         }
 129 }
 130
 131 static gboolean
 132 mono_blob_entry_equal (const char *str1, const char *str2) {
 133         MONO_REQ_GC_NEUTRAL_MODE;
 134
 135         int len, len2;
 136         const char *end1;
 137         const char *end2;
 138         len = mono_metadata_decode_blob_size (str1, &end1);
 139         len2 = mono_metadata_decode_blob_size (str2, &end2);
 140         if (len != len2)
 141                 return 0;
 142         return memcmp (end1, end2, len) == 0;
 143 }
 144 #endif
 145
 146
 147 /**
 148  * mono_find_dynamic_image_owner:
 149  *
 150  * Find the dynamic image, if any, which a given pointer is located in the memory of.
 151  */
 152 MonoImage *
 153 mono_find_dynamic_image_owner (void *ptr)
 154 {
 155         MonoImage *owner = NULL;
 156         int i;
 157
 158         dynamic_images_lock ();
 159
 160         if (dynamic_images)
 161         {
 162                 for (i = 0; !owner && i < dynamic_images->len; ++i) {
 163                         MonoImage *image = (MonoImage *)g_ptr_array_index (dynamic_images, i);
 164                         if (mono_mempool_contains_addr (image->mempool, ptr))
 165                                 owner = image;
 166                 }
 167         }
 168
 169         dynamic_images_unlock ();
 170
 171         return owner;
 172 }
 173
 174 static inline void
 175 dynamic_image_lock (MonoDynamicImage *image)
 176 {
 177         MONO_ENTER_GC_SAFE;
 178         mono_image_lock ((MonoImage*)image);
 179         MONO_EXIT_GC_SAFE;
 180 }
 181
 182 static inline void
 183 dynamic_image_unlock (MonoDynamicImage *image)
 184 {
 185         mono_image_unlock ((MonoImage*)image);
 186 }
 187
 188 #ifndef DISABLE_REFLECTION_EMIT
 189 /*
 190  * mono_dynamic_image_register_token:
 191  *
 192  *   Register the TOKEN->OBJ mapping in the mapping table in ASSEMBLY. This is required for
 193  * the Module.ResolveXXXToken () methods to work.
 194  */
 195 void
 196 mono_dynamic_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObjectHandle obj, int how_collide)
 197 {
 198         MONO_REQ_GC_UNSAFE_MODE;
 199
 200         g_assert (!MONO_HANDLE_IS_NULL (obj));
 201         g_assert (strcmp (mono_handle_class (obj)->name, "EnumBuilder"));
 202         dynamic_image_lock (assembly);
 203         MonoObject *prev = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
 204         if (prev) {
 205                 switch (how_collide) {
 206                 case MONO_DYN_IMAGE_TOK_NEW:
 207                         g_warning ("%s: Unexpected previous object when called with MONO_DYN_IMAGE_TOK_NEW", __func__);
 208                         break;
 209                 case MONO_DYN_IMAGE_TOK_SAME_OK:
 210                         if (prev != MONO_HANDLE_RAW (obj)) {
 211                                 g_warning ("%s: condition `prev == MONO_HANDLE_RAW (obj)' not met", __func__);
 212                         }
 213                         break;
 214                 case MONO_DYN_IMAGE_TOK_REPLACE:
 215                         break;
 216                 default:
 217                         g_assert_not_reached ();
 218                 }
 219         }
 220         mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), MONO_HANDLE_RAW (obj));
 221         dynamic_image_unlock (assembly);
 222 }
 223 #else
 224 void
 225 mono_dynamic_image_register_token (MonoDynamicImage *assembly, guint32 token, MonoObjectHandle obj, int how_collide)
 226 {
 227 }
 228 #endif
 229
 230 static MonoObject*
 231 lookup_dyn_token (MonoDynamicImage *assembly, guint32 token)
 232 {
 233         MONO_REQ_GC_UNSAFE_MODE;
 234
 235         MonoObject *obj;
 236
 237         dynamic_image_lock (assembly);
 238         obj = (MonoObject *)mono_g_hash_table_lookup (assembly->tokens, GUINT_TO_POINTER (token));
 239         dynamic_image_unlock (assembly);
 240
 241         return obj;
 242 }
 243
 244 #ifndef DISABLE_REFLECTION_EMIT
 245 MonoObjectHandle
 246 mono_dynamic_image_get_registered_token (MonoDynamicImage *dynimage, guint32 token, MonoError *error)
 247 {
 248         error_init (error);
 249         return MONO_HANDLE_NEW (MonoObject, lookup_dyn_token (dynimage, token));
 250 }
 251 #else /* DISABLE_REFLECTION_EMIT */
 252 MonoObjectHandle
 253 mono_dynamic_image_get_registered_token (MonoDynamicImage *dynimage, guint32 token, MonoError *error)
 254 {
 255         g_assert_not_reached ();
 256         return NULL_HANDLE;
 257 }
 258 #endif
 259
 260 /**
 261  *
 262  * mono_dynamic_image_is_valid_token:
 263  *
 264  * Returns TRUE if token is valid in the given image.
 265  *
 266  */
 267 gboolean
 268 mono_dynamic_image_is_valid_token (MonoDynamicImage *image, guint32 token)
 269 {
 270         return lookup_dyn_token (image, token) != NULL;
 271 }
 272
 273 #ifndef DISABLE_REFLECTION_EMIT
 274
 275 #endif /* DISABLE_REFLECTION_EMIT */
 276
 277 #ifndef DISABLE_REFLECTION_EMIT
 278 /**
 279  * mono_reflection_lookup_dynamic_token:
 280  *
 281  * Finish the Builder object pointed to by TOKEN and return the corresponding
 282  * runtime structure. If HANDLE_CLASS is not NULL, it is set to the class required by
 283  * mono_ldtoken. If valid_token is TRUE, assert if it is not found in the token->object
 284  * mapping table.
 285  *
 286  * LOCKING: Take the loader lock
 287  */
 288 gpointer
 289 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error)
 290 {
 291         MonoDynamicImage *assembly = (MonoDynamicImage*)image;
 292         MonoObject *obj;
 293         MonoClass *klass;
 294
 295         error_init (error);
 296
 297         obj = lookup_dyn_token (assembly, token);
 298         if (!obj) {
 299                 if (valid_token)
 300                         g_error ("Could not find required dynamic token 0x%08x", token);
 301                 else {
 302                         mono_error_set_execution_engine (error, "Could not find dynamic token 0x%08x", token);
 303                         return NULL;
 304                 }
 305         }
 306
 307         if (!handle_class)
 308                 handle_class = &klass;
 309         gpointer result = mono_reflection_resolve_object (image, obj, handle_class, context, error);
 310         return result;
 311 }
 312 #else /* DISABLE_REFLECTION_EMIT */
 313 gpointer
 314 mono_reflection_lookup_dynamic_token (MonoImage *image, guint32 token, gboolean valid_token, MonoClass **handle_class, MonoGenericContext *context, MonoError *error)
 315 {
 316         error_init (error);
 317         return NULL;
 318 }
 319 #endif /* DISABLE_REFLECTION_EMIT */
 320
 321 #ifndef DISABLE_REFLECTION_EMIT
 322 MonoDynamicImage*
 323 mono_dynamic_image_create (MonoDynamicAssembly *assembly, char *assembly_name, char *module_name)
 324 {
 325         static const guchar entrycode [16] = {0xff, 0x25, 0};
 326         MonoDynamicImage *image;
 327         int i;
 328
 329         const char *version;
 330
 331         if (!strcmp (mono_get_runtime_info ()->framework_version, "2.1"))
 332                 version = "v2.0.50727"; /* HACK: SL 2 enforces the .net 2 metadata version */
 333         else
 334                 version = mono_get_runtime_info ()->runtime_version;
 335
 336 #if HAVE_BOEHM_GC
 337         /* The MonoGHashTable's need GC tracking */
 338         image = (MonoDynamicImage *)GC_MALLOC (sizeof (MonoDynamicImage));
 339 #else
 340         image = g_new0 (MonoDynamicImage, 1);
 341 #endif
 342
 343         mono_profiler_module_event (&image->image, MONO_PROFILE_START_LOAD);
 344
 345         /*g_print ("created image %p\n", image);*/
 346         /* keep in sync with image.c */
 347         image->image.name = assembly_name;
 348         image->image.assembly_name = image->image.name; /* they may be different */
 349         image->image.module_name = module_name;
 350         image->image.version = g_strdup (version);
 351         image->image.md_version_major = 1;
 352         image->image.md_version_minor = 1;
 353         image->image.dynamic = TRUE;
 354
 355         image->image.references = g_new0 (MonoAssembly*, 1);
 356         image->image.references [0] = NULL;
 357
 358         mono_image_init (&image->image);
 359
 360         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");
 361         image->method_to_table_idx = g_hash_table_new (NULL, NULL);
 362         image->field_to_table_idx = g_hash_table_new (NULL, NULL);
 363         image->method_aux_hash = g_hash_table_new (NULL, NULL);
 364         image->vararg_aux_hash = g_hash_table_new (NULL, NULL);
 365         image->handleref = g_hash_table_new (NULL, NULL);
 366         image->tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, "dynamic module tokens table");
 367         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");
 368         image->typespec = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
 369         image->typeref = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
 370         image->blob_cache = g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal);
 371         image->gen_params = g_ptr_array_new ();
 372         image->remapped_tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, "dynamic module remapped tokens table");
 373
 374         /*g_print ("string heap create for image %p (%s)\n", image, module_name);*/
 375         string_heap_init (&image->sheap);
 376         mono_dynstream_add_data (&image->us, "", 1);
 377         mono_dynamic_image_add_to_blob_cached (image, (char*) "", 1, NULL, 0);
 378         /* import tables... */
 379         mono_dynstream_add_data (&image->code, (char*)entrycode, sizeof (entrycode));
 380         image->iat_offset = mono_dynstream_add_zero (&image->code, 8); /* two IAT entries */
 381         image->idt_offset = mono_dynstream_add_zero (&image->code, 2 * sizeof (MonoIDT)); /* two IDT entries */
 382         image->imp_names_offset = mono_dynstream_add_zero (&image->code, 2); /* flags for name entry */
 383         mono_dynstream_add_data (&image->code, "_CorExeMain", 12);
 384         mono_dynstream_add_data (&image->code, "mscoree.dll", 12);
 385         image->ilt_offset = mono_dynstream_add_zero (&image->code, 8); /* two ILT entries */
 386         mono_dynstream_data_align (&image->code);
 387
 388         image->cli_header_offset = mono_dynstream_add_zero (&image->code, sizeof (MonoCLIHeader));
 389
 390         for (i=0; i < MONO_TABLE_NUM; ++i) {
 391                 image->tables [i].next_idx = 1;
 392                 image->tables [i].columns = table_sizes [i];
 393         }
 394
 395         image->image.assembly = (MonoAssembly*)assembly;
 396         image->run = assembly->run;
 397         image->save = assembly->save;
 398         image->pe_kind = 0x1; /* ILOnly */
 399         image->machine = 0x14c; /* I386 */
 400
 401         mono_profiler_module_loaded (&image->image, MONO_PROFILE_OK);
 402
 403         dynamic_images_lock ();
 404
 405         if (!dynamic_images)
 406                 dynamic_images = g_ptr_array_new ();
 407
 408         g_ptr_array_add (dynamic_images, image);
 409
 410         dynamic_images_unlock ();
 411
 412         return image;
 413 }
 414 #else /* DISABLE_REFLECTION_EMIT */
 415 MonoDynamicImage*
 416 mono_dynamic_image_create (MonoDynamicAssembly *assembly, char *assembly_name, char *module_name)
 417 {
 418         g_assert_not_reached ();
 419         return NULL;
 420 }
 421 #endif /* DISABLE_REFLECTION_EMIT */
 422
 423 guint32
 424 mono_dynamic_image_add_to_blob_cached (MonoDynamicImage *assembly, char *b1, int s1, char *b2, int s2)
 425 {
 426         MONO_REQ_GC_NEUTRAL_MODE;
 427
 428         guint32 idx;
 429         char *copy;
 430         gpointer oldkey, oldval;
 431
 432         copy = (char *)g_malloc (s1+s2);
 433         memcpy (copy, b1, s1);
 434         memcpy (copy + s1, b2, s2);
 435         if (g_hash_table_lookup_extended (assembly->blob_cache, copy, &oldkey, &oldval)) {
 436                 g_free (copy);
 437                 idx = GPOINTER_TO_UINT (oldval);
 438         } else {
 439                 idx = mono_dynstream_add_data (&assembly->blob, b1, s1);
 440                 mono_dynstream_add_data (&assembly->blob, b2, s2);
 441                 g_hash_table_insert (assembly->blob_cache, copy, GUINT_TO_POINTER (idx));
 442         }
 443         return idx;
 444 }
 445
 446 void
 447 mono_dynimage_alloc_table (MonoDynamicTable *table, guint nrows)
 448 {
 449         MONO_REQ_GC_NEUTRAL_MODE;
 450
 451         table->rows = nrows;
 452         g_assert (table->columns);
 453         if (nrows + 1 >= table->alloc_rows) {
 454                 while (nrows + 1 >= table->alloc_rows) {
 455                         if (table->alloc_rows == 0)
 456                                 table->alloc_rows = 16;
 457                         else
 458                                 table->alloc_rows *= 2;
 459                 }
 460
 461                 table->values = (guint32 *)g_renew (guint32, table->values, (table->alloc_rows) * table->columns);
 462         }
 463 }
 464
 465
 466 static void
 467 free_blob_cache_entry (gpointer key, gpointer val, gpointer user_data)
 468 {
 469         g_free (key);
 470 }
 471
 472 static void
 473 release_hashtable (MonoGHashTable **hash)
 474 {
 475         if (*hash) {
 476                 mono_g_hash_table_destroy (*hash);
 477                 *hash = NULL;
 478         }
 479 }
 480
 481 void
 482 mono_dynamic_image_release_gc_roots (MonoDynamicImage *image)
 483 {
 484         release_hashtable (&image->token_fixups);
 485         release_hashtable (&image->tokens);
 486         release_hashtable (&image->remapped_tokens);
 487         release_hashtable (&image->generic_def_objects);
 488 }
 489
 490 // Free dynamic image pass one: Free resources but not image itself
 491 void
 492 mono_dynamic_image_free (MonoDynamicImage *image)
 493 {
 494         MonoDynamicImage *di = image;
 495         GList *list;
 496         int i;
 497
 498         if (di->typespec)
 499                 g_hash_table_destroy (di->typespec);
 500         if (di->typeref)
 501                 g_hash_table_destroy (di->typeref);
 502         if (di->handleref)
 503                 g_hash_table_destroy (di->handleref);
 504         if (di->tokens)
 505                 mono_g_hash_table_destroy (di->tokens);
 506         if (di->remapped_tokens)
 507                 mono_g_hash_table_destroy (di->remapped_tokens);
 508         if (di->generic_def_objects)
 509                 mono_g_hash_table_destroy (di->generic_def_objects);
 510         if (di->blob_cache) {
 511                 g_hash_table_foreach (di->blob_cache, free_blob_cache_entry, NULL);
 512                 g_hash_table_destroy (di->blob_cache);
 513         }
 514         if (di->standalonesig_cache)
 515                 g_hash_table_destroy (di->standalonesig_cache);
 516         for (list = di->array_methods; list; list = list->next) {
 517                 ArrayMethod *am = (ArrayMethod *)list->data;
 518                 mono_sre_array_method_free (am);
 519         }
 520         g_list_free (di->array_methods);
 521         if (di->gen_params) {
 522                 for (i = 0; i < di->gen_params->len; i++) {
 523                         GenericParamTableEntry *entry = (GenericParamTableEntry *)g_ptr_array_index (di->gen_params, i);
 524                         mono_sre_generic_param_table_entry_free (entry);
 525                 }
 526                 g_ptr_array_free (di->gen_params, TRUE);
 527         }
 528         if (di->token_fixups)
 529                 mono_g_hash_table_destroy (di->token_fixups);
 530         if (di->method_to_table_idx)
 531                 g_hash_table_destroy (di->method_to_table_idx);
 532         if (di->field_to_table_idx)
 533                 g_hash_table_destroy (di->field_to_table_idx);
 534         if (di->method_aux_hash)
 535                 g_hash_table_destroy (di->method_aux_hash);
 536         if (di->vararg_aux_hash)
 537                 g_hash_table_destroy (di->vararg_aux_hash);
 538         g_free (di->strong_name);
 539         g_free (di->win32_res);
 540         if (di->public_key)
 541                 g_free (di->public_key);
 542
 543         /*g_print ("string heap destroy for image %p\n", di);*/
 544         mono_dynamic_stream_reset (&di->sheap);
 545         mono_dynamic_stream_reset (&di->code);
 546         mono_dynamic_stream_reset (&di->resources);
 547         mono_dynamic_stream_reset (&di->us);
 548         mono_dynamic_stream_reset (&di->blob);
 549         mono_dynamic_stream_reset (&di->tstream);
 550         mono_dynamic_stream_reset (&di->guid);
 551         for (i = 0; i < MONO_TABLE_NUM; ++i) {
 552                 g_free (di->tables [i].values);
 553         }
 554
 555         dynamic_images_lock ();
 556
 557         if (dynamic_images)
 558                 g_ptr_array_remove (dynamic_images, di);
 559
 560         dynamic_images_unlock ();
 561 }
 562
 563 // Free dynamic image pass two: Free image itself (might never get called in some debug modes)
 564 void
 565 mono_dynamic_image_free_image (MonoDynamicImage *image)
 566 {
 567         /* See create_dynamic_mono_image () */
 568 #if HAVE_BOEHM_GC
 569         /* Allocated using GC_MALLOC */
 570 #else
 571         g_free (image);
 572 #endif
 573 }