X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fdomain-internals.h;h=1c4a01c56593c160ea2b48dcfc7ce41eba065167;hb=81d05c0ea48bc2194d4eb60cd197c20131c443d5;hp=e1cd1ae322aa1f1fc0cb2846a6f6407e369c57a4;hpb=83b532d63cfe06747cd2ef9c4429cf6ceb7a685f;p=mono.git diff --git a/mono/metadata/domain-internals.h b/mono/metadata/domain-internals.h index e1cd1ae322a..1c4a01c5659 100644 --- a/mono/metadata/domain-internals.h +++ b/mono/metadata/domain-internals.h @@ -5,6 +5,7 @@ #define __MONO_METADATA_DOMAIN_INTERNALS_H__ #include +#include #include #include #include @@ -12,6 +13,7 @@ #include extern CRITICAL_SECTION mono_delegate_section; +extern CRITICAL_SECTION mono_strtod_mutex; /* * If this is set, the memory belonging to appdomains is not freed when a domain is @@ -67,6 +69,8 @@ struct _MonoJitInfoTable MonoJitInfoTableChunk *chunks [MONO_ZERO_LEN_ARRAY]; }; +#define MONO_SIZEOF_JIT_INFO_TABLE (sizeof (struct _MonoJitInfoTable) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P) + typedef GArray MonoAotModuleInfoTable; typedef struct { @@ -106,9 +110,10 @@ struct _MonoJitInfo { MonoMethod *method; struct _MonoJitInfo *next_jit_code_hash; gpointer code_start; + /* This might contain an id for the unwind info instead of a register mask */ guint32 used_regs; int code_size; - guint32 num_clauses:16; + guint32 num_clauses:15; /* Whenever the code is domain neutral or 'shared' */ gboolean domain_neutral:1; gboolean cas_inited:1; @@ -119,10 +124,18 @@ struct _MonoJitInfo { gboolean cas_method_deny:1; gboolean cas_method_permitonly:1; gboolean has_generic_jit_info:1; + gboolean from_aot:1; + gboolean from_llvm:1; +#ifdef HAVE_SGEN_GC + /* FIXME: Embed this after the structure later */ + gpointer gc_info; +#endif MonoJitExceptionInfo clauses [MONO_ZERO_LEN_ARRAY]; /* There is an optional MonoGenericJitInfo after the clauses */ }; +#define MONO_SIZEOF_JIT_INFO (offsetof (struct _MonoJitInfo, clauses)) + struct _MonoAppContext { MonoObject obj; gint32 domain_id; @@ -130,15 +143,34 @@ struct _MonoAppContext { gpointer *static_data; }; +/* + * We have two unloading states because the domain + * must remain fully functional while AppDomain::DomainUnload is + * processed. + * After that unloading began and all domain facilities are teared down + * such as execution of new threadpool jobs. + */ typedef enum { MONO_APPDOMAIN_CREATED, + MONO_APPDOMAIN_UNLOADING_START, MONO_APPDOMAIN_UNLOADING, MONO_APPDOMAIN_UNLOADED } MonoAppDomainState; +typedef struct _MonoThunkFreeList { + guint32 size; + int length; /* only valid for the wait list */ + struct _MonoThunkFreeList *next; +} MonoThunkFreeList; + typedef struct _MonoJitCodeHash MonoJitCodeHash; struct _MonoDomain { + /* + * This lock must never be taken before the loader lock, + * i.e. if both are taken by the same thread, the loader lock + * must taken first. + */ CRITICAL_SECTION lock; MonoMemPool *mp; MonoCodeManager *code_mp; @@ -153,6 +185,12 @@ struct _MonoDomain { MonoException *out_of_memory_ex; MonoException *null_reference_ex; MonoException *stack_overflow_ex; + /* typeof (void) */ + MonoObject *typeof_void; + /* + * The fields between FIRST_GC_TRACKED and LAST_GC_TRACKED are roots, but + * not object references. + */ #define MONO_DOMAIN_FIRST_GC_TRACKED env MonoGHashTable *env; MonoGHashTable *ldstr_table; @@ -198,14 +236,37 @@ struct _MonoDomain { * if the hashtable contains a GC visible reference to them. */ GHashTable *finalizable_objects_hash; +#ifndef HAVE_SGEN_GC + /* Maps MonoObjects to a GSList of WeakTrackResurrection GCHandles pointing to them */ + GHashTable *track_resurrection_objects_hash; + /* Maps WeakTrackResurrection GCHandles to the MonoObjects they point to */ + GHashTable *track_resurrection_handles_hash; +#endif + /* Protects the three hashes above */ + CRITICAL_SECTION finalizable_objects_hash_lock; /* Used when accessing 'domain_assemblies' */ CRITICAL_SECTION assemblies_lock; - GHashTable *shared_generics_hash; GHashTable *method_rgctx_hash; + GHashTable *generic_virtual_cases; + MonoThunkFreeList **thunk_free_lists; + /* Information maintained by the JIT engine */ gpointer runtime_info; + + /*thread pool jobs, used to coordinate shutdown.*/ + int threadpool_jobs; + HANDLE cleanup_semaphore; + + /* Contains the compiled runtime invoke wrapper used by finalizers */ + gpointer finalize_runtime_invoke; + + /* Contains the compiled runtime invoke wrapper used by async resylt creation to capture thread context*/ + gpointer capture_context_runtime_invoke; + + /* Contains the compiled method used by async resylt creation to capture thread context*/ + gpointer capture_context_method; }; typedef struct { @@ -219,12 +280,12 @@ typedef struct { const AssemblyVersionSet version_sets [2]; } MonoRuntimeInfo; -#define mono_domain_lock(domain) EnterCriticalSection(&(domain)->lock) -#define mono_domain_unlock(domain) LeaveCriticalSection(&(domain)->lock) -#define mono_domain_assemblies_lock(domain) EnterCriticalSection(&(domain)->assemblies_lock) -#define mono_domain_assemblies_unlock(domain) LeaveCriticalSection(&(domain)->assemblies_lock) -#define mono_domain_jit_code_hash_lock(domain) EnterCriticalSection(&(domain)->jit_code_hash_lock) -#define mono_domain_jit_code_hash_unlock(domain) LeaveCriticalSection(&(domain)->jit_code_hash_lock) +#define mono_domain_lock(domain) mono_locks_acquire(&(domain)->lock, DomainLock) +#define mono_domain_unlock(domain) mono_locks_release(&(domain)->lock, DomainLock) +#define mono_domain_assemblies_lock(domain) mono_locks_acquire(&(domain)->assemblies_lock, DomainAssembliesLock) +#define mono_domain_assemblies_unlock(domain) mono_locks_release(&(domain)->assemblies_lock, DomainAssembliesLock) +#define mono_domain_jit_code_hash_lock(domain) mono_locks_acquire(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock) +#define mono_domain_jit_code_hash_unlock(domain) mono_locks_release(&(domain)->jit_code_hash_lock, DomainJitCodeHashLock) typedef MonoDomain* (*MonoLoadFunc) (const char *filename, const char *runtime_version); @@ -274,11 +335,11 @@ mono_jit_info_set_generic_sharing_context (MonoJitInfo *ji, MonoGenericSharingCo MonoJitInfo* mono_domain_lookup_shared_generic (MonoDomain *domain, MonoMethod *method) MONO_INTERNAL; -void -mono_domain_register_shared_generic (MonoDomain *domain, MonoMethod *method, MonoJitInfo *jit_info) MONO_INTERNAL; - char * -mono_make_shadow_copy (const char *filename); +mono_make_shadow_copy (const char *filename) MONO_INTERNAL; + +gboolean +mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name) MONO_INTERNAL; gpointer mono_domain_alloc (MonoDomain *domain, guint size) MONO_INTERNAL; @@ -286,6 +347,21 @@ mono_domain_alloc (MonoDomain *domain, guint size) MONO_INTERNAL; gpointer mono_domain_alloc0 (MonoDomain *domain, guint size) MONO_INTERNAL; +void* +mono_domain_code_reserve (MonoDomain *domain, int size) MONO_INTERNAL; + +void* +mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment) MONO_INTERNAL; + +void +mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize) MONO_INTERNAL; + +void +mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data) MONO_INTERNAL; + +void +mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception) MONO_INTERNAL; + /* * Installs a new function which is used to return a MonoJitInfo for a method inside * an AOT module. @@ -416,4 +492,10 @@ MonoAssembly* mono_assembly_load_full_nosearch (MonoAssemblyName *aname, MonoImageOpenStatus *status, gboolean refonly) MONO_INTERNAL; +void mono_set_private_bin_path_from_config (MonoDomain *domain) MONO_INTERNAL; + +int mono_framework_version (void) MONO_INTERNAL; + +void mono_reflection_cleanup_domain (MonoDomain *domain) MONO_INTERNAL; + #endif /* __MONO_METADATA_DOMAIN_INTERNALS_H__ */