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