mono/metadata/domain.c

   1
   2 /*
   3  * domain.c: MonoDomain functions
   4  *
   5  * Author:
   6  *      Dietmar Maurer (dietmar@ximian.com)
   7  *      Patrik Torstensson
   8  *
   9  * (C) 2001 Ximian, Inc.
  10  */
  11
  12 #include <config.h>
  13 #include <glib.h>
  14 #include <string.h>
  15
  16 #include <mono/os/gc_wrapper.h>
  17
  18 #include <mono/metadata/object.h>
  19 #include <mono/metadata/appdomain.h>
  20 #include <mono/metadata/assembly.h>
  21 #include <mono/metadata/exception.h>
  22 #include <mono/metadata/cil-coff.h>
  23 #include <mono/metadata/rawbuffer.h>
  24
  25 //#define DEBUG_DOMAIN_UNLOAD
  26
  27 static guint32 appdomain_thread_id = -1;
  28 static guint32 context_thread_id = -1;
  29
  30 static gint32 appdomain_id_counter = 0;
  31
  32 static MonoGHashTable * appdomains_list = NULL;
  33
  34 static CRITICAL_SECTION appdomains_mutex;
  35
  36 MonoDomain *mono_root_domain = NULL;
  37
  38 static MonoJitInfoTable *
  39 mono_jit_info_table_new (void)
  40 {
  41         return g_array_new (FALSE, FALSE, sizeof (gpointer));
  42 }
  43
  44 static void
  45 mono_jit_info_table_free (MonoJitInfoTable *table)
  46 {
  47         g_array_free (table, TRUE);
  48 }
  49
  50 static int
  51 mono_jit_info_table_index (MonoJitInfoTable *table, char *addr)
  52 {
  53         int left = 0, right = table->len;
  54
  55         while (left < right) {
  56                 int pos = (left + right) / 2;
  57                 MonoJitInfo *ji = g_array_index (table, gpointer, pos);
  58                 char *start = ji->code_start;
  59                 char *end = start + ji->code_size;
  60
  61                 if (addr < start)
  62                         right = pos;
  63                 else if (addr >= end)
  64                         left = pos + 1;
  65                 else
  66                         return pos;
  67         }
  68
  69         return left;
  70 }
  71
  72 MonoJitInfo *
  73 mono_jit_info_table_find (MonoDomain *domain, char *addr)
  74 {
  75         MonoJitInfoTable *table = domain->jit_info_table;
  76         int left = 0, right;
  77
  78         mono_domain_lock (domain);
  79
  80         right = table->len;
  81         while (left < right) {
  82                 int pos = (left + right) / 2;
  83                 MonoJitInfo *ji = g_array_index (table, gpointer, pos);
  84                 char *start = ji->code_start;
  85                 char *end = start + ji->code_size;
  86
  87                 if (addr < start)
  88                         right = pos;
  89                 else if (addr >= end)
  90                         left = pos + 1;
  91                 else {
  92                         mono_domain_unlock (domain);
  93                         return ji;
  94                 }
  95         }
  96         mono_domain_unlock (domain);
  97
  98         /* maybe it is shared code, so we also search in the root domain */
  99         if (domain != mono_root_domain)
 100                 return mono_jit_info_table_find (mono_root_domain, addr);
 101
 102         return NULL;
 103 }
 104
 105 void
 106 mono_jit_info_table_add (MonoDomain *domain, MonoJitInfo *ji)
 107 {
 108         MonoJitInfoTable *table = domain->jit_info_table;
 109         gpointer start = ji->code_start;
 110         int pos;
 111
 112         mono_domain_lock (domain);
 113         pos = mono_jit_info_table_index (table, start);
 114
 115         g_array_insert_val (table, pos, ji);
 116         mono_domain_unlock (domain);
 117 }
 118
 119 static int
 120 ldstr_hash (const char* str)
 121 {
 122         guint len, h;
 123         const char *end;
 124         len = mono_metadata_decode_blob_size (str, &str) - 1;
 125         end = str + len;
 126         /* if len == 0 *str will point to the mark byte */
 127         h = len? *str: 0;
 128         /*
 129          * FIXME: The distribution may not be so nice with lots of
 130          * null chars in the string.
 131          */
 132         for (str += 1; str < end; str++)
 133                 h = (h << 5) - h + *str;
 134         return h;
 135 }
 136
 137 static gboolean
 138 ldstr_equal (const char *str1, const char *str2) {
 139         int len, len2;
 140         if (str1 == str2)
 141                 return TRUE;
 142         len = mono_metadata_decode_blob_size (str1, NULL) - 1;
 143         len2 = mono_metadata_decode_blob_size (str2, NULL) - 1;
 144         if (len != len2)
 145                 return 0;
 146         return memcmp (str1, str2, len) == 0;
 147 }
 148
 149 static gboolean
 150 mono_string_equal (MonoString *s1, MonoString *s2)
 151 {
 152         int l1 = mono_string_length (s1);
 153         int l2 = mono_string_length (s2);
 154
 155         if (l1 != l2)
 156                 return FALSE;
 157
 158         return memcmp (mono_string_chars (s1), mono_string_chars (s2), l1) == 0;
 159 }
 160
 161 static guint
 162 mono_string_hash (MonoString *s)
 163 {
 164         const guint16 *p = mono_string_chars (s);
 165         int i, len = mono_string_length (s);
 166         guint h = 0;
 167
 168         for (i = 0; i < len; i++) {
 169                 h = (h << 5) - h + *p;
 170                 p++;
 171         }
 172
 173         return h;
 174 }
 175
 176 #if HAVE_BOEHM_GC
 177 static void
 178 domain_finalizer (void *obj, void *data) {
 179         g_print ("domain finalized\n");
 180 }
 181 #endif
 182
 183 MonoDomain *
 184 mono_domain_create (void)
 185 {
 186         MonoDomain *domain;
 187
 188 #if HAVE_BOEHM_GC
 189         domain = GC_MALLOC (sizeof (MonoDomain));
 190         GC_REGISTER_FINALIZER (domain, domain_finalizer, NULL, NULL, NULL);
 191 #else
 192         domain = g_new0 (MonoDomain, 1);
 193 #endif
 194         domain->domain = NULL;
 195         domain->setup = NULL;
 196         domain->friendly_name = NULL;
 197         domain->search_path = NULL;
 198
 199         domain->mp = mono_mempool_new ();
 200         domain->code_mp = mono_code_manager_new ();
 201         domain->env = mono_g_hash_table_new ((GHashFunc)mono_string_hash, (GCompareFunc)mono_string_equal);
 202         domain->assemblies = g_hash_table_new (g_str_hash, g_str_equal);
 203         domain->class_vtable_hash = mono_g_hash_table_new (NULL, NULL);
 204         domain->proxy_vtable_hash = mono_g_hash_table_new ((GHashFunc)mono_string_hash, (GCompareFunc)mono_string_equal);
 205         domain->static_data_hash = mono_g_hash_table_new (NULL, NULL);
 206         domain->jit_code_hash = g_hash_table_new (NULL, NULL);
 207         domain->ldstr_table = mono_g_hash_table_new ((GHashFunc)ldstr_hash, (GCompareFunc)ldstr_equal);
 208         domain->jit_info_table = mono_jit_info_table_new ();
 209         domain->class_init_trampoline_hash = mono_g_hash_table_new (NULL, NULL);
 210         domain->finalizable_objects_hash = g_hash_table_new (NULL, NULL);
 211         domain->domain_id = InterlockedIncrement (&appdomain_id_counter);
 212
 213         InitializeCriticalSection (&domain->lock);
 214
 215         EnterCriticalSection (&appdomains_mutex);
 216         mono_g_hash_table_insert(appdomains_list, GINT_TO_POINTER(domain->domain_id), domain);
 217         LeaveCriticalSection (&appdomains_mutex);
 218
 219         return domain;
 220 }
 221
 222 /**
 223  * mono_init:
 224  *
 225  * Creates the initial application domain and initializes the mono_defaults
 226  * structure.
 227  * This function is guaranteed to not run any IL code.
 228  *
 229  * Returns: the initial domain.
 230  */
 231 MonoDomain *
 232 mono_init (const char *filename)
 233 {
 234         static MonoDomain *domain = NULL;
 235         MonoAssembly *ass;
 236         MonoImageOpenStatus status = MONO_IMAGE_OK;
 237         MonoAssemblyName corlib_aname;
 238
 239         if (domain)
 240                 g_assert_not_reached ();
 241
 242         appdomain_thread_id = TlsAlloc ();
 243         context_thread_id = TlsAlloc ();
 244
 245         InitializeCriticalSection (&appdomains_mutex);
 246
 247         mono_metadata_init ();
 248         mono_raw_buffer_init ();
 249         mono_images_init ();
 250         mono_assemblies_init ();
 251         mono_loader_init ();
 252
 253         // FIXME: When should we release this memory?
 254         appdomains_list = mono_g_hash_table_new (g_direct_hash, g_direct_equal);
 255
 256         domain = mono_domain_create ();
 257         mono_root_domain = domain;
 258
 259         TlsSetValue (appdomain_thread_id, domain);
 260
 261         /* find the corlib */
 262         corlib_aname.name = "mscorlib";
 263         ass = mono_assembly_load (&corlib_aname, NULL, &status);
 264         if ((status != MONO_IMAGE_OK) || (ass == NULL)) {
 265                 switch (status){
 266                 case MONO_IMAGE_ERROR_ERRNO:
 267                         g_print ("The assembly mscorlib.dll was not found or could not be loaded.\n");
 268                         g_print ("It should have been installed in the `%s' directory.\n", MONO_ASSEMBLIES);
 269                         break;
 270                 case MONO_IMAGE_IMAGE_INVALID:
 271                         g_print ("The file %s/mscorlib.dll is an invalid CIL image\n", MONO_ASSEMBLIES);
 272                         break;
 273                 case MONO_IMAGE_MISSING_ASSEMBLYREF:
 274                         g_print ("Minning assembly reference in %s/mscorlib.dll\n", MONO_ASSEMBLIES);
 275                         break;
 276                 case MONO_IMAGE_OK:
 277                         /* to suppress compiler warning */
 278                         break;
 279                 }
 280
 281                 exit (1);
 282         }
 283         mono_defaults.corlib = ass->image;
 284
 285         mono_defaults.object_class = mono_class_from_name (
 286                 mono_defaults.corlib, "System", "Object");
 287         g_assert (mono_defaults.object_class != 0);
 288
 289         mono_defaults.void_class = mono_class_from_name (
 290                 mono_defaults.corlib, "System", "Void");
 291         g_assert (mono_defaults.void_class != 0);
 292
 293         mono_defaults.boolean_class = mono_class_from_name (
 294                 mono_defaults.corlib, "System", "Boolean");
 295         g_assert (mono_defaults.boolean_class != 0);
 296
 297         mono_defaults.byte_class = mono_class_from_name (
 298                 mono_defaults.corlib, "System", "Byte");
 299         g_assert (mono_defaults.byte_class != 0);
 300
 301         mono_defaults.sbyte_class = mono_class_from_name (
 302                 mono_defaults.corlib, "System", "SByte");
 303         g_assert (mono_defaults.sbyte_class != 0);
 304
 305         mono_defaults.int16_class = mono_class_from_name (
 306                 mono_defaults.corlib, "System", "Int16");
 307         g_assert (mono_defaults.int16_class != 0);
 308
 309         mono_defaults.uint16_class = mono_class_from_name (
 310                 mono_defaults.corlib, "System", "UInt16");
 311         g_assert (mono_defaults.uint16_class != 0);
 312
 313         mono_defaults.int32_class = mono_class_from_name (
 314                 mono_defaults.corlib, "System", "Int32");
 315         g_assert (mono_defaults.int32_class != 0);
 316
 317         mono_defaults.uint32_class = mono_class_from_name (
 318                 mono_defaults.corlib, "System", "UInt32");
 319         g_assert (mono_defaults.uint32_class != 0);
 320
 321         mono_defaults.uint_class = mono_class_from_name (
 322                 mono_defaults.corlib, "System", "UIntPtr");
 323         g_assert (mono_defaults.uint_class != 0);
 324
 325         mono_defaults.int_class = mono_class_from_name (
 326                 mono_defaults.corlib, "System", "IntPtr");
 327         g_assert (mono_defaults.int_class != 0);
 328
 329         mono_defaults.int64_class = mono_class_from_name (
 330                 mono_defaults.corlib, "System", "Int64");
 331         g_assert (mono_defaults.int64_class != 0);
 332
 333         mono_defaults.uint64_class = mono_class_from_name (
 334                 mono_defaults.corlib, "System", "UInt64");
 335         g_assert (mono_defaults.uint64_class != 0);
 336
 337         mono_defaults.single_class = mono_class_from_name (
 338                 mono_defaults.corlib, "System", "Single");
 339         g_assert (mono_defaults.single_class != 0);
 340
 341         mono_defaults.double_class = mono_class_from_name (
 342                 mono_defaults.corlib, "System", "Double");
 343         g_assert (mono_defaults.double_class != 0);
 344
 345         mono_defaults.char_class = mono_class_from_name (
 346                 mono_defaults.corlib, "System", "Char");
 347         g_assert (mono_defaults.char_class != 0);
 348
 349         mono_defaults.string_class = mono_class_from_name (
 350                 mono_defaults.corlib, "System", "String");
 351         g_assert (mono_defaults.string_class != 0);
 352
 353         mono_defaults.enum_class = mono_class_from_name (
 354                 mono_defaults.corlib, "System", "Enum");
 355         g_assert (mono_defaults.enum_class != 0);
 356
 357         mono_defaults.array_class = mono_class_from_name (
 358                 mono_defaults.corlib, "System", "Array");
 359         g_assert (mono_defaults.array_class != 0);
 360
 361         mono_defaults.delegate_class = mono_class_from_name (
 362                 mono_defaults.corlib, "System", "Delegate");
 363         g_assert (mono_defaults.delegate_class != 0 );
 364
 365         mono_defaults.multicastdelegate_class = mono_class_from_name (
 366                 mono_defaults.corlib, "System", "MulticastDelegate");
 367         g_assert (mono_defaults.multicastdelegate_class != 0 );
 368
 369         mono_defaults.asyncresult_class = mono_class_from_name (
 370                 mono_defaults.corlib, "System.Runtime.Remoting.Messaging",
 371                 "AsyncResult");
 372         g_assert (mono_defaults.asyncresult_class != 0 );
 373
 374         mono_defaults.waithandle_class = mono_class_from_name (
 375                 mono_defaults.corlib, "System.Threading", "WaitHandle");
 376         g_assert (mono_defaults.waithandle_class != 0 );
 377
 378         mono_defaults.typehandle_class = mono_class_from_name (
 379                 mono_defaults.corlib, "System", "RuntimeTypeHandle");
 380         g_assert (mono_defaults.typehandle_class != 0);
 381
 382         mono_defaults.methodhandle_class = mono_class_from_name (
 383                 mono_defaults.corlib, "System", "RuntimeMethodHandle");
 384         g_assert (mono_defaults.methodhandle_class != 0);
 385
 386         mono_defaults.fieldhandle_class = mono_class_from_name (
 387                 mono_defaults.corlib, "System", "RuntimeFieldHandle");
 388         g_assert (mono_defaults.fieldhandle_class != 0);
 389
 390         mono_defaults.monotype_class = mono_class_from_name (
 391                 mono_defaults.corlib, "System", "MonoType");
 392         g_assert (mono_defaults.monotype_class != 0);
 393
 394         mono_defaults.exception_class = mono_class_from_name (
 395                 mono_defaults.corlib, "System", "Exception");
 396         g_assert (mono_defaults.exception_class != 0);
 397
 398         mono_defaults.threadabortexception_class = mono_class_from_name (
 399                 mono_defaults.corlib, "System.Threading", "ThreadAbortException");
 400         g_assert (mono_defaults.threadabortexception_class != 0);
 401
 402         mono_defaults.thread_class = mono_class_from_name (
 403                 mono_defaults.corlib, "System.Threading", "Thread");
 404         g_assert (mono_defaults.thread_class != 0);
 405
 406         mono_defaults.appdomain_class = mono_class_from_name (
 407                 mono_defaults.corlib, "System", "AppDomain");
 408         g_assert (mono_defaults.appdomain_class != 0);
 409
 410         mono_defaults.transparent_proxy_class = mono_class_from_name (
 411                 mono_defaults.corlib, "System.Runtime.Remoting.Proxies", "TransparentProxy");
 412         g_assert (mono_defaults.transparent_proxy_class != 0);
 413
 414         mono_defaults.real_proxy_class = mono_class_from_name (
 415                 mono_defaults.corlib, "System.Runtime.Remoting.Proxies", "RealProxy");
 416         g_assert (mono_defaults.real_proxy_class != 0);
 417
 418         mono_defaults.mono_method_message_class = mono_class_from_name (
 419                 mono_defaults.corlib, "System.Runtime.Remoting.Messaging", "MonoMethodMessage");
 420         g_assert (mono_defaults.mono_method_message_class != 0);
 421
 422         mono_defaults.field_info_class = mono_class_from_name (
 423                 mono_defaults.corlib, "System.Reflection", "FieldInfo");
 424         g_assert (mono_defaults.field_info_class != 0);
 425
 426         mono_defaults.method_info_class = mono_class_from_name (
 427                 mono_defaults.corlib, "System.Reflection", "MethodInfo");
 428         g_assert (mono_defaults.method_info_class != 0);
 429
 430         mono_defaults.stringbuilder_class = mono_class_from_name (
 431                 mono_defaults.corlib, "System.Text", "StringBuilder");
 432         g_assert (mono_defaults.stringbuilder_class != 0);
 433
 434         mono_defaults.math_class = mono_class_from_name (
 435                 mono_defaults.corlib, "System", "Math");
 436         g_assert (mono_defaults.math_class != 0);
 437
 438         mono_defaults.stack_frame_class = mono_class_from_name (
 439                 mono_defaults.corlib, "System.Diagnostics", "StackFrame");
 440         g_assert (mono_defaults.stack_frame_class != 0);
 441
 442         mono_defaults.stack_trace_class = mono_class_from_name (
 443                 mono_defaults.corlib, "System.Diagnostics", "StackTrace");
 444         g_assert (mono_defaults.stack_trace_class != 0);
 445
 446         mono_defaults.marshal_class = mono_class_from_name (
 447                 mono_defaults.corlib, "System.Runtime.InteropServices", "Marshal");
 448         g_assert (mono_defaults.marshal_class != 0);
 449
 450         mono_defaults.iserializeable_class = mono_class_from_name (
 451                 mono_defaults.corlib, "System.Runtime.Serialization", "ISerializable");
 452         g_assert (mono_defaults.iserializeable_class != 0);
 453
 454         mono_defaults.serializationinfo_class = mono_class_from_name (
 455                 mono_defaults.corlib, "System.Runtime.Serialization", "SerializationInfo");
 456         g_assert (mono_defaults.serializationinfo_class != 0);
 457
 458         mono_defaults.streamingcontext_class = mono_class_from_name (
 459                 mono_defaults.corlib, "System.Runtime.Serialization", "StreamingContext");
 460         g_assert (mono_defaults.streamingcontext_class != 0);
 461
 462         mono_defaults.typed_reference_class =  mono_class_from_name (
 463                 mono_defaults.corlib, "System", "TypedReference");
 464         g_assert (mono_defaults.typed_reference_class != 0);
 465
 466         mono_defaults.argumenthandle_class =  mono_class_from_name (
 467                 mono_defaults.corlib, "System", "RuntimeArgumentHandle");
 468         g_assert (mono_defaults.argumenthandle_class != 0);
 469
 470         mono_defaults.marshalbyrefobject_class =  mono_class_from_name (
 471                 mono_defaults.corlib, "System", "MarshalByRefObject");
 472         g_assert (mono_defaults.marshalbyrefobject_class != 0);
 473
 474         mono_defaults.monitor_class =  mono_class_from_name (
 475                 mono_defaults.corlib, "System.Threading", "Monitor");
 476         g_assert (mono_defaults.monitor_class != 0);
 477
 478         mono_defaults.iremotingtypeinfo_class = mono_class_from_name (
 479                 mono_defaults.corlib, "System.Runtime.Remoting", "IRemotingTypeInfo");
 480         g_assert (mono_defaults.iremotingtypeinfo_class != 0);
 481
 482         domain->friendly_name = g_path_get_basename (filename);
 483
 484         return domain;
 485 }
 486
 487 /**
 488  * mono_domain_get:
 489  *
 490  * Returns the current domain.
 491  */
 492 inline MonoDomain *
 493 mono_domain_get ()
 494 {
 495         return ((MonoDomain *)TlsGetValue (appdomain_thread_id));
 496 }
 497
 498 /**
 499  * mono_domain_set_internal:
 500  * @domain: the new domain
 501  *
 502  * Sets the current domain to @domain.
 503  */
 504 inline void
 505 mono_domain_set_internal (MonoDomain *domain)
 506 {
 507         TlsSetValue (appdomain_thread_id, domain);
 508         TlsSetValue (context_thread_id, domain->default_context);
 509 }
 510
 511 typedef struct {
 512         MonoDomainFunc func;
 513         gpointer user_data;
 514 } DomainInfo;
 515
 516 static void
 517 copy_hash_entry (gpointer key, gpointer data, gpointer user_data)
 518 {
 519         MonoGHashTable *dest = (MonoGHashTable*)user_data;
 520
 521         mono_g_hash_table_insert (dest, key, data);
 522 }
 523
 524 static void
 525 foreach_domain (gpointer key, gpointer data, gpointer user_data)
 526 {
 527         DomainInfo *dom_info = user_data;
 528
 529         dom_info->func ((MonoDomain*)data, dom_info->user_data);
 530 }
 531
 532 void
 533 mono_domain_foreach (MonoDomainFunc func, gpointer user_data)
 534 {
 535         DomainInfo dom_info;
 536         MonoGHashTable *copy;
 537
 538         /*
 539          * Create a copy of the hashtable to avoid calling the user callback
 540          * inside the lock because that could lead to deadlocks.
 541          * We can do this because this function is not perf. critical.
 542          */
 543         copy = mono_g_hash_table_new (NULL, NULL);
 544         EnterCriticalSection (&appdomains_mutex);
 545         mono_g_hash_table_foreach (appdomains_list, copy_hash_entry, copy);
 546         LeaveCriticalSection (&appdomains_mutex);
 547
 548         dom_info.func = func;
 549         dom_info.user_data = user_data;
 550         mono_g_hash_table_foreach (copy, foreach_domain, &dom_info);
 551
 552         mono_g_hash_table_destroy (copy);
 553 }
 554
 555 /**
 556  * mono_domain_assembly_open:
 557  * @domain: the application domain
 558  * @name: file name of the assembly
 559  *
 560  * fixme: maybe we should integrate this with mono_assembly_open ??
 561  */
 562 MonoAssembly *
 563 mono_domain_assembly_open (MonoDomain *domain, const char *name)
 564 {
 565         MonoAssembly *ass;
 566
 567         mono_domain_lock (domain);
 568         if ((ass = g_hash_table_lookup (domain->assemblies, name))) {
 569                 mono_domain_unlock (domain);
 570                 return ass;
 571         }
 572         mono_domain_unlock (domain);
 573
 574         if (!(ass = mono_assembly_open (name, NULL)))
 575                 return NULL;
 576
 577         return ass;
 578 }
 579
 580 static void
 581 remove_assembly (gpointer key, gpointer value, gpointer user_data)
 582 {
 583         mono_assembly_close ((MonoAssembly *)value);
 584 }
 585
 586 static void
 587 delete_jump_list (gpointer key, gpointer value, gpointer user_data)
 588 {
 589         g_slist_free (value);
 590 }
 591
 592 void
 593 mono_domain_free (MonoDomain *domain, gboolean force)
 594 {
 595         if ((domain == mono_root_domain) && !force) {
 596                 g_warning ("cant unload root domain");
 597                 return;
 598         }
 599
 600         EnterCriticalSection (&appdomains_mutex);
 601         mono_g_hash_table_remove (appdomains_list, GINT_TO_POINTER(domain->domain_id));
 602         LeaveCriticalSection (&appdomains_mutex);
 603
 604         g_free (domain->friendly_name);
 605         g_hash_table_foreach (domain->assemblies, remove_assembly, NULL);
 606
 607         mono_g_hash_table_destroy (domain->env);
 608         g_hash_table_destroy (domain->assemblies);
 609         mono_g_hash_table_destroy (domain->class_vtable_hash);
 610         mono_g_hash_table_destroy (domain->proxy_vtable_hash);
 611         mono_g_hash_table_destroy (domain->static_data_hash);
 612         g_hash_table_destroy (domain->jit_code_hash);
 613         mono_g_hash_table_destroy (domain->ldstr_table);
 614         mono_jit_info_table_free (domain->jit_info_table);
 615 #ifdef DEBUG_DOMAIN_UNLOAD
 616         mono_mempool_invalidate (domain->mp);
 617         mono_code_manager_invalidate (domain->code_mp);
 618 #else
 619         mono_mempool_destroy (domain->mp);
 620         mono_code_manager_destroy (domain->code_mp);
 621 #endif
 622         if (domain->jump_target_hash) {
 623                 g_hash_table_foreach (domain->jump_target_hash, delete_jump_list, NULL);
 624                 g_hash_table_destroy (domain->jump_target_hash);
 625         }
 626         mono_g_hash_table_destroy (domain->class_init_trampoline_hash);
 627         g_hash_table_destroy (domain->finalizable_objects_hash);
 628         if (domain->special_static_fields)
 629                 g_hash_table_destroy (domain->special_static_fields);
 630         DeleteCriticalSection (&domain->lock);
 631         domain->setup = NULL;
 632
 633         /* FIXME: anything else required ? */
 634
 635 #if HAVE_BOEHM_GC
 636 #else
 637         g_free (domain);
 638 #endif
 639
 640         if ((domain == mono_root_domain))
 641                 mono_root_domain = NULL;
 642 }
 643
 644 /**
 645  * mono_domain_get_id:
 646  *
 647  * Returns the a domain for a specific domain id.
 648  */
 649 MonoDomain *
 650 mono_domain_get_by_id (gint32 domainid)
 651 {
 652         MonoDomain * domain;
 653
 654         EnterCriticalSection (&appdomains_mutex);
 655         domain = mono_g_hash_table_lookup (appdomains_list, GINT_TO_POINTER(domainid));
 656         LeaveCriticalSection (&appdomains_mutex);
 657
 658         return domain;
 659 }
 660
 661 void
 662 mono_context_set (MonoAppContext * new_context)
 663 {
 664         TlsSetValue (context_thread_id, new_context);
 665 }
 666
 667 MonoAppContext *
 668 mono_context_get ()
 669 {
 670         return ((MonoAppContext *)TlsGetValue (context_thread_id));
 671 }