mono/metadata/appdomain.c

   1 /*
   2  * appdomain.c: AppDomain functions
   3  *
   4  * Author:
   5  *      Dietmar Maurer (dietmar@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <string.h>
  13
  14 #if HAVE_BOEHM_GC
  15 #include <gc/gc.h>
  16 #endif
  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
  24 static guint32 appdomain_thread_id = 0;
  25
  26 static MonoJitInfoTable *
  27 mono_jit_info_table_new ()
  28 {
  29         return g_array_new (FALSE, FALSE, sizeof (gpointer));
  30 }
  31
  32 static void
  33 mono_jit_info_table_free (MonoJitInfoTable *table)
  34 {
  35         g_array_free (table, TRUE);
  36 }
  37
  38 static int
  39 mono_jit_info_table_index (MonoJitInfoTable *table, gpointer addr)
  40 {
  41         int left = 0, right = table->len;
  42
  43         while (left < right) {
  44                 int pos = (left + right) / 2;
  45                 MonoJitInfo *ji = g_array_index (table, gpointer, pos);
  46                 gpointer start = ji->code_start;
  47                 gpointer end = start + ji->code_size;
  48
  49                 if (addr < start)
  50                         right = pos;
  51                 else if (addr >= end)
  52                         left = pos + 1;
  53                 else
  54                         return pos;
  55         }
  56
  57         return left;
  58 }
  59
  60 MonoJitInfo *
  61 mono_jit_info_table_find (MonoDomain *domain, gpointer addr)
  62 {
  63         MonoJitInfoTable *table = domain->jit_info_table;
  64         int left = 0, right = table->len;
  65
  66         while (left < right) {
  67                 int pos = (left + right) / 2;
  68                 MonoJitInfo *ji = g_array_index (table, gpointer, pos);
  69                 gpointer start = ji->code_start;
  70                 gpointer end = start + ji->code_size;
  71
  72                 if (addr < start)
  73                         right = pos;
  74                 else if (addr >= end)
  75                         left = pos + 1;
  76                 else
  77                         return ji;
  78         }
  79
  80         /* maybe irt is shared code, so we also search in the root domain */
  81         if (domain != mono_root_domain)
  82                 return mono_jit_info_table_find (domain, addr);
  83
  84         return NULL;
  85 }
  86
  87 void
  88 mono_jit_info_table_add (MonoDomain *domain, MonoJitInfo *ji)
  89 {
  90         MonoJitInfoTable *table = domain->jit_info_table;
  91         gpointer start = ji->code_start;
  92         int pos = mono_jit_info_table_index (table, start);
  93
  94         g_array_insert_val (table, pos, ji);
  95 }
  96
  97 static int
  98 ldstr_hash (const char* str)
  99 {
 100         guint len, h;
 101         const char *end;
 102         len = mono_metadata_decode_blob_size (str, &str);
 103         end = str + len;
 104         h = *str;
 105         /*
 106          * FIXME: The distribution may not be so nice with lots of
 107          * null chars in the string.
 108          */
 109         for (str += 1; str < end; str++)
 110                 h = (h << 5) - h + *str;
 111         return h;
 112 }
 113
 114 static gboolean
 115 ldstr_equal (const char *str1, const char *str2) {
 116         int len, len2;
 117         len = mono_metadata_decode_blob_size (str1, NULL);
 118         len2 = mono_metadata_decode_blob_size (str2, NULL);
 119         if (len != len2)
 120                 return 0;
 121         return memcmp (str1, str2, len) == 0;
 122 }
 123
 124 static MonoDomain *
 125 mono_create_domain ()
 126 {
 127         MonoDomain *domain;
 128
 129 #if HAVE_BOEHM_GC
 130         domain = GC_malloc (sizeof (MonoDomain));
 131 #else
 132         domain = g_new0 (MonoDomain, 1);
 133 #endif
 134         domain->domain = NULL;
 135         domain->setup = NULL;
 136         domain->friendly_name = NULL;
 137
 138         domain->mp = mono_mempool_new ();
 139         domain->env = g_hash_table_new (g_str_hash, g_str_equal);
 140         domain->assemblies = g_hash_table_new (g_str_hash, g_str_equal);
 141         domain->class_vtable_hash = g_hash_table_new (NULL, NULL);
 142         domain->jit_code_hash = g_hash_table_new (NULL, NULL);
 143         domain->ldstr_table = g_hash_table_new ((GHashFunc)ldstr_hash, (GCompareFunc)ldstr_equal);
 144         domain->jit_info_table = mono_jit_info_table_new ();
 145         return domain;
 146 }
 147
 148 MonoDomain *mono_root_domain = NULL;
 149
 150 /**
 151  * mono_init:
 152  *
 153  * Creates the initial application domain and initializes the mono_defaults
 154  * structure.
 155  *
 156  * Returns: the initial domain.
 157  */
 158 MonoDomain *
 159 mono_init (const char *filename)
 160 {
 161         static MonoDomain *domain = NULL;
 162         MonoAppDomainSetup *setup;
 163         MonoAppDomain *ad;
 164         MonoAssembly *ass;
 165         MonoClass *class;
 166         MonoString *name;
 167         enum MonoImageOpenStatus status = MONO_IMAGE_OK;
 168
 169         if (domain)
 170                 g_assert_not_reached ();
 171
 172         appdomain_thread_id = TlsAlloc ();
 173
 174         domain = mono_create_domain ();
 175         mono_root_domain = domain;
 176
 177         TlsSetValue (appdomain_thread_id, domain);
 178
 179         /* find the corlib */
 180         ass = mono_assembly_open (CORLIB_NAME, NULL, &status);
 181         if ((status != MONO_IMAGE_OK) || (ass == NULL)) {
 182                 switch (status){
 183                 case MONO_IMAGE_ERROR_ERRNO:
 184                         g_print ("The assembly corlib.dll was not found or could not be loaded.\n");
 185                         g_print ("It should have been installed in the `%s' directory.\n", MONO_ASSEMBLIES);
 186                         break;
 187                 case MONO_IMAGE_IMAGE_INVALID:
 188                         g_print ("The file %s/corlib.dll is an invalid CIL image\n", MONO_ASSEMBLIES);
 189                         break;
 190                 case MONO_IMAGE_MISSING_ASSEMBLYREF:
 191                         g_print ("Minning assembly reference in %s/corlib.dll\n", MONO_ASSEMBLIES);
 192                         break;
 193                 case MONO_IMAGE_OK:
 194                         /* to suppress compiler warning */
 195                 }
 196
 197                 exit (1);
 198         }
 199         mono_defaults.corlib = ass->image;
 200
 201         mono_defaults.object_class = mono_class_from_name (
 202                 mono_defaults.corlib, "System", "Object");
 203         g_assert (mono_defaults.object_class != 0);
 204
 205         mono_defaults.void_class = mono_class_from_name (
 206                 mono_defaults.corlib, "System", "Void");
 207         g_assert (mono_defaults.void_class != 0);
 208
 209         mono_defaults.boolean_class = mono_class_from_name (
 210                 mono_defaults.corlib, "System", "Boolean");
 211         g_assert (mono_defaults.boolean_class != 0);
 212
 213         mono_defaults.byte_class = mono_class_from_name (
 214                 mono_defaults.corlib, "System", "Byte");
 215         g_assert (mono_defaults.byte_class != 0);
 216
 217         mono_defaults.sbyte_class = mono_class_from_name (
 218                 mono_defaults.corlib, "System", "SByte");
 219         g_assert (mono_defaults.sbyte_class != 0);
 220
 221         mono_defaults.int16_class = mono_class_from_name (
 222                 mono_defaults.corlib, "System", "Int16");
 223         g_assert (mono_defaults.int16_class != 0);
 224
 225         mono_defaults.uint16_class = mono_class_from_name (
 226                 mono_defaults.corlib, "System", "UInt16");
 227         g_assert (mono_defaults.uint16_class != 0);
 228
 229         mono_defaults.int32_class = mono_class_from_name (
 230                 mono_defaults.corlib, "System", "Int32");
 231         g_assert (mono_defaults.int32_class != 0);
 232
 233         mono_defaults.uint32_class = mono_class_from_name (
 234                 mono_defaults.corlib, "System", "UInt32");
 235         g_assert (mono_defaults.uint32_class != 0);
 236
 237         mono_defaults.uint_class = mono_class_from_name (
 238                 mono_defaults.corlib, "System", "UIntPtr");
 239         g_assert (mono_defaults.uint_class != 0);
 240
 241         mono_defaults.int_class = mono_class_from_name (
 242                 mono_defaults.corlib, "System", "IntPtr");
 243         g_assert (mono_defaults.int_class != 0);
 244
 245         mono_defaults.int64_class = mono_class_from_name (
 246                 mono_defaults.corlib, "System", "Int64");
 247         g_assert (mono_defaults.int64_class != 0);
 248
 249         mono_defaults.uint64_class = mono_class_from_name (
 250                 mono_defaults.corlib, "System", "UInt64");
 251         g_assert (mono_defaults.uint64_class != 0);
 252
 253         mono_defaults.single_class = mono_class_from_name (
 254                 mono_defaults.corlib, "System", "Single");
 255         g_assert (mono_defaults.single_class != 0);
 256
 257         mono_defaults.double_class = mono_class_from_name (
 258                 mono_defaults.corlib, "System", "Double");
 259         g_assert (mono_defaults.double_class != 0);
 260
 261         mono_defaults.char_class = mono_class_from_name (
 262                 mono_defaults.corlib, "System", "Char");
 263         g_assert (mono_defaults.char_class != 0);
 264
 265         mono_defaults.string_class = mono_class_from_name (
 266                 mono_defaults.corlib, "System", "String");
 267         g_assert (mono_defaults.string_class != 0);
 268
 269         mono_defaults.enum_class = mono_class_from_name (
 270                 mono_defaults.corlib, "System", "Enum");
 271         g_assert (mono_defaults.enum_class != 0);
 272
 273         mono_defaults.array_class = mono_class_from_name (
 274                 mono_defaults.corlib, "System", "Array");
 275         g_assert (mono_defaults.array_class != 0);
 276
 277         mono_defaults.multicastdelegate_class = mono_class_from_name (
 278                 mono_defaults.corlib, "System", "MulticastDelegate");
 279         g_assert (mono_defaults.multicastdelegate_class != 0 );
 280
 281         mono_defaults.asyncresult_class = mono_class_from_name (
 282                 mono_defaults.corlib, "System", "MonoAsyncResult");
 283         g_assert (mono_defaults.asyncresult_class != 0 );
 284
 285         mono_defaults.waithandle_class = mono_class_from_name (
 286                 mono_defaults.corlib, "System.Threading", "WaitHandle");
 287         g_assert (mono_defaults.waithandle_class != 0 );
 288
 289         mono_defaults.typehandle_class = mono_class_from_name (
 290                 mono_defaults.corlib, "System", "RuntimeTypeHandle");
 291         g_assert (mono_defaults.typehandle_class != 0);
 292
 293         mono_defaults.methodhandle_class = mono_class_from_name (
 294                 mono_defaults.corlib, "System", "RuntimeMethodHandle");
 295         g_assert (mono_defaults.methodhandle_class != 0);
 296
 297         mono_defaults.fieldhandle_class = mono_class_from_name (
 298                 mono_defaults.corlib, "System", "RuntimeFieldHandle");
 299         g_assert (mono_defaults.fieldhandle_class != 0);
 300
 301         mono_defaults.monotype_class = mono_class_from_name (
 302                 mono_defaults.corlib, "System", "MonoType");
 303         g_assert (mono_defaults.monotype_class != 0);
 304
 305         mono_defaults.exception_class = mono_class_from_name (
 306                 mono_defaults.corlib, "System", "Exception");
 307         g_assert (mono_defaults.exception_class != 0);
 308
 309         mono_defaults.thread_class = mono_class_from_name (
 310                 mono_defaults.corlib, "System.Threading", "Thread");
 311         g_assert (mono_defaults.thread_class != 0);
 312
 313         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
 314         setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
 315         ves_icall_System_AppDomainSetup_InitAppDomainSetup (setup);
 316
 317         name = mono_string_new (domain, g_path_get_basename (filename));
 318
 319         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 320         ad = (MonoAppDomain *) mono_object_new (domain, class);
 321         ad->data = domain;
 322         domain->domain = ad;
 323         domain->setup = setup;
 324         domain->friendly_name = name;
 325
 326         return domain;
 327 }
 328
 329 void
 330 ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
 331 {
 332         // fixme: implement me
 333 }
 334
 335 /**
 336  * mono_domain_transfer_object:
 337  * @src: the source domain
 338  * @dst: the destination domain
 339  * @obj: the object to transfer
 340  *
 341  * This function is used to transfer objects between domains. This is done by
 342  * marshalling or serialisation.
 343  */
 344 static MonoObject *
 345 mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj)
 346 {
 347         MonoClass *klass;
 348         MonoObject *res;
 349
 350         if (!obj)
 351                 return NULL;
 352
 353         g_assert (obj->vtable->domain == src);
 354
 355         /* fixme: transfer an object from one domain into another */
 356
 357         klass = obj->vtable->klass;
 358
 359         if (MONO_CLASS_IS_ARRAY (klass)) {
 360                 MonoArray *ao = (MonoArray *)obj;
 361                 int esize, ecount, i;
 362                 guint32 *sizes;
 363
 364                 sizes = alloca (klass->rank * sizeof(guint32) * 2);
 365                 esize = mono_array_element_size (klass);
 366                 ecount = 1;
 367                 for (i = 0; i < klass->rank; ++i) {
 368                         sizes [i] = ao->bounds [i].length;
 369                         ecount *= ao->bounds [i].length;
 370                         sizes [i + klass->rank] = ao->bounds [i].lower_bound;
 371                 }
 372                 res = (MonoObject *)mono_array_new_full (dst, klass, sizes, sizes + klass->rank);
 373                 if (klass->element_class->valuetype) {
 374                         memcpy (res, (char *)ao + sizeof(MonoArray), esize * ecount);
 375                 } else {
 376                         g_assert (esize == sizeof (gpointer));
 377                         for (i = 0; i < ecount; i++) {
 378                                 int offset = sizeof (MonoArray) + esize * i;
 379                                 gpointer *src_ea = (gpointer *)((char *)ao + offset);
 380                                 gpointer *dst_ea = (gpointer *)((char *)res + offset);
 381
 382                                 *dst_ea = mono_domain_transfer_object (src, dst, *src_ea);
 383                         }
 384                 }
 385         } else if (klass == mono_defaults.string_class) {
 386                 MonoString *str = (MonoString *)obj;
 387                 res = (MonoObject *)mono_string_new_utf16 (dst,
 388                         (const guint16 *)str->c_str->vector, str->length);
 389         } else {
 390                 // fixme: we need generic marshalling code here */
 391                 g_assert_not_reached ();
 392         }
 393
 394         return res;
 395 }
 396
 397 MonoObject *
 398 ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
 399 {
 400         MonoDomain *add = ad->data;
 401         MonoDomain *cur = mono_domain_get ();
 402         MonoObject *o;
 403         char *str;
 404
 405         g_assert (ad != NULL);
 406         g_assert (name != NULL);
 407
 408         str = mono_string_to_utf8 (name);
 409
 410         if (!strcmp (str, "APPBASE"))
 411                 o = (MonoObject *)add->setup->application_base;
 412         else if (!strcmp (str, "APP_CONFIG_FILE"))
 413                 o = (MonoObject *)add->setup->configuration_file;
 414         else if (!strcmp (str, "DYNAMIC_BASE"))
 415                 o = (MonoObject *)add->setup->dynamic_base;
 416         else if (!strcmp (str, "APP_NAME"))
 417                 o = (MonoObject *)add->setup->application_name;
 418         else if (!strcmp (str, "CACHE_BASE"))
 419                 o = (MonoObject *)add->setup->cache_path;
 420         else if (!strcmp (str, "PRIVATE_BINPATH"))
 421                 o = (MonoObject *)add->setup->private_bin_path;
 422         else if (!strcmp (str, "BINPATH_PROBE_ONLY"))
 423                 o = (MonoObject *)add->setup->private_bin_path_probe;
 424         else if (!strcmp (str, "SHADOW_COPY_DIRS"))
 425                 o = (MonoObject *)add->setup->shadow_copy_directories;
 426         else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
 427                 o = (MonoObject *)add->setup->shadow_copy_files;
 428         else
 429                 o = g_hash_table_lookup (add->env, str);
 430
 431         g_free (str);
 432
 433         if (!o)
 434                 return NULL;
 435
 436         return mono_domain_transfer_object (add, cur, o);
 437 }
 438
 439 void
 440 ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
 441 {
 442         MonoDomain *add = ad->data;
 443         MonoDomain *cur = mono_domain_get ();
 444         MonoObject *o;
 445         char *str;
 446
 447         g_assert (ad != NULL);
 448         g_assert (name != NULL);
 449
 450         o = mono_domain_transfer_object (cur, add, data);
 451
 452         /* fixme: need a hash func for MonoString */
 453         str = mono_string_to_utf8 (name);
 454         g_hash_table_insert (add->env, str, o);
 455         g_free (str);
 456 }
 457
 458 MonoAppDomainSetup *
 459 ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
 460 {
 461         g_assert (ad != NULL);
 462         g_assert (ad->data != NULL);
 463
 464         return ad->data->setup;
 465 }
 466
 467 MonoString *
 468 ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
 469 {
 470         g_assert (ad != NULL);
 471         g_assert (ad->data != NULL);
 472
 473         return ad->data->friendly_name;
 474 }
 475
 476 /**
 477  * mono_domain_get:
 478  *
 479  * Returns the current domain.
 480  */
 481 inline MonoDomain *
 482 mono_domain_get ()
 483 {
 484         return ((MonoDomain *)TlsGetValue (appdomain_thread_id));
 485 }
 486
 487 /**
 488  * mono_domain_set:
 489  * @domain: the new domain
 490  *
 491  * Sets the current domain to @domain.
 492  */
 493 inline void
 494 mono_domain_set (MonoDomain *domain)
 495 {
 496         TlsSetValue (appdomain_thread_id, domain);
 497 }
 498
 499 MonoAppDomain *
 500 ves_icall_System_AppDomain_getCurDomain ()
 501 {
 502         MonoDomain *add = mono_domain_get ();
 503         return add->domain;
 504 }
 505
 506 MonoAppDomain *
 507 ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
 508 {
 509         MonoDomain *domain = mono_domain_get ();
 510         MonoClass *adclass;
 511         MonoAppDomain *ad;
 512         MonoDomain *data;
 513
 514         adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 515
 516         // fixme: pin all those objects
 517         ad = (MonoAppDomain *) mono_object_new (domain, adclass);
 518         ad->data = data = mono_create_domain ();
 519         data->domain = ad;
 520         data->setup = setup;
 521         data->friendly_name = friendly_name;
 522
 523         // fixme: what to do next ?
 524
 525         return ad;
 526 }
 527
 528 typedef struct {
 529         MonoArray *res;
 530         MonoDomain *domain;
 531         int idx;
 532 } add_assembly_helper_t;
 533
 534 static void
 535 add_assembly (gpointer key, gpointer value, gpointer user_data)
 536 {
 537         add_assembly_helper_t *ah = (add_assembly_helper_t *) user_data;
 538
 539         mono_array_set (ah->res, gpointer, ah->idx++, mono_assembly_get_object (ah->domain, value));
 540 }
 541
 542 MonoArray *
 543 ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad)
 544 {
 545         MonoDomain *domain = ad->data;
 546         static MonoClass *System_Reflection_Assembly;
 547         MonoArray *res;
 548         add_assembly_helper_t ah;
 549
 550         if (!System_Reflection_Assembly)
 551                 System_Reflection_Assembly = mono_class_from_name (
 552                         mono_defaults.corlib, "System.Reflection", "Assembly");
 553
 554         res = mono_array_new (domain, System_Reflection_Assembly, g_hash_table_size (domain->assemblies));
 555
 556         ah.domain = domain;
 557         ah.res = res;
 558         ah.idx = 0;
 559         g_hash_table_foreach (domain->assemblies, add_assembly, &ah);
 560
 561         return res;
 562 }
 563
 564
 565 MonoReflectionAssembly *
 566 ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoReflectionAssemblyName *assRef, MonoObject *evidence)
 567 {
 568         MonoDomain *domain = ad->data;
 569         char *name, *filename;
 570         enum MonoImageOpenStatus status = MONO_IMAGE_OK;
 571         MonoAssembly *ass;
 572
 573         /* FIXME : examine evidence? */
 574
 575         g_assert (assRef != NULL);
 576         g_assert (assRef->name != NULL);
 577
 578         /* FIXME : examine version, culture info */
 579
 580         name = filename = mono_string_to_utf8 (assRef->name);
 581
 582         if (strncmp (filename, "file://", 7) == 0)
 583                 filename += 7;
 584
 585         ass = mono_assembly_open (filename, NULL, &status);
 586
 587         g_free (name);
 588
 589         if (!ass)
 590                 mono_raise_exception ((MonoException *)mono_exception_from_name (mono_defaults.corlib, "System.IO", "FileNotFoundException"));
 591
 592         return mono_assembly_get_object (domain, ass);
 593 }
 594
 595 void
 596 ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
 597 {
 598         mono_domain_unload (ad->data, FALSE);
 599 }
 600
 601 /**
 602  * mono_domain_assembly_open:
 603  * @domain: the application domain
 604  * @name: file name of the assembly
 605  *
 606  * fixme: maybe we should integrate this with mono_assembly_open ??
 607  */
 608 MonoAssembly *
 609 mono_domain_assembly_open (MonoDomain *domain, char *name)
 610 {
 611         MonoAssembly *ass, *tmp;
 612         int i;
 613
 614         if ((ass = g_hash_table_lookup (domain->assemblies, name)))
 615                 return ass;
 616
 617         if (!(ass = mono_assembly_open (name, NULL, NULL)))
 618                 return NULL;
 619
 620         g_hash_table_insert (domain->assemblies, ass->name, ass);
 621
 622         // fixme: maybe this must be recursive ?
 623         for (i = 0; (tmp = ass->image->references [i]) != NULL; i++) {
 624                 if (!g_hash_table_lookup (domain->assemblies, tmp->name))
 625                         g_hash_table_insert (domain->assemblies, tmp->name, tmp);
 626         }
 627
 628         return ass;
 629 }
 630
 631 static void
 632 remove_assembly (gpointer key, gpointer value, gpointer user_data)
 633 {
 634         mono_assembly_close ((MonoAssembly *)value);
 635 }
 636
 637 void
 638 mono_domain_unload (MonoDomain *domain, gboolean force)
 639 {
 640         if ((domain == mono_root_domain) && !force) {
 641                 g_warning ("cant unload root domain");
 642                 return;
 643         }
 644
 645         g_hash_table_foreach (domain->assemblies, remove_assembly, NULL);
 646
 647         g_hash_table_destroy (domain->env);
 648         g_hash_table_destroy (domain->assemblies);
 649         g_hash_table_destroy (domain->class_vtable_hash);
 650         g_hash_table_destroy (domain->jit_code_hash);
 651         g_hash_table_destroy (domain->ldstr_table);
 652         mono_jit_info_table_free (domain->jit_info_table);
 653         mono_mempool_destroy (domain->mp);
 654
 655         // fixme: anything else required ? */
 656
 657 #if HAVE_BOEHM_GC
 658 #else
 659         g_free (domain);
 660 #endif
 661
 662         if ((domain == mono_root_domain))
 663                 mono_root_domain = NULL;
 664 }
 665
 666 gint32
 667 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
 668                                             MonoObject *evidence, MonoArray *args)
 669 {
 670         MonoDomain *cdom = mono_domain_get ();
 671         MonoAssembly *assembly;
 672         MonoImage *image;
 673         MonoCLIImageInfo *iinfo;
 674         MonoMethod *method;
 675         MonoObject *margs;
 676         char *filename;
 677         gint32 res;
 678
 679         mono_domain_set (ad->data);
 680
 681         filename = mono_string_to_utf8 (file);
 682         assembly = mono_assembly_open (filename, NULL, NULL);
 683         g_free (filename);
 684
 685         if (!assembly) {
 686                 mono_raise_exception ((MonoException *)mono_exception_from_name (
 687                         mono_defaults.corlib, "System.IO", "FileNotFoundException"));
 688         }
 689
 690         image = assembly->image;
 691         iinfo = image->image_info;
 692         method = mono_get_method (image, iinfo->cli_cli_header.ch_entry_point, NULL);
 693
 694         if (!method)
 695                 g_error ("No entry point method found in %s", image->name);
 696
 697         margs = mono_domain_transfer_object (cdom, ad->data, (MonoObject *)args);
 698         res = mono_runtime_exec_main (method, (MonoArray *)margs);
 699
 700         mono_domain_set (cdom);
 701
 702         return res;
 703 }
 704