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.Runtime.Remoting.Messaging",
 283                 "AsyncResult");
 284         g_assert (mono_defaults.asyncresult_class != 0 );
 285
 286         mono_defaults.waithandle_class = mono_class_from_name (
 287                 mono_defaults.corlib, "System.Threading", "WaitHandle");
 288         g_assert (mono_defaults.waithandle_class != 0 );
 289
 290         mono_defaults.typehandle_class = mono_class_from_name (
 291                 mono_defaults.corlib, "System", "RuntimeTypeHandle");
 292         g_assert (mono_defaults.typehandle_class != 0);
 293
 294         mono_defaults.methodhandle_class = mono_class_from_name (
 295                 mono_defaults.corlib, "System", "RuntimeMethodHandle");
 296         g_assert (mono_defaults.methodhandle_class != 0);
 297
 298         mono_defaults.fieldhandle_class = mono_class_from_name (
 299                 mono_defaults.corlib, "System", "RuntimeFieldHandle");
 300         g_assert (mono_defaults.fieldhandle_class != 0);
 301
 302         mono_defaults.monotype_class = mono_class_from_name (
 303                 mono_defaults.corlib, "System", "MonoType");
 304         g_assert (mono_defaults.monotype_class != 0);
 305
 306         mono_defaults.exception_class = mono_class_from_name (
 307                 mono_defaults.corlib, "System", "Exception");
 308         g_assert (mono_defaults.exception_class != 0);
 309
 310         mono_defaults.thread_class = mono_class_from_name (
 311                 mono_defaults.corlib, "System.Threading", "Thread");
 312         g_assert (mono_defaults.thread_class != 0);
 313
 314         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
 315         setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
 316         ves_icall_System_AppDomainSetup_InitAppDomainSetup (setup);
 317
 318         name = mono_string_new (domain, g_path_get_basename (filename));
 319
 320         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 321         ad = (MonoAppDomain *) mono_object_new (domain, class);
 322         ad->data = domain;
 323         domain->domain = ad;
 324         domain->setup = setup;
 325         domain->friendly_name = name;
 326
 327         return domain;
 328 }
 329
 330 void
 331 ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
 332 {
 333         // fixme: implement me
 334 }
 335
 336 /**
 337  * mono_domain_transfer_object:
 338  * @src: the source domain
 339  * @dst: the destination domain
 340  * @obj: the object to transfer
 341  *
 342  * This function is used to transfer objects between domains. This is done by
 343  * marshalling or serialisation.
 344  */
 345 static MonoObject *
 346 mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj)
 347 {
 348         MonoClass *klass;
 349         MonoObject *res;
 350
 351         if (!obj)
 352                 return NULL;
 353
 354         g_assert (obj->vtable->domain == src);
 355
 356         /* fixme: transfer an object from one domain into another */
 357
 358         klass = obj->vtable->klass;
 359
 360         if (MONO_CLASS_IS_ARRAY (klass)) {
 361                 MonoArray *ao = (MonoArray *)obj;
 362                 int esize, ecount, i;
 363                 guint32 *sizes;
 364
 365                 sizes = alloca (klass->rank * sizeof(guint32) * 2);
 366                 esize = mono_array_element_size (klass);
 367                 ecount = 1;
 368                 for (i = 0; i < klass->rank; ++i) {
 369                         sizes [i] = ao->bounds [i].length;
 370                         ecount *= ao->bounds [i].length;
 371                         sizes [i + klass->rank] = ao->bounds [i].lower_bound;
 372                 }
 373                 res = (MonoObject *)mono_array_new_full (dst, klass, sizes, sizes + klass->rank);
 374                 if (klass->element_class->valuetype) {
 375                         memcpy (res, (char *)ao + sizeof(MonoArray), esize * ecount);
 376                 } else {
 377                         g_assert (esize == sizeof (gpointer));
 378                         for (i = 0; i < ecount; i++) {
 379                                 int offset = sizeof (MonoArray) + esize * i;
 380                                 gpointer *src_ea = (gpointer *)((char *)ao + offset);
 381                                 gpointer *dst_ea = (gpointer *)((char *)res + offset);
 382
 383                                 *dst_ea = mono_domain_transfer_object (src, dst, *src_ea);
 384                         }
 385                 }
 386         } else if (klass == mono_defaults.string_class) {
 387                 MonoString *str = (MonoString *)obj;
 388                 res = (MonoObject *)mono_string_new_utf16 (dst,
 389                         (const guint16 *)str->c_str->vector, str->length);
 390         } else {
 391                 // fixme: we need generic marshalling code here */
 392                 g_assert_not_reached ();
 393         }
 394
 395         return res;
 396 }
 397
 398 MonoObject *
 399 ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
 400 {
 401         MonoDomain *add = ad->data;
 402         MonoDomain *cur = mono_domain_get ();
 403         MonoObject *o;
 404         char *str;
 405
 406         g_assert (ad != NULL);
 407         g_assert (name != NULL);
 408
 409         str = mono_string_to_utf8 (name);
 410
 411         if (!strcmp (str, "APPBASE"))
 412                 o = (MonoObject *)add->setup->application_base;
 413         else if (!strcmp (str, "APP_CONFIG_FILE"))
 414                 o = (MonoObject *)add->setup->configuration_file;
 415         else if (!strcmp (str, "DYNAMIC_BASE"))
 416                 o = (MonoObject *)add->setup->dynamic_base;
 417         else if (!strcmp (str, "APP_NAME"))
 418                 o = (MonoObject *)add->setup->application_name;
 419         else if (!strcmp (str, "CACHE_BASE"))
 420                 o = (MonoObject *)add->setup->cache_path;
 421         else if (!strcmp (str, "PRIVATE_BINPATH"))
 422                 o = (MonoObject *)add->setup->private_bin_path;
 423         else if (!strcmp (str, "BINPATH_PROBE_ONLY"))
 424                 o = (MonoObject *)add->setup->private_bin_path_probe;
 425         else if (!strcmp (str, "SHADOW_COPY_DIRS"))
 426                 o = (MonoObject *)add->setup->shadow_copy_directories;
 427         else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
 428                 o = (MonoObject *)add->setup->shadow_copy_files;
 429         else
 430                 o = g_hash_table_lookup (add->env, str);
 431
 432         g_free (str);
 433
 434         if (!o)
 435                 return NULL;
 436
 437         return mono_domain_transfer_object (add, cur, o);
 438 }
 439
 440 void
 441 ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
 442 {
 443         MonoDomain *add = ad->data;
 444         MonoDomain *cur = mono_domain_get ();
 445         MonoObject *o;
 446         char *str;
 447
 448         g_assert (ad != NULL);
 449         g_assert (name != NULL);
 450
 451         o = mono_domain_transfer_object (cur, add, data);
 452
 453         /* fixme: need a hash func for MonoString */
 454         str = mono_string_to_utf8 (name);
 455         g_hash_table_insert (add->env, str, o);
 456         g_free (str);
 457 }
 458
 459 MonoAppDomainSetup *
 460 ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
 461 {
 462         g_assert (ad != NULL);
 463         g_assert (ad->data != NULL);
 464
 465         return ad->data->setup;
 466 }
 467
 468 MonoString *
 469 ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
 470 {
 471         g_assert (ad != NULL);
 472         g_assert (ad->data != NULL);
 473
 474         return ad->data->friendly_name;
 475 }
 476
 477 /**
 478  * mono_domain_get:
 479  *
 480  * Returns the current domain.
 481  */
 482 inline MonoDomain *
 483 mono_domain_get ()
 484 {
 485         return ((MonoDomain *)TlsGetValue (appdomain_thread_id));
 486 }
 487
 488 /**
 489  * mono_domain_set:
 490  * @domain: the new domain
 491  *
 492  * Sets the current domain to @domain.
 493  */
 494 inline void
 495 mono_domain_set (MonoDomain *domain)
 496 {
 497         TlsSetValue (appdomain_thread_id, domain);
 498 }
 499
 500 MonoAppDomain *
 501 ves_icall_System_AppDomain_getCurDomain ()
 502 {
 503         MonoDomain *add = mono_domain_get ();
 504         return add->domain;
 505 }
 506
 507 MonoAppDomain *
 508 ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
 509 {
 510         MonoDomain *domain = mono_domain_get ();
 511         MonoClass *adclass;
 512         MonoAppDomain *ad;
 513         MonoDomain *data;
 514
 515         adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 516
 517         // fixme: pin all those objects
 518         ad = (MonoAppDomain *) mono_object_new (domain, adclass);
 519         ad->data = data = mono_create_domain ();
 520         data->domain = ad;
 521         data->setup = setup;
 522         data->friendly_name = friendly_name;
 523
 524         // fixme: what to do next ?
 525
 526         return ad;
 527 }
 528
 529 typedef struct {
 530         MonoArray *res;
 531         MonoDomain *domain;
 532         int idx;
 533 } add_assembly_helper_t;
 534
 535 static void
 536 add_assembly (gpointer key, gpointer value, gpointer user_data)
 537 {
 538         add_assembly_helper_t *ah = (add_assembly_helper_t *) user_data;
 539
 540         mono_array_set (ah->res, gpointer, ah->idx++, mono_assembly_get_object (ah->domain, value));
 541 }
 542
 543 MonoArray *
 544 ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad)
 545 {
 546         MonoDomain *domain = ad->data;
 547         static MonoClass *System_Reflection_Assembly;
 548         MonoArray *res;
 549         add_assembly_helper_t ah;
 550
 551         if (!System_Reflection_Assembly)
 552                 System_Reflection_Assembly = mono_class_from_name (
 553                         mono_defaults.corlib, "System.Reflection", "Assembly");
 554
 555         res = mono_array_new (domain, System_Reflection_Assembly, g_hash_table_size (domain->assemblies));
 556
 557         ah.domain = domain;
 558         ah.res = res;
 559         ah.idx = 0;
 560         g_hash_table_foreach (domain->assemblies, add_assembly, &ah);
 561
 562         return res;
 563 }
 564
 565
 566 MonoReflectionAssembly *
 567 ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoReflectionAssemblyName *assRef, MonoObject *evidence)
 568 {
 569         MonoDomain *domain = ad->data;
 570         char *name, *filename;
 571         enum MonoImageOpenStatus status = MONO_IMAGE_OK;
 572         MonoAssembly *ass;
 573
 574         /* FIXME : examine evidence? */
 575
 576         g_assert (assRef != NULL);
 577         g_assert (assRef->name != NULL);
 578
 579         /* FIXME : examine version, culture info */
 580
 581         name = filename = mono_string_to_utf8 (assRef->name);
 582
 583         if (strncmp (filename, "file://", 7) == 0)
 584                 filename += 7;
 585
 586         ass = mono_assembly_open (filename, NULL, &status);
 587
 588         g_free (name);
 589
 590         if (!ass)
 591                 mono_raise_exception ((MonoException *)mono_exception_from_name (mono_defaults.corlib, "System.IO", "FileNotFoundException"));
 592
 593         return mono_assembly_get_object (domain, ass);
 594 }
 595
 596 void
 597 ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
 598 {
 599         mono_domain_unload (ad->data, FALSE);
 600 }
 601
 602 /**
 603  * mono_domain_assembly_open:
 604  * @domain: the application domain
 605  * @name: file name of the assembly
 606  *
 607  * fixme: maybe we should integrate this with mono_assembly_open ??
 608  */
 609 MonoAssembly *
 610 mono_domain_assembly_open (MonoDomain *domain, char *name)
 611 {
 612         MonoAssembly *ass, *tmp;
 613         int i;
 614
 615         if ((ass = g_hash_table_lookup (domain->assemblies, name)))
 616                 return ass;
 617
 618         if (!(ass = mono_assembly_open (name, NULL, NULL)))
 619                 return NULL;
 620
 621         g_hash_table_insert (domain->assemblies, ass->name, ass);
 622
 623         // fixme: maybe this must be recursive ?
 624         for (i = 0; (tmp = ass->image->references [i]) != NULL; i++) {
 625                 if (!g_hash_table_lookup (domain->assemblies, tmp->name))
 626                         g_hash_table_insert (domain->assemblies, tmp->name, tmp);
 627         }
 628
 629         return ass;
 630 }
 631
 632 static void
 633 remove_assembly (gpointer key, gpointer value, gpointer user_data)
 634 {
 635         mono_assembly_close ((MonoAssembly *)value);
 636 }
 637
 638 void
 639 mono_domain_unload (MonoDomain *domain, gboolean force)
 640 {
 641         if ((domain == mono_root_domain) && !force) {
 642                 g_warning ("cant unload root domain");
 643                 return;
 644         }
 645
 646         g_hash_table_foreach (domain->assemblies, remove_assembly, NULL);
 647
 648         g_hash_table_destroy (domain->env);
 649         g_hash_table_destroy (domain->assemblies);
 650         g_hash_table_destroy (domain->class_vtable_hash);
 651         g_hash_table_destroy (domain->jit_code_hash);
 652         g_hash_table_destroy (domain->ldstr_table);
 653         mono_jit_info_table_free (domain->jit_info_table);
 654         mono_mempool_destroy (domain->mp);
 655
 656         // fixme: anything else required ? */
 657
 658 #if HAVE_BOEHM_GC
 659 #else
 660         g_free (domain);
 661 #endif
 662
 663         if ((domain == mono_root_domain))
 664                 mono_root_domain = NULL;
 665 }
 666
 667 gint32
 668 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
 669                                             MonoObject *evidence, MonoArray *args)
 670 {
 671         MonoDomain *cdom = mono_domain_get ();
 672         MonoAssembly *assembly;
 673         MonoImage *image;
 674         MonoCLIImageInfo *iinfo;
 675         MonoMethod *method;
 676         MonoObject *margs;
 677         char *filename;
 678         gint32 res;
 679
 680         mono_domain_set (ad->data);
 681
 682         filename = mono_string_to_utf8 (file);
 683         assembly = mono_assembly_open (filename, NULL, NULL);
 684         g_free (filename);
 685
 686         if (!assembly) {
 687                 mono_raise_exception ((MonoException *)mono_exception_from_name (
 688                         mono_defaults.corlib, "System.IO", "FileNotFoundException"));
 689         }
 690
 691         image = assembly->image;
 692         iinfo = image->image_info;
 693         method = mono_get_method (image, iinfo->cli_cli_header.ch_entry_point, NULL);
 694
 695         if (!method)
 696                 g_error ("No entry point method found in %s", image->name);
 697
 698         margs = mono_domain_transfer_object (cdom, ad->data, (MonoObject *)args);
 699         res = mono_runtime_exec_main (method, (MonoArray *)margs);
 700
 701         mono_domain_set (cdom);
 702
 703         return res;
 704 }
 705