X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fdomain-internals.h;h=02c3d5270359348fba84d00fbcbd87a12079e1d7;hb=08cbcd7f0261275fac6330235d9a04f285f9a759;hp=adae3121941233fc779d7bceff427da76476a3a9;hpb=98a5c5b5e2ab4da886b7ad24e104d8f148212b97;p=mono.git diff --git a/mono/metadata/domain-internals.h b/mono/metadata/domain-internals.h index adae3121941..02c3d527035 100644 --- a/mono/metadata/domain-internals.h +++ b/mono/metadata/domain-internals.h @@ -1,16 +1,19 @@ /* * Appdomain-related internal data structures and functions. + * Copyright 2012 Xamarin Inc (http://www.xamarin.com) */ #ifndef __MONO_METADATA_DOMAIN_INTERNALS_H__ #define __MONO_METADATA_DOMAIN_INTERNALS_H__ #include +#include #include #include -#include +#include #include #include #include +#include extern CRITICAL_SECTION mono_delegate_section; extern CRITICAL_SECTION mono_strtod_mutex; @@ -43,10 +46,11 @@ typedef struct { MonoBoolean disallow_code_downloads; MonoObject *activation_arguments; /* it is System.Object in 1.x, ActivationArguments in 2.0 */ MonoObject *domain_initializer; - MonoArray *domain_initializer_args; MonoObject *application_trust; /* it is System.Object in 1.x, ApplicationTrust in 2.0 */ + MonoArray *domain_initializer_args; MonoBoolean disallow_appbase_probe; MonoArray *configuration_bytes; + MonoArray *serialized_non_primitives; } MonoAppDomainSetup; typedef struct _MonoJitInfoTable MonoJitInfoTable; @@ -69,6 +73,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 { @@ -80,6 +86,7 @@ typedef struct { union { MonoClass *catch_class; gpointer filter; + gpointer handler_end; } data; } MonoJitExceptionInfo; @@ -91,15 +98,88 @@ typedef struct { int dummy; } MonoGenericSharingContext; +/* Simplified DWARF location list entry */ +typedef struct { + /* Whenever the value is in a register */ + gboolean is_reg; + /* + * If is_reg is TRUE, the register which contains the value. Otherwise + * the base register. + */ + int reg; + /* + * If is_reg is FALSE, the offset of the stack location relative to 'reg'. + * Otherwise, 0. + */ + int offset; + /* + * Offsets of the PC interval where the value is in this location. + */ + int from, to; +} MonoDwarfLocListEntry; + typedef struct { MonoGenericSharingContext *generic_sharing_context; + int nlocs; + MonoDwarfLocListEntry *locations; gint32 this_offset; guint8 this_reg; gboolean has_this:1; gboolean this_in_reg:1; } MonoGenericJitInfo; +/* +A try block hole is used to represent a non-contiguous part of +of a segment of native code protected by a given .try block. +Usually, a try block is defined as a contiguous segment of code. +But in some cases it's needed to have some parts of it to not be protected. +For example, given "try {} finally {}", the code in the .try block to call +the finally part looks like: + +try { + ... + call finally_block + adjust stack + jump outside try block + ... +} finally { + ... +} + +The instructions between the call and the jump should not be under the try block since they happen +after the finally block executes, which means if an async exceptions happens at that point we would +execute the finally clause twice. So, to avoid this, we introduce a hole in the try block to signal +that those instructions are not protected. +*/ +typedef struct +{ + guint32 offset; + guint16 clause; + guint16 length; +} MonoTryBlockHoleJitInfo; + +typedef struct +{ + guint16 num_holes; + MonoTryBlockHoleJitInfo holes [MONO_ZERO_LEN_ARRAY]; +} MonoTryBlockHoleTableJitInfo; + +typedef struct +{ + guint32 stack_size; +} MonoArchEHJitInfo; + +typedef struct { + gboolean cas_inited:1; + gboolean cas_class_assert:1; + gboolean cas_class_deny:1; + gboolean cas_class_permitonly:1; + gboolean cas_method_assert:1; + gboolean cas_method_deny:1; + gboolean cas_method_permitonly:1; +} MonoMethodCasInfo; + struct _MonoJitInfo { /* NOTE: These first two elements (method and next_jit_code_hash) must be in the same order and at the @@ -114,19 +194,26 @@ struct _MonoJitInfo { guint32 num_clauses:15; /* Whenever the code is domain neutral or 'shared' */ gboolean domain_neutral:1; - gboolean cas_inited:1; - gboolean cas_class_assert:1; - gboolean cas_class_deny:1; - gboolean cas_class_permitonly:1; - gboolean cas_method_assert:1; - gboolean cas_method_deny:1; - gboolean cas_method_permitonly:1; + gboolean has_cas_info:1; gboolean has_generic_jit_info:1; + gboolean has_try_block_holes:1; + gboolean has_arch_eh_info:1; gboolean from_aot:1; + gboolean from_llvm:1; + gboolean dbg_hidden_inited:1; + gboolean dbg_hidden:1; + + /* FIXME: Embed this after the structure later*/ + gpointer gc_info; /* Currently only used by SGen */ + MonoJitExceptionInfo clauses [MONO_ZERO_LEN_ARRAY]; /* There is an optional MonoGenericJitInfo after the clauses */ + /* There is an optional MonoTryBlockHoleTableJitInfo after MonoGenericJitInfo clauses*/ + /* There is an optional MonoArchEHJitInfo after MonoTryBlockHoleTableJitInfo */ }; +#define MONO_SIZEOF_JIT_INFO (offsetof (struct _MonoJitInfo, clauses)) + struct _MonoAppContext { MonoObject obj; gint32 domain_id; @@ -156,6 +243,13 @@ typedef struct _MonoThunkFreeList { typedef struct _MonoJitCodeHash MonoJitCodeHash; +typedef struct _MonoTlsDataRecord MonoTlsDataRecord; +struct _MonoTlsDataRecord { + MonoTlsDataRecord *next; + guint32 tls_offset; + guint32 size; +}; + struct _MonoDomain { /* * This lock must never be taken before the loader lock, @@ -178,6 +272,10 @@ struct _MonoDomain { MonoException *stack_overflow_ex; /* typeof (void) */ MonoObject *typeof_void; + /* Ephemeron Tombstone*/ + MonoObject *ephemeron_tombstone; + /* new MonoType [0] */ + MonoArray *empty_types; /* * The fields between FIRST_GC_TRACKED and LAST_GC_TRACKED are roots, but * not object references. @@ -203,7 +301,7 @@ struct _MonoDomain { GSList *domain_assemblies; MonoAssembly *entry_assembly; char *friendly_name; - GHashTable *class_vtable_hash; + GPtrArray *class_vtable_array; /* maps remote class key -> MonoRemoteClass */ GHashTable *proxy_vtable_hash; /* Protected by 'jit_code_hash_lock' */ @@ -222,11 +320,20 @@ struct _MonoDomain { MonoMethod *private_invoke_method; /* Used to store offsets of thread and context static fields */ GHashTable *special_static_fields; + MonoTlsDataRecord *tlsrec_list; /* * This must be a GHashTable, since these objects can't be finalized * if the hashtable contains a GC visible reference to them. */ GHashTable *finalizable_objects_hash; + + /* These two are boehm only */ + /* 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; + + /* Protects the three hashes above */ CRITICAL_SECTION finalizable_objects_hash_lock; /* Used when accessing 'domain_assemblies' */ CRITICAL_SECTION assemblies_lock; @@ -236,11 +343,13 @@ struct _MonoDomain { GHashTable *generic_virtual_cases; MonoThunkFreeList **thunk_free_lists; + GHashTable *generic_virtual_thunks; + /* Information maintained by the JIT engine */ gpointer runtime_info; /*thread pool jobs, used to coordinate shutdown.*/ - int threadpool_jobs; + volatile int threadpool_jobs; HANDLE cleanup_semaphore; /* Contains the compiled runtime invoke wrapper used by finalizers */ @@ -251,6 +360,29 @@ struct _MonoDomain { /* Contains the compiled method used by async resylt creation to capture thread context*/ gpointer capture_context_method; + + /* Assembly bindings, the per-domain part */ + GSList *assembly_bindings; + gboolean assembly_bindings_parsed; + + /* Used by socket-io.c */ + /* These are domain specific, since the assembly can be unloaded */ + MonoImage *socket_assembly; + MonoClass *sockaddr_class; + MonoClassField *sockaddr_data_field; + + /* Used by threadpool.c */ + MonoImage *system_image; + MonoClass *corlib_asyncresult_class; + MonoClass *socket_class; + MonoClass *ad_unloaded_ex_class; + MonoClass *process_class; + + /* Cache function pointers for architectures */ + /* that require wrappers */ + GHashTable *ftnptrs_hash; + + guint32 execution_context_field_offset; }; typedef struct { @@ -261,7 +393,7 @@ typedef struct { typedef struct { const char runtime_version [12]; const char framework_version [4]; - const AssemblyVersionSet version_sets [2]; + const AssemblyVersionSet version_sets [4]; } MonoRuntimeInfo; #define mono_domain_lock(domain) mono_locks_acquire(&(domain)->lock, DomainLock) @@ -332,7 +464,7 @@ gpointer mono_domain_alloc0 (MonoDomain *domain, guint size) MONO_INTERNAL; void* -mono_domain_code_reserve (MonoDomain *domain, int size) MONO_INTERNAL; +mono_domain_code_reserve (MonoDomain *domain, int size) MONO_LLVM_INTERNAL; void* mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment) MONO_INTERNAL; @@ -340,9 +472,30 @@ mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment) MON void mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize) MONO_INTERNAL; +void * +nacl_domain_get_code_dest (MonoDomain *domain, void *data) MONO_INTERNAL; + +void +nacl_domain_code_validate (MonoDomain *domain, guint8 **buf_base, int buf_size, guint8 **code_end) MONO_INTERNAL; + void mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data) MONO_INTERNAL; +void +mono_domain_unset (void) MONO_INTERNAL; + +void +mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exception) MONO_INTERNAL; + +MonoTryBlockHoleTableJitInfo* +mono_jit_info_get_try_block_hole_table_info (MonoJitInfo *ji) MONO_INTERNAL; + +MonoArchEHJitInfo* +mono_jit_info_get_arch_eh_info (MonoJitInfo *ji) MONO_INTERNAL; + +MonoMethodCasInfo* +mono_jit_info_get_cas_info (MonoJitInfo *ji) MONO_INTERNAL; + /* * Installs a new function which is used to return a MonoJitInfo for a method inside * an AOT module. @@ -455,9 +608,6 @@ mono_runtime_get_no_exec (void) MONO_INTERNAL; gboolean mono_assembly_name_parse (const char *name, MonoAssemblyName *aname) MONO_INTERNAL; -void -mono_assembly_name_free (MonoAssemblyName *aname) MONO_INTERNAL; - MonoImage *mono_assembly_open_from_bundle (const char *filename, MonoImageOpenStatus *status, gboolean refonly) MONO_INTERNAL; @@ -477,4 +627,8 @@ 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; + +void mono_assembly_cleanup_domain_bindings (guint32 domain_id) MONO_INTERNAL;; + #endif /* __MONO_METADATA_DOMAIN_INTERNALS_H__ */