mono/metadata/domain-internals.h

   1 /*
   2  * Appdomain-related internal data structures and functions.
   3  * Copyright 2012 Xamarin Inc (http://www.xamarin.com)
   4  */
   5 #ifndef __MONO_METADATA_DOMAIN_INTERNALS_H__
   6 #define __MONO_METADATA_DOMAIN_INTERNALS_H__
   7
   8 #include <mono/metadata/appdomain.h>
   9 #include <mono/metadata/mempool.h>
  10 #include <mono/metadata/lock-tracer.h>
  11 #include <mono/utils/mono-codeman.h>
  12 #include <mono/metadata/mono-hash.h>
  13 #include <mono/utils/mono-compiler.h>
  14 #include <mono/utils/mono-internal-hash.h>
  15 #include <mono/io-layer/io-layer.h>
  16 #include <mono/metadata/mempool-internals.h>
  17
  18 /*
  19  * If this is set, the memory belonging to appdomains is not freed when a domain is
  20  * unloaded, and assemblies loaded by the appdomain are not unloaded either. This
  21  * allows us to use typed gc in non-default appdomains too, leading to increased
  22  * performance.
  23  */
  24 extern gboolean mono_dont_free_domains;
  25
  26 /* This is a copy of System.AppDomainSetup */
  27 typedef struct {
  28         MonoObject object;
  29         MonoString *application_base;
  30         MonoString *application_name;
  31         MonoString *cache_path;
  32         MonoString *configuration_file;
  33         MonoString *dynamic_base;
  34         MonoString *license_file;
  35         MonoString *private_bin_path;
  36         MonoString *private_bin_path_probe;
  37         MonoString *shadow_copy_directories;
  38         MonoString *shadow_copy_files;
  39         MonoBoolean publisher_policy;
  40         MonoBoolean path_changed;
  41         int loader_optimization;
  42         MonoBoolean disallow_binding_redirects;
  43         MonoBoolean disallow_code_downloads;
  44         MonoObject *activation_arguments; /* it is System.Object in 1.x, ActivationArguments in 2.0 */
  45         MonoObject *domain_initializer;
  46         MonoObject *application_trust; /* it is System.Object in 1.x, ApplicationTrust in 2.0 */
  47         MonoArray *domain_initializer_args;
  48         MonoBoolean disallow_appbase_probe;
  49         MonoArray *configuration_bytes;
  50         MonoArray *serialized_non_primitives;
  51 } MonoAppDomainSetup;
  52
  53 typedef struct _MonoJitInfoTable MonoJitInfoTable;
  54 typedef struct _MonoJitInfoTableChunk MonoJitInfoTableChunk;
  55
  56 #define MONO_JIT_INFO_TABLE_CHUNK_SIZE          64
  57
  58 struct _MonoJitInfoTableChunk
  59 {
  60         int                    refcount;
  61         volatile int           num_elements;
  62         volatile gint8        *last_code_end;
  63         MonoJitInfo * volatile data [MONO_JIT_INFO_TABLE_CHUNK_SIZE];
  64 };
  65
  66 struct _MonoJitInfoTable
  67 {
  68         MonoDomain             *domain;
  69         int                     num_chunks;
  70         MonoJitInfoTableChunk  *chunks [MONO_ZERO_LEN_ARRAY];
  71 };
  72
  73 #define MONO_SIZEOF_JIT_INFO_TABLE (sizeof (struct _MonoJitInfoTable) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P)
  74
  75 typedef GArray MonoAotModuleInfoTable;
  76
  77 typedef struct {
  78         guint32  flags;
  79         gint32   exvar_offset;
  80         gpointer try_start;
  81         gpointer try_end;
  82         gpointer handler_start;
  83         /*
  84          * For LLVM compiled code, this is the index of the il clause
  85          * associated with this handler.
  86          */
  87         int clause_index;
  88         uint32_t try_offset;
  89         uint32_t try_len;
  90         uint32_t handler_offset;
  91         uint32_t handler_len;
  92         union {
  93                 MonoClass *catch_class;
  94                 gpointer filter;
  95                 gpointer handler_end;
  96         } data;
  97 } MonoJitExceptionInfo;
  98
  99 /*
 100  * Contains information about the type arguments for generic shared methods.
 101  */
 102 typedef struct {
 103         gboolean is_gsharedvt;
 104 } MonoGenericSharingContext;
 105
 106 /* Simplified DWARF location list entry */
 107 typedef struct {
 108         /* Whenever the value is in a register */
 109         gboolean is_reg;
 110         /*
 111          * If is_reg is TRUE, the register which contains the value. Otherwise
 112          * the base register.
 113          */
 114         int reg;
 115         /*
 116          * If is_reg is FALSE, the offset of the stack location relative to 'reg'.
 117          * Otherwise, 0.
 118          */
 119         int offset;
 120         /*
 121          * Offsets of the PC interval where the value is in this location.
 122          */
 123         int from, to;
 124 } MonoDwarfLocListEntry;
 125
 126 typedef struct
 127 {
 128         MonoGenericSharingContext *generic_sharing_context;
 129         int nlocs;
 130         MonoDwarfLocListEntry *locations;
 131         gint32 this_offset;
 132         guint8 this_reg;
 133         gboolean has_this:1;
 134         gboolean this_in_reg:1;
 135 } MonoGenericJitInfo;
 136
 137 /*
 138 A try block hole is used to represent a non-contiguous part of
 139 of a segment of native code protected by a given .try block.
 140 Usually, a try block is defined as a contiguous segment of code.
 141 But in some cases it's needed to have some parts of it to not be protected.
 142 For example, given "try {} finally {}", the code in the .try block to call
 143 the finally part looks like:
 144
 145 try {
 146     ...
 147         call finally_block
 148         adjust stack
 149         jump outside try block
 150         ...
 151 } finally {
 152         ...
 153 }
 154
 155 The instructions between the call and the jump should not be under the try block since they happen
 156 after the finally block executes, which means if an async exceptions happens at that point we would
 157 execute the finally clause twice. So, to avoid this, we introduce a hole in the try block to signal
 158 that those instructions are not protected.
 159 */
 160 typedef struct
 161 {
 162         guint32 offset;
 163         guint16 clause;
 164         guint16 length;
 165 } MonoTryBlockHoleJitInfo;
 166
 167 typedef struct
 168 {
 169         guint16 num_holes;
 170         MonoTryBlockHoleJitInfo holes [MONO_ZERO_LEN_ARRAY];
 171 } MonoTryBlockHoleTableJitInfo;
 172
 173 typedef struct
 174 {
 175         guint32 stack_size;
 176         guint32 epilog_size;
 177 } MonoArchEHJitInfo;
 178
 179 typedef struct {
 180         /* Relative to code_start */
 181         int thunks_offset;
 182         int thunks_size;
 183 } MonoThunkJitInfo;
 184
 185 typedef enum {
 186         JIT_INFO_NONE = 0,
 187         JIT_INFO_HAS_GENERIC_JIT_INFO = (1 << 0),
 188         JIT_INFO_HAS_TRY_BLOCK_HOLES = (1 << 1),
 189         JIT_INFO_HAS_ARCH_EH_INFO = (1 << 2),
 190         JIT_INFO_HAS_THUNK_INFO = (1 << 3)
 191 } MonoJitInfoFlags;
 192
 193 struct _MonoJitInfo {
 194         /* NOTE: These first two elements (method and
 195            next_jit_code_hash) must be in the same order and at the
 196            same offset as in RuntimeMethod, because of the jit_code_hash
 197            internal hash table in MonoDomain. */
 198         union {
 199                 MonoMethod *method;
 200                 MonoImage *image;
 201                 gpointer aot_info;
 202                 gpointer tramp_info;
 203         } d;
 204         struct _MonoJitInfo *next_jit_code_hash;
 205         gpointer    code_start;
 206         guint32     unwind_info;
 207         int         code_size;
 208         guint32     num_clauses:15;
 209         /* Whenever the code is domain neutral or 'shared' */
 210         gboolean    domain_neutral:1;
 211         gboolean    has_generic_jit_info:1;
 212         gboolean    has_try_block_holes:1;
 213         gboolean    has_arch_eh_info:1;
 214         gboolean    has_thunk_info:1;
 215         gboolean    from_aot:1;
 216         gboolean    from_llvm:1;
 217         gboolean    dbg_attrs_inited:1;
 218         gboolean    dbg_hidden:1;
 219         /* Whenever this jit info was loaded in async context */
 220         gboolean    async:1;
 221         gboolean    dbg_step_through:1;
 222         gboolean    dbg_non_user_code:1;
 223         /*
 224          * Whenever this jit info refers to a trampoline.
 225          * d.tramp_info contains additional data in this case.
 226          */
 227         gboolean    is_trampoline:1;
 228
 229         /* FIXME: Embed this after the structure later*/
 230         gpointer    gc_info; /* Currently only used by SGen */
 231
 232         MonoJitExceptionInfo clauses [MONO_ZERO_LEN_ARRAY];
 233         /* There is an optional MonoGenericJitInfo after the clauses */
 234         /* There is an optional MonoTryBlockHoleTableJitInfo after MonoGenericJitInfo clauses*/
 235         /* There is an optional MonoArchEHJitInfo after MonoTryBlockHoleTableJitInfo */
 236         /* There is an optional MonoThunkJitInfo after MonoArchEHJitInfo */
 237 };
 238
 239 #define MONO_SIZEOF_JIT_INFO (offsetof (struct _MonoJitInfo, clauses))
 240
 241 typedef struct {
 242         gpointer *static_data; /* Used to free the static data without going through the MonoAppContext object itself. */
 243         uint32_t gc_handle;
 244 } ContextStaticData;
 245
 246 struct _MonoAppContext {
 247         MonoObject obj;
 248         gint32 domain_id;
 249         gint32 context_id;
 250         gpointer *static_data;
 251         ContextStaticData *data;
 252 };
 253
 254 /* Lock-free allocator */
 255 typedef struct {
 256         guint8 *mem;
 257         gpointer prev;
 258         int size, pos;
 259 } LockFreeMempoolChunk;
 260
 261 typedef struct {
 262         LockFreeMempoolChunk *current, *chunks;
 263 } LockFreeMempool;
 264
 265 /*
 266  * We have two unloading states because the domain
 267  * must remain fully functional while AppDomain::DomainUnload is
 268  * processed.
 269  * After that unloading began and all domain facilities are teared down
 270  * such as execution of new threadpool jobs.
 271  */
 272 typedef enum {
 273         MONO_APPDOMAIN_CREATED,
 274         MONO_APPDOMAIN_UNLOADING_START,
 275         MONO_APPDOMAIN_UNLOADING,
 276         MONO_APPDOMAIN_UNLOADED
 277 } MonoAppDomainState;
 278
 279 typedef struct _MonoThunkFreeList {
 280         guint32 size;
 281         int length;             /* only valid for the wait list */
 282         struct _MonoThunkFreeList *next;
 283 } MonoThunkFreeList;
 284
 285 typedef struct _MonoJitCodeHash MonoJitCodeHash;
 286
 287 struct _MonoDomain {
 288         /*
 289          * This lock must never be taken before the loader lock,
 290          * i.e. if both are taken by the same thread, the loader lock
 291          * must taken first.
 292          */
 293         MonoCoopMutex    lock;
 294         MonoMemPool        *mp;
 295         MonoCodeManager    *code_mp;
 296         /*
 297          * keep all the managed objects close to each other for the precise GC
 298          * For the Boehm GC we additionally keep close also other GC-tracked pointers.
 299          */
 300 #define MONO_DOMAIN_FIRST_OBJECT setup
 301         MonoAppDomainSetup *setup;
 302         MonoAppDomain      *domain;
 303         MonoAppContext     *default_context;
 304         MonoException      *out_of_memory_ex;
 305         MonoException      *null_reference_ex;
 306         MonoException      *stack_overflow_ex;
 307         /* typeof (void) */
 308         MonoObject         *typeof_void;
 309         /* Ephemeron Tombstone*/
 310         MonoObject         *ephemeron_tombstone;
 311         /* new MonoType [0] */
 312         MonoArray          *empty_types;
 313         /*
 314          * The fields between FIRST_GC_TRACKED and LAST_GC_TRACKED are roots, but
 315          * not object references.
 316          */
 317 #define MONO_DOMAIN_FIRST_GC_TRACKED env
 318         MonoGHashTable     *env;
 319         MonoGHashTable     *ldstr_table;
 320         /* hashtables for Reflection handles */
 321         MonoGHashTable     *type_hash;
 322         MonoGHashTable     *refobject_hash;
 323         /* a GC-tracked array to keep references to the static fields of types */
 324         gpointer           *static_data_array;
 325         /* maps class -> type initialization exception object */
 326         MonoGHashTable    *type_init_exception_hash;
 327         /* maps delegate trampoline addr -> delegate object */
 328         MonoGHashTable     *delegate_hash_table;
 329 #define MONO_DOMAIN_LAST_GC_TRACKED delegate_hash_table
 330         guint32            state;
 331         /* Needed by Thread:GetDomainID() */
 332         gint32             domain_id;
 333         gint32             shadow_serial;
 334         unsigned char      inet_family_hint; // used in socket-io.c as a cache
 335         GSList             *domain_assemblies;
 336         MonoAssembly       *entry_assembly;
 337         char               *friendly_name;
 338         GPtrArray          *class_vtable_array;
 339         /* maps remote class key -> MonoRemoteClass */
 340         GHashTable         *proxy_vtable_hash;
 341         /* Protected by 'jit_code_hash_lock' */
 342         MonoInternalHashTable jit_code_hash;
 343         mono_mutex_t    jit_code_hash_lock;
 344         int                 num_jit_info_tables;
 345         MonoJitInfoTable *
 346           volatile          jit_info_table;
 347         /*
 348          * Contains information about AOT loaded code.
 349          * Only used in the root domain.
 350          */
 351         MonoJitInfoTable *
 352           volatile          aot_modules;
 353         GSList             *jit_info_free_queue;
 354         /* Used when loading assemblies */
 355         gchar **search_path;
 356         gchar *private_bin_path;
 357         LockFreeMempool *lock_free_mp;
 358
 359         /* Used by remoting proxies */
 360         MonoMethod         *create_proxy_for_type_method;
 361         MonoMethod         *private_invoke_method;
 362         /* Used to store offsets of thread and context static fields */
 363         GHashTable         *special_static_fields;
 364         /*
 365          * This must be a GHashTable, since these objects can't be finalized
 366          * if the hashtable contains a GC visible reference to them.
 367          */
 368         GHashTable         *finalizable_objects_hash;
 369
 370         /* Protects the three hashes above */
 371         mono_mutex_t   finalizable_objects_hash_lock;
 372         /* Used when accessing 'domain_assemblies' */
 373         mono_mutex_t    assemblies_lock;
 374
 375         GHashTable         *method_rgctx_hash;
 376
 377         GHashTable         *generic_virtual_cases;
 378         MonoThunkFreeList **thunk_free_lists;
 379
 380         GHashTable     *generic_virtual_thunks;
 381
 382         /* Information maintained by the JIT engine */
 383         gpointer runtime_info;
 384
 385         /*thread pool jobs, used to coordinate shutdown.*/
 386         volatile int                    threadpool_jobs;
 387         HANDLE                          cleanup_semaphore;
 388
 389         /* Contains the compiled runtime invoke wrapper used by finalizers */
 390         gpointer            finalize_runtime_invoke;
 391
 392         /* Contains the compiled runtime invoke wrapper used by async resylt creation to capture thread context*/
 393         gpointer            capture_context_runtime_invoke;
 394
 395         /* Contains the compiled method used by async resylt creation to capture thread context*/
 396         gpointer            capture_context_method;
 397
 398         /* Assembly bindings, the per-domain part */
 399         GSList *assembly_bindings;
 400         gboolean assembly_bindings_parsed;
 401
 402         /* Used by socket-io.c */
 403         /* These are domain specific, since the assembly can be unloaded */
 404         MonoImage *socket_assembly;
 405         MonoClass *sockaddr_class;
 406         MonoClassField *sockaddr_data_field;
 407
 408         /* Cache function pointers for architectures  */
 409         /* that require wrappers */
 410         GHashTable *ftnptrs_hash;
 411
 412         /* Maps MonoMethod* to weak links to DynamicMethod objects */
 413         GHashTable *method_to_dyn_method;
 414
 415         guint32 execution_context_field_offset;
 416 };
 417
 418 typedef struct  {
 419         guint16 major, minor, build, revision;
 420 } AssemblyVersionSet;
 421
 422 /* MonoRuntimeInfo: Contains information about versions supported by this runtime */
 423 typedef struct  {
 424         const char runtime_version [12];
 425         const char framework_version [4];
 426         const AssemblyVersionSet version_sets [4];
 427 } MonoRuntimeInfo;
 428
 429 #define mono_domain_assemblies_lock(domain) mono_locks_os_acquire(&(domain)->assemblies_lock, DomainAssembliesLock)
 430 #define mono_domain_assemblies_unlock(domain) mono_locks_os_release(&(domain)->assemblies_lock, DomainAssembliesLock)
 431 #define mono_domain_jit_code_hash_lock(domain) mono_locks_os_acquire(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock)
 432 #define mono_domain_jit_code_hash_unlock(domain) mono_locks_os_release(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock)
 433
 434 typedef MonoDomain* (*MonoLoadFunc) (const char *filename, const char *runtime_version);
 435
 436 void mono_domain_lock (MonoDomain *domain);
 437 void mono_domain_unlock (MonoDomain *domain);
 438
 439 void
 440 mono_install_runtime_load  (MonoLoadFunc func);
 441
 442 MonoDomain*
 443 mono_runtime_load (const char *filename, const char *runtime_version);
 444
 445 typedef void (*MonoCreateDomainFunc) (MonoDomain *domain);
 446
 447 void
 448 mono_install_create_domain_hook (MonoCreateDomainFunc func);
 449
 450 typedef void (*MonoFreeDomainFunc) (MonoDomain *domain);
 451
 452 void
 453 mono_install_free_domain_hook (MonoFreeDomainFunc func);
 454
 455 void
 456 mono_cleanup (void);
 457
 458 void
 459 mono_close_exe_image (void);
 460
 461 int
 462 mono_jit_info_size (MonoJitInfoFlags flags, int num_clauses, int num_holes);
 463
 464 void
 465 mono_jit_info_init (MonoJitInfo *ji, MonoMethod *method, guint8 *code, int code_size,
 466                                         MonoJitInfoFlags flags, int num_clauses, int num_holes);
 467
 468 MonoJitInfoTable *
 469 mono_jit_info_table_new (MonoDomain *domain);
 470
 471 void
 472 mono_jit_info_table_free (MonoJitInfoTable *table);
 473
 474 void
 475 mono_jit_info_table_add    (MonoDomain *domain, MonoJitInfo *ji);
 476
 477 void
 478 mono_jit_info_table_remove (MonoDomain *domain, MonoJitInfo *ji);
 479
 480 void
 481 mono_jit_info_add_aot_module (MonoImage *image, gpointer start, gpointer end);
 482
 483 MonoGenericJitInfo*
 484 mono_jit_info_get_generic_jit_info (MonoJitInfo *ji);
 485
 486 MonoGenericSharingContext*
 487 mono_jit_info_get_generic_sharing_context (MonoJitInfo *ji);
 488
 489 void
 490 mono_jit_info_set_generic_sharing_context (MonoJitInfo *ji, MonoGenericSharingContext *gsctx);
 491
 492 char *
 493 mono_make_shadow_copy (const char *filename);
 494
 495 gboolean
 496 mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name);
 497
 498 gpointer
 499 mono_domain_alloc  (MonoDomain *domain, guint size);
 500
 501 gpointer
 502 mono_domain_alloc0 (MonoDomain *domain, guint size);
 503
 504 gpointer
 505 mono_domain_alloc0_lock_free (MonoDomain *domain, guint size);
 506
 507 void*
 508 mono_domain_code_reserve (MonoDomain *domain, int size) MONO_LLVM_INTERNAL;
 509
 510 void*
 511 mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment);
 512
 513 void
 514 mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize);
 515
 516 void *
 517 nacl_domain_get_code_dest (MonoDomain *domain, void *data);
 518
 519 void
 520 nacl_domain_code_validate (MonoDomain *domain, guint8 **buf_base, int buf_size, guint8 **code_end);
 521
 522 void
 523 mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data);
 524
 525 void
 526 mono_domain_unset (void);
 527
 528 void
 529 mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception);
 530
 531 MonoTryBlockHoleTableJitInfo*
 532 mono_jit_info_get_try_block_hole_table_info (MonoJitInfo *ji);
 533
 534 MonoArchEHJitInfo*
 535 mono_jit_info_get_arch_eh_info (MonoJitInfo *ji);
 536
 537 MonoThunkJitInfo*
 538 mono_jit_info_get_thunk_info (MonoJitInfo *ji);
 539
 540 /*
 541  * Installs a new function which is used to return a MonoJitInfo for a method inside
 542  * an AOT module.
 543  */
 544 typedef MonoJitInfo *(*MonoJitInfoFindInAot)         (MonoDomain *domain, MonoImage *image, gpointer addr);
 545 void          mono_install_jit_info_find_in_aot (MonoJitInfoFindInAot func);
 546
 547 void
 548 mono_jit_code_hash_init (MonoInternalHashTable *jit_code_hash);
 549
 550 MonoAppDomain *
 551 ves_icall_System_AppDomain_getCurDomain            (void);
 552
 553 MonoAppDomain *
 554 ves_icall_System_AppDomain_getRootDomain           (void);
 555
 556 MonoAppDomain *
 557 ves_icall_System_AppDomain_createDomain            (MonoString         *friendly_name,
 558                                                     MonoAppDomainSetup *setup);
 559
 560 MonoObject *
 561 ves_icall_System_AppDomain_GetData                 (MonoAppDomain *ad,
 562                                                     MonoString    *name);
 563
 564 MonoReflectionAssembly *
 565 ves_icall_System_AppDomain_LoadAssemblyRaw         (MonoAppDomain *ad,
 566                                                     MonoArray *raw_assembly,
 567                                                     MonoArray *raw_symbol_store,
 568                                                     MonoObject *evidence,
 569                                                     MonoBoolean refonly);
 570
 571 void
 572 ves_icall_System_AppDomain_SetData                 (MonoAppDomain *ad,
 573                                                     MonoString    *name,
 574                                                     MonoObject    *data);
 575
 576 MonoAppDomainSetup *
 577 ves_icall_System_AppDomain_getSetup                (MonoAppDomain *ad);
 578
 579 MonoString *
 580 ves_icall_System_AppDomain_getFriendlyName         (MonoAppDomain *ad);
 581
 582 MonoArray *
 583 ves_icall_System_AppDomain_GetAssemblies           (MonoAppDomain *ad,
 584                                                     MonoBoolean refonly);
 585
 586 MonoReflectionAssembly *
 587 ves_icall_System_Reflection_Assembly_LoadFrom      (MonoString *fname,
 588                                                     MonoBoolean refonly);
 589
 590 MonoReflectionAssembly *
 591 ves_icall_System_AppDomain_LoadAssembly            (MonoAppDomain *ad,
 592                                                     MonoString *assRef,
 593                                                     MonoObject    *evidence,
 594                                                     MonoBoolean refonly);
 595
 596 gboolean
 597 ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id);
 598
 599 void
 600 ves_icall_System_AppDomain_InternalUnload          (gint32 domain_id);
 601
 602 void
 603 ves_icall_System_AppDomain_DoUnhandledException (MonoException *exc);
 604
 605 gint32
 606 ves_icall_System_AppDomain_ExecuteAssembly         (MonoAppDomain *ad,
 607                                                                                                         MonoReflectionAssembly *refass,
 608                                                                                                         MonoArray     *args);
 609
 610 MonoAppDomain *
 611 ves_icall_System_AppDomain_InternalSetDomain       (MonoAppDomain *ad);
 612
 613 MonoAppDomain *
 614 ves_icall_System_AppDomain_InternalSetDomainByID   (gint32 domainid);
 615
 616 void
 617 ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad);
 618
 619 void
 620 ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id);
 621
 622 void
 623 ves_icall_System_AppDomain_InternalPopDomainRef (void);
 624
 625 MonoAppContext *
 626 ves_icall_System_AppDomain_InternalGetContext      (void);
 627
 628 MonoAppContext *
 629 ves_icall_System_AppDomain_InternalGetDefaultContext      (void);
 630
 631 MonoAppContext *
 632 ves_icall_System_AppDomain_InternalSetContext      (MonoAppContext *mc);
 633
 634 gint32
 635 ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad);
 636
 637 MonoString *
 638 ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid);
 639
 640 MonoAssembly *
 641 mono_assembly_load_corlib (const MonoRuntimeInfo *runtime, MonoImageOpenStatus *status);
 642
 643 const MonoRuntimeInfo*
 644 mono_get_runtime_info (void);
 645
 646 void
 647 mono_runtime_set_no_exec (gboolean val);
 648
 649 gboolean
 650 mono_runtime_get_no_exec (void);
 651
 652 gboolean
 653 mono_assembly_name_parse (const char *name, MonoAssemblyName *aname);
 654
 655 MonoImage *mono_assembly_open_from_bundle (const char *filename,
 656                                            MonoImageOpenStatus *status,
 657                                            gboolean refonly);
 658
 659 MONO_API void
 660 mono_domain_add_class_static_data (MonoDomain *domain, MonoClass *klass, gpointer data, guint32 *bitmap);
 661
 662 MonoReflectionAssembly *
 663 mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, MonoAssembly *requesting, gboolean refonly);
 664
 665 MonoAssembly *
 666 mono_domain_assembly_postload_search (MonoAssemblyName *aname, MonoAssembly *requesting, gboolean refonly);
 667
 668 MonoAssembly* mono_assembly_load_full_nosearch (MonoAssemblyName *aname,
 669                                                 const char       *basedir,
 670                                                 MonoImageOpenStatus *status,
 671                                                 gboolean refonly);
 672
 673 void mono_set_private_bin_path_from_config (MonoDomain *domain);
 674
 675 int mono_framework_version (void);
 676
 677 void mono_reflection_cleanup_domain (MonoDomain *domain);
 678
 679 void mono_assembly_cleanup_domain_bindings (guint32 domain_id);
 680
 681 MonoJitInfo* mono_jit_info_table_find_internal (MonoDomain *domain, char *addr, gboolean try_aot, gboolean allow_trampolines);
 682
 683 void mono_enable_debug_domain_unload (gboolean enable);
 684
 685 #endif /* __MONO_METADATA_DOMAIN_INTERNALS_H__ */