* [jit] Add a MonoJitMemoryManager structure, which is the same as the MonoJitDomainInfo structure, but owned by a MonoMemoryManager instead of a domain.
* Move static_rgctx_trampoline_hash to MonoJitMemoryManager.
* Move jump_target_hash to MonoJitMemoryManager.
* Move jump_trampoline_hash to MonoJitMemoryManager.
* Move jit_trampoline_hash to MonoJitMemoryManager.
* Move delegate_trampoline_hash to MonoJitMemoryManager.
* Move method_code_hash to MonoJitMemoryManager.
* Move more fields to MonoJitMemoryManager.
* Move llvm data to MonoJitMemoryManager.
* Move arch_seq_points field to MonoJitMemoryManager.
* Remove unused fields from MonoJitDomainInfo.
* Use the default alc memory manager only for now.
* Remove MonoJitDomainInfo which is now unused.
GHashTable *generic_virtual_cases;
- /* Information maintained by the JIT engine */
- gpointer runtime_info;
-
/* Contains the compiled runtime invoke wrapper used by finalizers */
gpointer finalize_runtime_invoke;
MonoDomain*
mono_runtime_load (const char *filename, const char *runtime_version);
-typedef void (*MonoCreateDomainFunc) (MonoDomain *domain);
-
-void
-mono_install_create_domain_hook (MonoCreateDomainFunc func);
-
-typedef void (*MonoFreeDomainFunc) (MonoDomain *domain);
-
-void
-mono_install_free_domain_hook (MonoFreeDomainFunc func);
-
void
mono_runtime_quit_internal (void);
/* The stable runtime version */
#define DEFAULT_RUNTIME_VERSION "v4.0.30319"
-/* Callbacks installed by the JIT */
-static MonoCreateDomainFunc create_domain_hook;
-static MonoFreeDomainFunc free_domain_hook;
-
static GSList*
get_runtimes_from_exe (const char *exe_file, MonoImage **exe_image);
return res;
}
-void
-mono_install_create_domain_hook (MonoCreateDomainFunc func)
-{
- create_domain_hook = func;
-}
-
-void
-mono_install_free_domain_hook (MonoFreeDomainFunc func)
-{
- free_domain_hook = func;
-}
-
gboolean
mono_string_equal_internal (MonoString *s1, MonoString *s2)
{
mono_alc_create_default (domain);
- if (create_domain_hook)
- create_domain_hook (domain);
-
MONO_PROFILER_RAISE (domain_loaded, (domain));
return domain;
/* Information maintained by mono-debug.c */
gpointer debug_info;
+ /* Information maintained by the execution engine */
+ gpointer runtime_info;
+
// !!! REGISTERED AS GC ROOTS !!!
// Hashtables for Reflection handles
MonoGHashTable *type_hash;
memory_manager->type_hash = mono_g_hash_table_new_type_internal ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Reflection Type Table");
memory_manager->refobject_hash = mono_conc_g_hash_table_new_type (mono_reflected_hash, mono_reflected_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Reflection Object Table");
memory_manager->type_init_exception_hash = mono_g_hash_table_new_type_internal (mono_aligned_addr_hash, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Type Initialization Exception Table");
+
+ if (mono_get_runtime_callbacks ()->init_mem_manager)
+ mono_get_runtime_callbacks ()->init_mem_manager (memory_manager);
}
MonoSingletonMemoryManager *
{
// Scan here to assert no lingering references in vtables?
+ if (mono_get_runtime_callbacks ()->free_mem_manager)
+ mono_get_runtime_callbacks ()->free_mem_manager (memory_manager);
+
if (memory_manager->debug_info) {
mono_mem_manager_free_debug_info (memory_manager);
memory_manager->debug_info = NULL;
GHashTable *(*get_weak_field_indexes) (MonoImage *image);
void (*install_state_summarizer) (void);
gboolean (*is_interpreter_enabled) (void);
+ void (*init_mem_manager)(MonoMemoryManager*);
+ void (*free_mem_manager)(MonoMemoryManager*);
#ifdef ENABLE_METADATA_UPDATE
void (*metadata_update_init) (MonoError *error);
void (*metadata_update_published) (MonoDomain *domain, MonoAssemblyLoadContext *alc, uint32_t generation);
p += mono_seq_point_info_read (&seq_points, p, FALSE);
- mono_domain_lock (domain);
+ // FIXME: Call a function in seq-points.c
+ // FIXME:
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+ jit_mm_lock (jit_mm);
/* This could be set already since this function can be called more than once for the same method */
- if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, method))
- g_hash_table_insert (domain_jit_info (domain)->seq_points, method, seq_points);
+ if (!g_hash_table_lookup (jit_mm->seq_points, method))
+ g_hash_table_insert (jit_mm->seq_points, method, seq_points);
else
mono_seq_point_info_free (seq_points);
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
jinfo->seq_points = seq_points;
}
* the addresses of the GOT slots pointing to a method, and patch
* them after the method has been compiled.
*/
- MonoJitDomainInfo *info = domain_jit_info (domain);
GSList *list;
+ MonoJitMemoryManager *jit_mm;
MonoMethod *shared_method = mini_method_to_shared (method);
method = shared_method ? shared_method : method;
-
- mono_domain_lock (domain);
- if (!info->jump_target_got_slot_hash)
- info->jump_target_got_slot_hash = g_hash_table_new (NULL, NULL);
- list = (GSList *)g_hash_table_lookup (info->jump_target_got_slot_hash, method);
+
+ jit_mm = jit_mm_for_method (method);
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->jump_target_got_slot_hash)
+ jit_mm->jump_target_got_slot_hash = g_hash_table_new (NULL, NULL);
+ list = (GSList *)g_hash_table_lookup (jit_mm->jump_target_got_slot_hash, method);
list = g_slist_prepend (list, got_slot);
- g_hash_table_insert (info->jump_target_got_slot_hash, method, list);
- mono_domain_unlock (domain);
+ g_hash_table_insert (jit_mm->jump_target_got_slot_hash, method, list);
+ jit_mm_unlock (jit_mm);
}
/*
}
static void
-stub_debugger_agent_free_domain_info (MonoDomain *domain)
+stub_debugger_agent_free_mem_manager (gpointer mem_manager)
{
}
cbs.single_step_event = stub_debugger_agent_single_step_event;
cbs.single_step_from_context = stub_debugger_agent_single_step_from_context;
cbs.breakpoint_from_context = stub_debugger_agent_breakpoint_from_context;
- cbs.free_domain_info = stub_debugger_agent_free_domain_info;
cbs.unhandled_exception = stub_debugger_agent_unhandled_exception;
cbs.handle_exception = stub_debugger_agent_handle_exception;
cbs.begin_exception_filter = stub_debugger_agent_begin_exception_filter;
}
static void
-debugger_agent_free_domain_info (MonoDomain *domain)
+debugger_agent_free_mem_manager (gpointer mem_manager)
{
- AgentDomainInfo *info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info;
- int i, j;
+ MonoJitMemoryManager *jit_mm = (MonoJitMemoryManager*)mem_manager;
+ AgentDomainInfo *info = (AgentDomainInfo *)jit_mm->agent_info;
+ int i;
GHashTableIter iter;
GPtrArray *file_names;
char *basename;
GSList *l;
+ // FIXME:
+ if (mem_manager != get_default_jit_mm ())
+ return;
+
if (info) {
for (i = 0; i < ID_NUM; ++i)
g_hash_table_destroy (info->val_to_id [i]);
g_free (info);
}
- domain_jit_info (domain)->agent_info = NULL;
+ jit_mm->agent_info = NULL;
+#if 0
/* Clear ids referencing structures in the domain */
dbg_lock ();
for (i = 0; i < ID_NUM; ++i) {
}
}
dbg_unlock ();
-
- mono_de_domain_remove (domain);
+#endif
}
static AgentDomainInfo*
-get_agent_domain_info (MonoDomain *domain)
+get_agent_info (void)
{
AgentDomainInfo *info = NULL;
- MonoJitDomainInfo *jit_info = domain_jit_info (domain);
-
- info = (AgentDomainInfo *)jit_info->agent_info;
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+ info = (AgentDomainInfo *)jit_mm->agent_info;
if (info) {
mono_memory_read_barrier ();
mono_memory_write_barrier ();
- gpointer other_info = mono_atomic_cas_ptr (&jit_info->agent_info, info, NULL);
+ gpointer other_info = mono_atomic_cas_ptr (&jit_mm->agent_info, info, NULL);
if (other_info != NULL) {
g_hash_table_destroy (info->loaded_classes);
g_free (info);
}
- return (AgentDomainInfo *)jit_info->agent_info;
+ return (AgentDomainInfo *)jit_mm->agent_info;
}
static int
if (val == NULL)
return 0;
- info = get_agent_domain_info (domain);
+ info = get_agent_info ();
dbg_lock ();
emit_appdomain_load (gpointer key, gpointer value, gpointer user_data)
{
process_profiler_event (EVENT_KIND_APPDOMAIN_CREATE, value);
- g_hash_table_foreach (get_agent_domain_info ((MonoDomain *)value)->loaded_classes, emit_type_load, NULL);
+ g_hash_table_foreach (get_agent_info ()->loaded_classes, emit_type_load, NULL);
}
/*
send_type_load (MonoClass *klass)
{
gboolean type_load = FALSE;
- MonoDomain *domain = mono_domain_get ();
AgentDomainInfo *info = NULL;
- info = get_agent_domain_info (domain);
+ info = get_agent_info ();
mono_loader_lock ();
MonoDomain* old_domain;
AgentDomainInfo *info = NULL;
- info = get_agent_domain_info (domain);
+ info = get_agent_info ();
g_assert (info);
old_domain = mono_domain_get ();
static void
clear_types_for_assembly (MonoAssembly *assembly)
{
- MonoDomain *domain = mono_domain_get ();
AgentDomainInfo *info = NULL;
- if (!domain || !domain_jit_info (domain))
- /* Can happen during shutdown */
- return;
-
- info = get_agent_domain_info (domain);
+ info = get_agent_info ();
mono_loader_lock ();
g_hash_table_foreach_remove (info->loaded_classes, type_comes_from_assembly, assembly);
GetTypesForSourceFileArgs *ud = (GetTypesForSourceFileArgs*)user_data;
MonoDomain *domain = (MonoDomain*)key;
- AgentDomainInfo *info = (AgentDomainInfo *)domain_jit_info (domain)->agent_info;
+ AgentDomainInfo *info = get_agent_info ();
/* Update 'source_file_to_class' cache */
g_hash_table_iter_init (&iter, info->loaded_classes);
cbs.single_step_event = debugger_agent_single_step_event;
cbs.single_step_from_context = debugger_agent_single_step_from_context;
cbs.breakpoint_from_context = debugger_agent_breakpoint_from_context;
- cbs.free_domain_info = debugger_agent_free_domain_info;
+ cbs.free_mem_manager = debugger_agent_free_mem_manager;
cbs.unhandled_exception = debugger_agent_unhandled_exception;
cbs.handle_exception = debugger_agent_handle_exception;
cbs.begin_exception_filter = debugger_agent_begin_exception_filter;
#include "mini.h"
#include <mono/utils/mono-stack-unwinding.h>
-#define MONO_DBG_CALLBACKS_VERSION (3)
+#define MONO_DBG_CALLBACKS_VERSION (4)
// 2. debug_log parameters changed from MonoString* to MonoStringHandle
// 3. debug_log parameters changed from MonoStringHandle back to MonoString*
void (*single_step_event) (void *sigctx);
void (*single_step_from_context) (MonoContext *ctx);
void (*breakpoint_from_context) (MonoContext *ctx);
- void (*free_domain_info) (MonoDomain *domain);
+ void (*free_mem_manager) (gpointer mem_manager);
void (*unhandled_exception) (MonoException *exc);
void (*handle_exception) (MonoException *exc, MonoContext *throw_ctx,
MonoContext *catch_ctx, StackFrameInfo *catch_frame);
CollectDomainData *ud = (CollectDomainData*)user_data;
MonoMethod *m;
- mono_domain_lock (domain);
- g_hash_table_iter_init (&iter, domain_jit_info (domain)->seq_points);
+ // FIXME:
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+ jit_mm_lock (jit_mm);
+ g_hash_table_iter_init (&iter, jit_mm->seq_points);
while (g_hash_table_iter_next (&iter, (void**)&m, (void**)&seq_points)) {
if (bp_matches_method (ud->bp, m)) {
/* Save the info locally to simplify the code inside the domain lock */
g_ptr_array_add (ud->method_seq_points, seq_points);
}
}
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
}
void
comp_time = elapsed = 0.0;
int local_skip_index = 0;
- /* fixme: ugly hack - delete all previously compiled methods */
- if (domain_jit_info (domain)) {
- g_hash_table_destroy (domain_jit_info (domain)->jit_trampoline_hash);
- domain_jit_info (domain)->jit_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
- mono_internal_hash_table_destroy (&(domain->jit_code_hash));
- mono_jit_code_hash_init (&(domain->jit_code_hash));
- }
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+ g_hash_table_destroy (jit_mm->jit_trampoline_hash);
+ jit_mm->jit_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
+ mono_internal_hash_table_destroy (&(domain->jit_code_hash));
+ mono_jit_code_hash_init (&(domain->jit_code_hash));
g_timer_start (timer);
if (mini_stats_fd)
lookup_imethod (MonoDomain *domain, MonoMethod *method)
{
InterpMethod *imethod;
- MonoJitDomainInfo *info;
+ MonoJitMemoryManager *jit_mm = jit_mm_for_method (method);
+
+ jit_mm_lock (jit_mm);
+ imethod = (InterpMethod*)mono_internal_hash_table_lookup (&jit_mm->interp_code_hash, method);
+ jit_mm_unlock (jit_mm);
- info = domain_jit_info (domain);
- mono_domain_jit_code_hash_lock (domain);
- imethod = (InterpMethod*)mono_internal_hash_table_lookup (&info->interp_code_hash, method);
- mono_domain_jit_code_hash_unlock (domain);
return imethod;
}
mono_interp_get_imethod (MonoDomain *domain, MonoMethod *method, MonoError *error)
{
InterpMethod *imethod;
- MonoJitDomainInfo *info;
MonoMethodSignature *sig;
+ MonoJitMemoryManager *jit_mm = jit_mm_for_method (method);
int i;
error_init (error);
- info = domain_jit_info (domain);
- mono_domain_jit_code_hash_lock (domain);
- imethod = (InterpMethod*)mono_internal_hash_table_lookup (&info->interp_code_hash, method);
- mono_domain_jit_code_hash_unlock (domain);
+ jit_mm_lock (jit_mm);
+ imethod = (InterpMethod*)mono_internal_hash_table_lookup (&jit_mm->interp_code_hash, method);
+ jit_mm_unlock (jit_mm);
if (imethod)
return imethod;
for (i = 0; i < sig->param_count; ++i)
imethod->param_types [i] = mini_get_underlying_type (sig->params [i]);
- mono_domain_jit_code_hash_lock (domain);
- if (!mono_internal_hash_table_lookup (&info->interp_code_hash, method))
- mono_internal_hash_table_insert (&info->interp_code_hash, method, imethod);
- mono_domain_jit_code_hash_unlock (domain);
+ jit_mm_lock (jit_mm);
+ if (!mono_internal_hash_table_lookup (&jit_mm->interp_code_hash, method))
+ mono_internal_hash_table_insert (&jit_mm->interp_code_hash, method, imethod);
+ jit_mm_unlock (jit_mm);
imethod->prof_flags = mono_profiler_get_call_instrumentation_flags (imethod->method);
static InterpMethod*
lookup_method_pointer (gpointer addr)
{
- MonoDomain *domain = mono_domain_get ();
- MonoJitDomainInfo *info = domain_jit_info (domain);
InterpMethod *res = NULL;
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
- mono_domain_lock (domain);
- if (info->interp_method_pointer_hash)
- res = (InterpMethod*)g_hash_table_lookup (info->interp_method_pointer_hash, addr);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ if (jit_mm->interp_method_pointer_hash)
+ res = (InterpMethod*)g_hash_table_lookup (jit_mm->interp_method_pointer_hash, addr);
+ jit_mm_unlock (jit_mm);
return res;
}
gpointer addr, entry_func, entry_wrapper;
MonoMethodSignature *sig;
MonoMethod *wrapper;
- MonoJitDomainInfo *info;
InterpMethod *imethod;
imethod = mono_interp_get_imethod (domain, method, error);
addr = mini_llvmonly_create_ftndesc (mono_domain_get (), entry_wrapper, entry_ftndesc);
- info = domain_jit_info (domain);
- mono_domain_lock (domain);
- if (!info->interp_method_pointer_hash)
- info->interp_method_pointer_hash = g_hash_table_new (NULL, NULL);
- g_hash_table_insert (info->interp_method_pointer_hash, addr, imethod);
- mono_domain_unlock (domain);
+ // FIXME:
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->interp_method_pointer_hash)
+ jit_mm->interp_method_pointer_hash = g_hash_table_new (NULL, NULL);
+ g_hash_table_insert (jit_mm->interp_method_pointer_hash, addr, imethod);
+ jit_mm_unlock (jit_mm);
mono_memory_barrier ();
if (unbox)
{
gpointer addr, entry_func, entry_wrapper = NULL;
MonoDomain *domain = mono_domain_get ();
- MonoJitDomainInfo *info;
InterpMethod *imethod = mono_interp_get_imethod (domain, method, error);
if (imethod->jit_entry)
addr = mono_create_ftnptr_arg_trampoline (ftndesc, entry_wrapper);
- info = domain_jit_info (domain);
- mono_domain_lock (domain);
- if (!info->interp_method_pointer_hash)
- info->interp_method_pointer_hash = g_hash_table_new (NULL, NULL);
- g_hash_table_insert (info->interp_method_pointer_hash, addr, imethod);
- mono_domain_unlock (domain);
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->interp_method_pointer_hash)
+ jit_mm->interp_method_pointer_hash = g_hash_table_new (NULL, NULL);
+ g_hash_table_insert (jit_mm->interp_method_pointer_hash, addr, imethod);
+ jit_mm_unlock (jit_mm);
mono_memory_barrier ();
imethod->jit_entry = addr;
static void
interp_free_method (MonoDomain *domain, MonoMethod *method)
{
- MonoJitDomainInfo *info = domain_jit_info (domain);
+ MonoJitMemoryManager *jit_mm = jit_mm_for_method (method);
- mono_domain_jit_code_hash_lock (domain);
+ jit_mm_lock (jit_mm);
/* InterpMethod is allocated in the domain mempool. We might haven't
* allocated an InterpMethod for this instance yet */
- mono_internal_hash_table_remove (&info->interp_code_hash, method);
- mono_domain_jit_code_hash_unlock (domain);
+ mono_internal_hash_table_remove (&jit_mm->interp_code_hash, method);
+ jit_mm_unlock (jit_mm);
}
#if COUNT_OPS
interp_print_method_counts (void)
{
MonoDomain *domain = mono_get_root_domain ();
- MonoJitDomainInfo *info = domain_jit_info (domain);
+ MonoJitMemoryManager *jit_mm = jit_mm_for_method (method);
- mono_domain_jit_code_hash_lock (domain);
- imethods = (InterpMethod**) malloc (info->interp_code_hash.num_entries * sizeof (InterpMethod*));
- mono_internal_hash_table_apply (&info->interp_code_hash, interp_add_imethod);
- mono_domain_jit_code_hash_unlock (domain);
+ jit_mm_lock (jit_mm);
+ imethods = (InterpMethod**) malloc (jit_mm->interp_code_hash.num_entries * sizeof (InterpMethod*));
+ mono_internal_hash_table_apply (&jit_mm->interp_code_hash, interp_add_imethod);
+ jit_mm_unlock (jit_mm);
qsort (imethods, num_methods, sizeof (InterpMethod*), imethod_opcount_comparer);
mono_stop_world (MONO_THREAD_INFO_FLAGS_NO_GC);
metadata_update_prepare_to_invalidate (domain);
#endif
- MonoJitDomainInfo *info = domain_jit_info (domain);
- mono_domain_jit_code_hash_lock (domain);
- mono_internal_hash_table_apply (&info->interp_code_hash, invalidate_transform);
- mono_domain_jit_code_hash_unlock (domain);
+
+ // FIXME: Enumerate all memory managers
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+
+ jit_mm_lock (jit_mm);
+ mono_internal_hash_table_apply (&jit_mm->interp_code_hash, invalidate_transform);
+ jit_mm_unlock (jit_mm);
if (need_stw_restart)
mono_restart_world (MONO_THREAD_INFO_FLAGS_NO_GC);
g_printf ("Printing runtime stats at method: %s\n", mono_method_get_full_name (imethod->method));
mono_runtime_print_stats ();
}
- if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, imethod->method))
- g_hash_table_insert (domain_jit_info (domain)->seq_points, imethod->method, imethod->jinfo->seq_points);
mono_domain_unlock (domain);
+ MonoJitMemoryManager *jit_mm = jit_mm_for_method (imethod->method);
+ jit_mm_lock (jit_mm);
+ if (!g_hash_table_lookup (jit_mm->seq_points, imethod->method))
+ g_hash_table_insert (jit_mm->seq_points, imethod->method, imethod->jinfo->seq_points);
+ jit_mm_unlock (jit_mm);
+
// FIXME: Add a different callback ?
MONO_PROFILER_RAISE (jit_done, (method, imethod->jinfo));
}
return (unsigned char *)mono_mem_manager_code_reserve (cfg->mem_manager, size);
}
-class MonoJitMemoryManager : public RTDyldMemoryManager
+class MonoLLVMMemoryManager : public RTDyldMemoryManager
{
public:
- ~MonoJitMemoryManager() override;
+ ~MonoLLVMMemoryManager() override;
uint8_t *allocateDataSection(uintptr_t Size,
unsigned Alignment,
SmallVector<sys::MemoryBlock, 16> PendingCodeMem;
};
-MonoJitMemoryManager::~MonoJitMemoryManager()
+MonoLLVMMemoryManager::~MonoLLVMMemoryManager()
{
}
uint8_t *
-MonoJitMemoryManager::allocateDataSection(uintptr_t Size,
+MonoLLVMMemoryManager::allocateDataSection(uintptr_t Size,
unsigned Alignment,
unsigned SectionID,
StringRef SectionName,
}
uint8_t *
-MonoJitMemoryManager::allocateCodeSection(uintptr_t Size,
+MonoLLVMMemoryManager::allocateCodeSection(uintptr_t Size,
unsigned Alignment,
unsigned SectionID,
StringRef SectionName)
}
bool
-MonoJitMemoryManager::finalizeMemory(std::string *ErrMsg)
+MonoLLVMMemoryManager::finalizeMemory(std::string *ErrMsg)
{
for (sys::MemoryBlock &Block : PendingCodeMem) {
#if LLVM_API_VERSION >= 900
#if LLVM_API_VERSION >= 900
struct MonoLLVMJIT {
- std::shared_ptr<MonoJitMemoryManager> mmgr;
+ std::shared_ptr<MonoLLVMMemoryManager> mmgr;
ExecutionSession execution_session;
std::map<VModuleKey, std::shared_ptr<SymbolResolver>> resolvers;
TargetMachine *target_machine;
legacy::FunctionPassManager fpm;
MonoLLVMJIT (TargetMachine *tm, Module *pgo_module)
- : mmgr (std::make_shared<MonoJitMemoryManager>())
+ : mmgr (std::make_shared<MonoLLVMMemoryManager>())
, target_machine (tm)
, object_layer (
AcknowledgeORCv1Deprecation, execution_session,
typedef IRCompileLayer<ObjLayerT, SimpleCompiler> CompileLayerT;
typedef CompileLayerT::ModuleHandleT ModuleHandleT;
- MonoLLVMJIT (TargetMachine *TM, MonoJitMemoryManager *mm)
+ MonoLLVMJIT (TargetMachine *TM, MonoLLVMMemoryManager *mm)
: TM(TM), ObjectLayer([=] { return std::shared_ptr<RuntimeDyld::MemoryManager> (mm); }),
CompileLayer (ObjectLayer, SimpleCompiler (*TM)),
modules(),
legacy::FunctionPassManager fpm;
};
-static MonoJitMemoryManager *mono_mm;
+static MonoLLVMMemoryManager *mono_mm;
static MonoLLVMJIT *
make_mono_llvm_jit (TargetMachine *target_machine, llvm::Module *)
{
- mono_mm = new MonoJitMemoryManager ();
+ mono_mm = new MonoLLVMMemoryManager ();
return new MonoLLVMJIT(target_machine, mono_mm);
}
int dreg;
gpointer trampoline;
MonoInst *obj, *tramp_ins;
- MonoDomain *domain;
guint8 **code_slot;
if (virtual_ && !cfg->llvm_only) {
if (target_method_context_used) {
code_slot_ins = emit_get_rgctx_method (cfg, target_method_context_used, method, MONO_RGCTX_INFO_METHOD_DELEGATE_CODE);
} else {
- domain = mono_domain_get ();
- mono_domain_lock (domain);
- if (!domain_jit_info (domain)->method_code_hash)
- domain_jit_info (domain)->method_code_hash = g_hash_table_new (NULL, NULL);
- code_slot = (guint8 **)g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, method);
+ MonoJitMemoryManager *jit_mm = (MonoJitMemoryManager*)cfg->jit_mm;
+
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->method_code_hash)
+ jit_mm->method_code_hash = g_hash_table_new (NULL, NULL);
+ code_slot = (guint8 **)g_hash_table_lookup (jit_mm->method_code_hash, method);
if (!code_slot) {
code_slot = (guint8 **)m_method_alloc0 (method, sizeof (gpointer));
- g_hash_table_insert (domain_jit_info (domain)->method_code_hash, method, code_slot);
+ g_hash_table_insert (jit_mm->method_code_hash, method, code_slot);
}
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
code_slot_ins = mini_emit_runtime_constant (cfg, MONO_PATCH_INFO_METHOD_CODE_SLOT, method);
}
{
SeqPointInfo *info;
MonoJitInfo *ji;
+ MonoJitMemoryManager *jit_mm;
+
+ /*
+ * We don't have access to the method etc. so use the global
+ * memory manager for now.
+ */
+ jit_mm = get_default_jit_mm ();
// FIXME: Add a free function
- mono_domain_lock (domain);
- info = (SeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points,
- code);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ info = (SeqPointInfo *)g_hash_table_lookup (jit_mm->arch_seq_points, code);
+ jit_mm_unlock (jit_mm);
if (!info) {
- ji = mono_jit_info_table_find (domain, code);
+ ji = mini_jit_info_table_find (code);
g_assert (ji);
// FIXME: Optimize the size
info->ss_tramp_addr = &ss_trampoline;
- mono_domain_lock (domain);
- g_hash_table_insert (domain_jit_info (domain)->arch_seq_points,
- code, info);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ g_hash_table_insert (jit_mm->arch_seq_points, code, info);
+ jit_mm_unlock (jit_mm);
}
return info;
{
SeqPointInfo *info;
MonoJitInfo *ji;
+ MonoJitMemoryManager *jit_mm;
+
+ jit_mm = get_default_jit_mm ();
// FIXME: Add a free function
- mono_domain_lock (domain);
- info = (SeqPointInfo*)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points,
- code);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ info = (SeqPointInfo *)g_hash_table_lookup (jit_mm->arch_seq_points, code);
+ jit_mm_unlock (jit_mm);
if (!info) {
- ji = mono_jit_info_table_find (domain, code);
+ ji = mini_jit_info_table_find (code);
g_assert (ji);
info = g_malloc0 (sizeof (SeqPointInfo) + ji->code_size);
info->bp_trigger_page = bp_trigger_page;
info->ss_tramp_addr = &single_step_tramp;
- mono_domain_lock (domain);
- g_hash_table_insert (domain_jit_info (domain)->arch_seq_points,
- code, info);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ g_hash_table_insert (jit_mm->arch_seq_points, code, info);
+ jit_mm_unlock (jit_mm);
}
return info;
{
SeqPointInfo *info;
MonoJitInfo *ji;
+ MonoJitMemoryManager *jit_mm;
+
+ jit_mm = get_default_jit_mm ();
// FIXME: Add a free function
- mono_domain_lock (domain);
- info = (SeqPointInfo*)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points,
- code);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ info = (SeqPointInfo *)g_hash_table_lookup (jit_mm->arch_seq_points, code);
+ jit_mm_unlock (jit_mm);
if (!info) {
- ji = mono_jit_info_table_find (domain, code);
+ ji = mini_jit_info_table_find (code);
g_assert (ji);
info = g_malloc0 (sizeof (SeqPointInfo) + (ji->code_size / 4) * sizeof(guint8*));
info->ss_tramp_addr = &ss_trampoline;
- mono_domain_lock (domain);
- g_hash_table_insert (domain_jit_info (domain)->arch_seq_points,
- code, info);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ g_hash_table_insert (jit_mm->arch_seq_points, code, info);
+ jit_mm_unlock (jit_mm);
}
return info;
case MONO_RGCTX_INFO_BZERO: {
static MonoMethod *memcpy_method [17];
static MonoMethod *bzero_method [17];
- MonoJitDomainInfo *domain_info;
+ MonoJitMemoryManager *jit_mm;
int size;
guint32 align;
- domain_info = domain_jit_info (domain);
+ /* The memcpy methods are in the default memory alc */
+ jit_mm = get_default_jit_mm ();
if (MONO_TYPE_IS_REFERENCE (m_class_get_byval_arg (klass))) {
size = sizeof (gpointer);
mono_memory_barrier ();
memcpy_method [size] = m;
}
- if (!domain_info->memcpy_addr [size]) {
+ if (!jit_mm->memcpy_addr [size]) {
gpointer addr = mono_compile_method_checked (memcpy_method [size], error);
mono_memory_barrier ();
- domain_info->memcpy_addr [size] = (gpointer *)addr;
+ jit_mm->memcpy_addr [size] = (gpointer *)addr;
mono_error_assert_ok (error);
}
- return domain_info->memcpy_addr [size];
+ return jit_mm->memcpy_addr [size];
} else {
if (!bzero_method [size]) {
MonoMethod *m;
mono_memory_barrier ();
bzero_method [size] = m;
}
- if (!domain_info->bzero_addr [size]) {
+ if (!jit_mm->bzero_addr [size]) {
gpointer addr = mono_compile_method_checked (bzero_method [size], error);
mono_memory_barrier ();
- domain_info->bzero_addr [size] = (gpointer *)addr;
+ jit_mm->bzero_addr [size] = (gpointer *)addr;
mono_error_assert_ok (error);
}
- return domain_info->bzero_addr [size];
+ return jit_mm->bzero_addr [size];
}
}
case MONO_RGCTX_INFO_NULLABLE_CLASS_BOX:
ERROR_DECL (error);
gpointer res, info;
MonoDomain *domain = mono_domain_get ();
- MonoJitDomainInfo *domain_info;
GSharedVtTrampInfo *tramp_info;
GSharedVtTrampInfo tinfo;
+ MonoJitMemoryManager *jit_mm;
if (mono_llvm_only) {
MonoMethod *wrapper;
tinfo.sig = normal_sig;
tinfo.gsig = gsharedvt_sig;
- domain_info = domain_jit_info (domain);
+ // FIXME:
+ jit_mm = get_default_jit_mm ();
/*
* The arg trampolines might only have a finite number in full-aot, so use a cache.
*/
- mono_domain_lock (domain);
- if (!domain_info->gsharedvt_arg_tramp_hash)
- domain_info->gsharedvt_arg_tramp_hash = g_hash_table_new (tramp_info_hash, tramp_info_equal);
- res = g_hash_table_lookup (domain_info->gsharedvt_arg_tramp_hash, &tinfo);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->gsharedvt_arg_tramp_hash)
+ jit_mm->gsharedvt_arg_tramp_hash = g_hash_table_new (tramp_info_hash, tramp_info_equal);
+ res = g_hash_table_lookup (jit_mm->gsharedvt_arg_tramp_hash, &tinfo);
+ jit_mm_unlock (jit_mm);
if (res)
return res;
tramp_info = (GSharedVtTrampInfo *)mono_domain_alloc0 (domain, sizeof (GSharedVtTrampInfo));
*tramp_info = tinfo;
- mono_domain_lock (domain);
+ jit_mm_lock (jit_mm);
/* Duplicates are not a problem */
- g_hash_table_insert (domain_info->gsharedvt_arg_tramp_hash, tramp_info, addr);
- mono_domain_unlock (domain);
+ g_hash_table_insert (jit_mm->gsharedvt_arg_tramp_hash, tramp_info, addr);
+ jit_mm_unlock (jit_mm);
return addr;
}
MonoMethodRuntimeGenericContext *mrgctx;
MonoMethodRuntimeGenericContext key;
MonoGenericInst *method_inst = mini_method_get_context (method)->method_inst;
- MonoJitDomainInfo *domain_info = domain_jit_info (domain);
+ MonoJitMemoryManager *jit_mm;
g_assert (!mono_class_is_gtd (class_vtable->klass));
+ jit_mm = jit_mm_for_method (method);
+
mono_domain_lock (domain);
if (!method_inst) {
g_assert (mini_method_is_default_method (method));
- if (!domain_info->mrgctx_hash)
- domain_info->mrgctx_hash = g_hash_table_new (NULL, NULL);
- mrgctx = (MonoMethodRuntimeGenericContext*)g_hash_table_lookup (domain_info->mrgctx_hash, method);
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->mrgctx_hash)
+ jit_mm->mrgctx_hash = g_hash_table_new (NULL, NULL);
+ mrgctx = (MonoMethodRuntimeGenericContext*)g_hash_table_lookup (jit_mm->mrgctx_hash, method);
+ jit_mm_unlock (jit_mm);
} else {
g_assert (!method_inst->is_open);
- if (!domain_info->method_rgctx_hash)
- domain_info->method_rgctx_hash = g_hash_table_new (mrgctx_hash_func, mrgctx_equal_func);
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->method_rgctx_hash)
+ jit_mm->method_rgctx_hash = g_hash_table_new (mrgctx_hash_func, mrgctx_equal_func);
key.class_vtable = class_vtable;
key.method_inst = method_inst;
- mrgctx = (MonoMethodRuntimeGenericContext *)g_hash_table_lookup (domain_info->method_rgctx_hash, &key);
+ mrgctx = (MonoMethodRuntimeGenericContext *)g_hash_table_lookup (jit_mm->method_rgctx_hash, &key);
+ jit_mm_unlock (jit_mm);
}
if (!mrgctx) {
- //int i;
-
mrgctx = (MonoMethodRuntimeGenericContext*)alloc_rgctx_array (domain, 0, TRUE);
mrgctx->class_vtable = class_vtable;
mrgctx->method_inst = method_inst;
+ /* FIXME: The domain lock prevents duplicates */
+ jit_mm_lock (jit_mm);
if (!method_inst)
- g_hash_table_insert (domain_info->mrgctx_hash, method, mrgctx);
+ g_hash_table_insert (jit_mm->mrgctx_hash, method, mrgctx);
else
- g_hash_table_insert (domain_info->method_rgctx_hash, mrgctx, mrgctx);
+ g_hash_table_insert (jit_mm->method_rgctx_hash, mrgctx, mrgctx);
+ jit_mm_unlock (jit_mm);
/*
g_print ("mrgctx alloced for %s <", mono_type_get_full_name (class_vtable->klass));
- for (i = 0; i < method_inst->type_argc; ++i)
+ for (int i = 0; i < method_inst->type_argc; ++i)
g_print ("%s, ", mono_type_full_name (method_inst->type_argv [i]));
g_print (">\n");
*/
static GHashTable *intrins_id_to_intrins;
static LLVMTypeRef sse_i1_t, sse_i2_t, sse_i4_t, sse_i8_t, sse_r4_t, sse_r8_t;
-static void init_jit_module (MonoDomain *domain);
+static MonoLLVMModule *init_jit_module (void);
static void emit_dbg_loc (EmitContext *ctx, LLVMBuilderRef builder, const unsigned char *cil_code);
static void emit_default_dbg_loc (EmitContext *ctx, LLVMBuilderRef builder);
method_name = mono_aot_get_method_name (cfg);
cfg->llvm_method_name = g_strdup (method_name);
} else {
- init_jit_module (cfg->domain);
- ctx->module = (MonoLLVMModule*)domain_jit_info (cfg->domain)->llvm_module;
+ ctx->module = init_jit_module ();
method_name = mono_method_full_name (cfg->method, TRUE);
}
ctx->method_name = method_name;
}
void
-mono_llvm_free_domain_info (MonoDomain *domain)
+mono_llvm_free_mem_manager (MonoJitMemoryManager *mem_manager)
{
- MonoJitDomainInfo *info = domain_jit_info (domain);
- MonoLLVMModule *module = (MonoLLVMModule*)info->llvm_module;
+ MonoLLVMModule *module = (MonoLLVMModule*)mem_manager->llvm_module;
int i;
if (!module)
g_free (module);
- info->llvm_module = NULL;
+ mem_manager->llvm_module = NULL;
}
void
}
void
-mono_llvm_free_domain_info (MonoDomain *domain)
+mono_llvm_free_mem_manager (MonoJitMemoryManager *mem_manager)
{
}
}
}
-static void
-init_jit_module (MonoDomain *domain)
+static MonoLLVMModule*
+init_jit_module (void)
{
- MonoJitDomainInfo *dinfo;
+ MonoJitMemoryManager *jit_mm;
MonoLLVMModule *module;
- char *name;
- dinfo = domain_jit_info (domain);
- if (dinfo->llvm_module)
- return;
+ // FIXME:
+ jit_mm = get_default_jit_mm ();
+ if (jit_mm->llvm_module)
+ return (MonoLLVMModule*)jit_mm->llvm_module;
mono_loader_lock ();
- if (dinfo->llvm_module) {
+ if (jit_mm->llvm_module) {
mono_loader_unlock ();
- return;
+ return (MonoLLVMModule*)jit_mm->llvm_module;
}
module = g_new0 (MonoLLVMModule, 1);
- name = g_strdup_printf ("mono-%s", domain->friendly_name);
module->context = LLVMGetGlobalContext ();
module->intrins_by_id = g_new0 (LLVMValueRef, INTRINS_NUM);
mono_memory_barrier ();
- dinfo->llvm_module = module;
+ jit_mm->llvm_module = module;
mono_loader_unlock ();
+
+ return (MonoLLVMModule*)jit_mm->llvm_module;
}
static void
llvm_jit_finalize_method (EmitContext *ctx)
{
MonoCompile *cfg = ctx->cfg;
- MonoDomain *domain = mono_domain_get ();
- MonoJitDomainInfo *domain_info;
int nvars = g_hash_table_size (ctx->jit_callees);
LLVMValueRef *callee_vars = g_new0 (LLVMValueRef, nvars);
gpointer *callee_addrs = g_new0 (gpointer, nvars);
decode_llvm_eh_info (ctx, eh_frame);
- mono_domain_lock (domain);
- domain_info = domain_jit_info (domain);
- if (!domain_info->llvm_jit_callees)
- domain_info->llvm_jit_callees = g_hash_table_new (NULL, NULL);
+ // FIXME:
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->llvm_jit_callees)
+ jit_mm->llvm_jit_callees = g_hash_table_new (NULL, NULL);
g_hash_table_iter_init (&iter, ctx->jit_callees);
i = 0;
while (g_hash_table_iter_next (&iter, (void**)&callee, (void**)&var)) {
- GSList *addrs = (GSList*)g_hash_table_lookup (domain_info->llvm_jit_callees, callee);
+ GSList *addrs = (GSList*)g_hash_table_lookup (jit_mm->llvm_jit_callees, callee);
addrs = g_slist_prepend (addrs, callee_addrs [i]);
- g_hash_table_insert (domain_info->llvm_jit_callees, callee, addrs);
+ g_hash_table_insert (jit_mm->llvm_jit_callees, callee, addrs);
i ++;
}
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
}
#else
-static void
-init_jit_module (MonoDomain *domain)
+static MonoLLVMModule*
+init_jit_module (void)
{
g_assert_not_reached ();
}
#include "mini.h"
#include "aot-runtime.h"
+#include "mini-runtime.h"
/* LLVM backend */
gpointer mono_llvm_emit_aot_data (const char *symbol, guint8 *data, int data_len);
gpointer mono_llvm_emit_aot_data_aligned (const char *symbol, guint8 *data, int data_len, int align);
void mono_llvm_check_method_supported (MonoCompile *cfg);
-void mono_llvm_free_domain_info (MonoDomain *domain);
+void mono_llvm_free_mem_manager (MonoJitMemoryManager *mem_manager);
MONO_API void mono_personality (void);
void mono_llvm_create_vars (MonoCompile *cfg);
void mono_llvm_fixup_aot_module (void);
if (!ji) {
user_data.ip = ip;
user_data.method = NULL;
- mono_domain_lock (domain);
- g_hash_table_foreach (domain_jit_info (domain)->jit_trampoline_hash, find_tramp, &user_data);
- mono_domain_unlock (domain);
+
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+
+ jit_mm_lock (jit_mm);
+ g_hash_table_foreach (jit_mm->jit_trampoline_hash, find_tramp, &user_data);
+ jit_mm_unlock (jit_mm);
if (user_data.method) {
char *mname = mono_method_full_name (user_data.method, TRUE);
res = g_strdup_printf ("<%p - JIT trampoline for %s>", ip, mname);
if (!ji) {
user_data.ip = ip;
user_data.method = NULL;
- mono_domain_lock (domain);
- g_hash_table_foreach (domain_jit_info (domain)->jit_trampoline_hash, find_tramp, &user_data);
- mono_domain_unlock (domain);
+
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+
+ jit_mm_lock (jit_mm);
+ g_hash_table_foreach (jit_mm->jit_trampoline_hash, find_tramp, &user_data);
+ jit_mm_unlock (jit_mm);
if (user_data.method) {
char *mname = mono_method_full_name (user_data.method, TRUE);
}
static MonoJitDynamicMethodInfo*
-mono_dynamic_code_hash_lookup (MonoDomain *domain, MonoMethod *method)
+mono_dynamic_code_hash_lookup (MonoMethod *method)
{
MonoJitDynamicMethodInfo *res;
+ MonoJitMemoryManager *jit_mm;
- if (domain_jit_info (domain)->dynamic_code_hash)
- res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (domain_jit_info (domain)->dynamic_code_hash, method);
+ jit_mm = jit_mm_for_method (method);
+ jit_mm_lock (jit_mm);
+ if (jit_mm->dynamic_code_hash)
+ res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (jit_mm->dynamic_code_hash, method);
else
res = NULL;
+ jit_mm_unlock (jit_mm);
return res;
}
case MONO_PATCH_INFO_METHOD_CODE_SLOT: {
gpointer code_slot;
- mono_domain_lock (domain);
- if (!domain_jit_info (domain)->method_code_hash)
- domain_jit_info (domain)->method_code_hash = g_hash_table_new (NULL, NULL);
- code_slot = g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, patch_info->data.method);
+ MonoJitMemoryManager *jit_mm = jit_mm_for_method (patch_info->data.method);
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->method_code_hash)
+ jit_mm->method_code_hash = g_hash_table_new (NULL, NULL);
+ code_slot = g_hash_table_lookup (jit_mm->method_code_hash, patch_info->data.method);
if (!code_slot) {
code_slot = mono_domain_alloc0 (domain, sizeof (gpointer));
- g_hash_table_insert (domain_jit_info (domain)->method_code_hash, patch_info->data.method, code_slot);
+ g_hash_table_insert (jit_mm->method_code_hash, patch_info->data.method, code_slot);
}
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
target = code_slot;
break;
}
int i;
if (method && method->dynamic) {
- jump_table = (void **)mono_code_manager_reserve (mono_dynamic_code_hash_lookup (domain, method)->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
+ jump_table = (void **)mono_code_manager_reserve (mono_dynamic_code_hash_lookup (method)->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
} else {
MonoMemoryManager *mem_manager = m_method_get_mem_manager (method);
if (mono_aot_only) {
mini_register_jump_site (MonoDomain *domain, MonoMethod *method, gpointer ip)
{
MonoJumpList *jlist;
+ MonoJitMemoryManager *jit_mm;
MonoMethod *shared_method = mini_method_to_shared (method);
method = shared_method ? shared_method : method;
- mono_domain_lock (domain);
- jlist = (MonoJumpList *)g_hash_table_lookup (domain_jit_info (domain)->jump_target_hash, method);
+ jit_mm = jit_mm_for_method (method);
+
+ jit_mm_lock (jit_mm);
+ jlist = (MonoJumpList *)g_hash_table_lookup (jit_mm->jump_target_hash, method);
if (!jlist) {
jlist = (MonoJumpList *)mono_domain_alloc0 (domain, sizeof (MonoJumpList));
- g_hash_table_insert (domain_jit_info (domain)->jump_target_hash, method, jlist);
+ g_hash_table_insert (jit_mm->jump_target_hash, method, jlist);
}
jlist->list = g_slist_prepend (jlist->list, ip);
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
}
/*
void
mini_patch_jump_sites (MonoDomain *domain, MonoMethod *method, gpointer addr)
{
- GHashTable *hash = domain_jit_info (domain)->jump_target_hash;
-
- if (!hash)
- return;
-
+ MonoJitMemoryManager *jit_mm;
MonoJumpInfo patch_info;
MonoJumpList *jlist;
GSList *tmp;
MonoMethod *shared_method = mini_method_to_shared (method);
method = shared_method ? shared_method : method;
- mono_domain_lock (domain);
- jlist = (MonoJumpList *)g_hash_table_lookup (hash, method);
+ jit_mm = jit_mm_for_method (method);
+
+ jit_mm_lock (jit_mm);
+ jlist = (MonoJumpList *)g_hash_table_lookup (jit_mm->jump_target_hash, method);
if (jlist)
- g_hash_table_remove (hash, method);
- mono_domain_unlock (domain);
+ g_hash_table_remove (jit_mm->jump_target_hash, method);
+ jit_mm_unlock (jit_mm);
+
if (jlist) {
patch_info.next = NULL;
patch_info.ip.i = 0;
void
mini_patch_llvm_jit_callees (MonoDomain *domain, MonoMethod *method, gpointer addr)
{
- if (!domain_jit_info (domain)->llvm_jit_callees)
+ MonoJitMemoryManager *jit_mm;
+
+ // FIXME:
+ jit_mm = get_default_jit_mm ();
+ if (!jit_mm->llvm_jit_callees)
return;
- GSList *callees = (GSList*)g_hash_table_lookup (domain_jit_info (domain)->llvm_jit_callees, method);
+
+ jit_mm_lock (jit_mm);
+ GSList *callees = (GSList*)g_hash_table_lookup (jit_mm->llvm_jit_callees, method);
GSList *l;
for (l = callees; l; l = l->next) {
*slot = addr;
}
+ jit_mm_unlock (jit_mm);
}
void
gboolean destroy = TRUE, removed;
GHashTableIter iter;
MonoJumpList *jlist;
- MonoJitDomainInfo *info = domain_jit_info (domain);
+ MonoJitMemoryManager *jit_mm;
g_assert (method->dynamic);
mini_get_interp_callbacks ()->free_method (domain, method);
}
- mono_domain_lock (domain);
- ji = mono_dynamic_code_hash_lookup (domain, method);
- mono_domain_unlock (domain);
-
+ ji = mono_dynamic_code_hash_lookup (method);
if (!ji)
return;
mono_lldb_remove_method (domain, method, ji);
mono_domain_lock (domain);
- g_hash_table_remove (info->dynamic_code_hash, method);
mono_domain_jit_code_hash_lock (domain);
removed = mono_internal_hash_table_remove (&domain->jit_code_hash, method);
g_assert (removed);
mono_domain_jit_code_hash_unlock (domain);
- g_hash_table_remove (info->jump_trampoline_hash, method);
- g_hash_table_remove (info->seq_points, method);
-
ji->ji->seq_points = NULL;
+ mono_domain_unlock (domain);
+
+ jit_mm = jit_mm_for_method (method);
- /* requires the domain lock - took above */
- mono_conc_hashtable_remove (info->runtime_invoke_hash, method);
+ jit_mm_lock (jit_mm);
- /* Remove jump targets in this method */
- g_hash_table_iter_init (&iter, info->jump_target_hash);
+ mono_conc_hashtable_remove (jit_mm->runtime_invoke_hash, method);
+ g_hash_table_remove (jit_mm->dynamic_code_hash, method);
+ g_hash_table_remove (jit_mm->jump_trampoline_hash, method);
+ g_hash_table_remove (jit_mm->seq_points, method);
+
+ g_hash_table_iter_init (&iter, jit_mm->jump_target_hash);
while (g_hash_table_iter_next (&iter, NULL, (void**)&jlist)) {
GSList *tmp, *remove;
}
g_slist_free (remove);
}
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
#ifdef MONO_ARCH_HAVE_INVALIDATE_METHOD
if (mini_debug_options.keep_delegates && method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED) {
MonoMethod *invoke, *callee;
MonoObject *(*runtime_invoke) (MonoObject *this_obj, void **params, MonoObject **exc, void* compiled_method);
MonoDomain *domain = mono_domain_get ();
- MonoJitDomainInfo *domain_info;
RuntimeInvokeInfo *info, *info2;
MonoJitInfo *ji = NULL;
gboolean callee_gsharedvt = FALSE;
+ MonoJitMemoryManager *jit_mm;
if (mono_ee_features.force_use_interpreter)
return mini_get_interp_callbacks ()->runtime_invoke (method, obj, params, exc, error);
return NULL;
}
- domain_info = domain_jit_info (domain);
+ jit_mm = jit_mm_for_method (method);
- info = (RuntimeInvokeInfo *)mono_conc_hashtable_lookup (domain_info->runtime_invoke_hash, method);
+ info = (RuntimeInvokeInfo *)mono_conc_hashtable_lookup (jit_mm->runtime_invoke_hash, method);
if (!info) {
gpointer compiled_method;
if (!is_ok (error))
return NULL;
- mono_domain_lock (domain);
- info2 = (RuntimeInvokeInfo *)mono_conc_hashtable_insert (domain_info->runtime_invoke_hash, method, info);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ info2 = (RuntimeInvokeInfo *)mono_conc_hashtable_insert (jit_mm->runtime_invoke_hash, method, info);
+ jit_mm_unlock (jit_mm);
if (info2) {
g_free (info);
info = info2;
}
static void
-mini_create_jit_domain_info (MonoDomain *domain)
+init_jit_mem_manager (MonoMemoryManager *mem_manager)
{
- MonoJitDomainInfo *info = g_new0 (MonoJitDomainInfo, 1);
+ MonoJitMemoryManager *info = g_new0 (MonoJitMemoryManager, 1);
+ info->mem_manager = mem_manager;
info->jump_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
+ info->jump_target_hash = g_hash_table_new (NULL, NULL);
info->jit_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
info->delegate_trampoline_hash = g_hash_table_new (class_method_pair_hash, class_method_pair_equal);
- info->llvm_vcall_trampoline_hash = g_hash_table_new (mono_aligned_addr_hash, NULL);
- info->runtime_invoke_hash = mono_conc_hashtable_new_full (mono_aligned_addr_hash, NULL, NULL, runtime_invoke_info_free);
info->seq_points = g_hash_table_new_full (mono_aligned_addr_hash, NULL, NULL, mono_seq_point_info_free);
+ info->runtime_invoke_hash = mono_conc_hashtable_new_full (mono_aligned_addr_hash, NULL, NULL, runtime_invoke_info_free);
info->arch_seq_points = g_hash_table_new (mono_aligned_addr_hash, NULL);
- info->jump_target_hash = g_hash_table_new (NULL, NULL);
mono_jit_code_hash_init (&info->interp_code_hash);
- domain->runtime_info = info;
+ mem_manager->runtime_info = info;
}
static void
}
static void
-mini_free_jit_domain_info (MonoDomain *domain)
+free_jit_mem_manager (MonoMemoryManager *mem_manager)
{
- MonoJitDomainInfo *info = domain_jit_info (domain);
+ MonoJitMemoryManager *info = (MonoJitMemoryManager*)mem_manager->runtime_info;
g_hash_table_foreach (info->jump_target_hash, delete_jump_list, NULL);
g_hash_table_destroy (info->jump_target_hash);
g_hash_table_destroy (info->mrgctx_hash);
g_hash_table_destroy (info->method_rgctx_hash);
g_hash_table_destroy (info->interp_method_pointer_hash);
- g_hash_table_destroy (info->llvm_vcall_trampoline_hash);
mono_conc_hashtable_destroy (info->runtime_invoke_hash);
g_hash_table_destroy (info->seq_points);
g_hash_table_destroy (info->arch_seq_points);
if (info->agent_info)
- mini_get_dbg_callbacks ()->free_domain_info (domain);
+ mini_get_dbg_callbacks ()->free_mem_manager (info);
g_hash_table_destroy (info->gsharedvt_arg_tramp_hash);
if (info->llvm_jit_callees) {
g_hash_table_foreach (info->llvm_jit_callees, free_jit_callee_list, NULL);
}
mono_internal_hash_table_destroy (&info->interp_code_hash);
#ifdef ENABLE_LLVM
- mono_llvm_free_domain_info (domain);
+ mono_llvm_free_mem_manager (info);
#endif
- g_free (domain->runtime_info);
- domain->runtime_info = NULL;
+ g_free (info);
+ mem_manager->runtime_info = NULL;
}
#ifdef ENABLE_LLVM
callbacks.metadata_update_init = mini_metadata_update_init;
callbacks.metadata_update_published = mini_invalidate_transformed_interp_methods;
#endif
+ callbacks.init_mem_manager = init_jit_mem_manager;
+ callbacks.free_mem_manager = free_jit_mem_manager;
mono_install_callbacks (&callbacks);
#endif
mono_threads_install_cleanup (mini_thread_cleanup);
-#ifdef JIT_TRAMPOLINES_WORK
- mono_install_create_domain_hook (mini_create_jit_domain_info);
- mono_install_free_domain_hook (mini_free_jit_domain_info);
-#endif
mono_install_get_cached_class_info (mono_aot_get_cached_class_info);
mono_install_get_class_from_name (mono_aot_get_class_from_name);
mono_install_jit_info_find_in_aot (mono_aot_find_jit_info);
#include "mini.h"
#include "ee.h"
-/* Per-domain information maintained by the JIT */
-typedef struct
-{
+/*
+ * Per-memory manager information maintained by the JIT.
+ */
+typedef struct {
+ MonoMemoryManager *mem_manager;
+
/* Maps MonoMethod's to a GSList of GOT slot addresses pointing to its code */
GHashTable *jump_target_got_slot_hash;
GHashTable *jump_target_hash;
GHashTable *delegate_trampoline_hash;
/* Maps ClassMethodPair -> MonoDelegateTrampInfo */
GHashTable *static_rgctx_trampoline_hash;
- GHashTable *llvm_vcall_trampoline_hash;
/* maps MonoMethod -> MonoJitDynamicMethodInfo */
GHashTable *dynamic_code_hash;
GHashTable *method_code_hash;
GHashTable *method_rgctx_hash;
/* Maps gpointer -> InterpMethod */
GHashTable *interp_method_pointer_hash;
-} MonoJitDomainInfo;
+} MonoJitMemoryManager;
+
+static inline MonoJitMemoryManager*
+get_default_jit_mm (void)
+{
+ return (MonoJitMemoryManager*)(mono_domain_ambient_memory_manager (mono_get_root_domain ()))->runtime_info;
+}
+
+static inline MonoJitMemoryManager*
+jit_mm_for_method (MonoMethod *method)
+{
+ /*
+ * Some places might not look up the correct memory manager because of generic instances/generic sharing etc.
+ * So use the same memory manager everywhere, this is not a problem since we don't support unloading yet.
+ */
+ //return (MonoJitMemoryManager*)m_method_get_mem_manager (method)->runtime_info;
+ return get_default_jit_mm ();
+}
-#define domain_jit_info(domain) ((MonoJitDomainInfo*)((domain)->runtime_info))
+static inline void
+jit_mm_lock (MonoJitMemoryManager *jit_mm)
+{
+ mono_mem_manager_lock (jit_mm->mem_manager);
+}
+
+static inline void
+jit_mm_unlock (MonoJitMemoryManager *jit_mm)
+{
+ mono_mem_manager_unlock (jit_mm->mem_manager);
+}
/*
* Stores state need to resume exception handling when using LLVM
{
SeqPointInfo *info;
MonoJitInfo *ji;
+ MonoJitMemoryManager *jit_mm;
- mono_domain_lock (domain);
- info = (SeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points, code);
- mono_domain_unlock (domain);
+ jit_mm = get_default_jit_mm ();
+
+ jit_mm_lock (jit_mm);
+ info = (SeqPointInfo *)g_hash_table_lookup (jit_mm->arch_seq_points, code);
+ jit_mm_unlock (jit_mm);
if (!info) {
- ji = mono_jit_info_table_find (domain, code);
+ ji = mini_jit_info_table_find (code);
g_assert (ji);
// FIXME: Optimize the size
info->ss_tramp_addr = &ss_trampoline;
- mono_domain_lock (domain);
- g_hash_table_insert (domain_jit_info(domain)->arch_seq_points, code, info);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ g_hash_table_insert (jit_mm->arch_seq_points, code, info);
+ jit_mm_unlock (jit_mm);
}
return info;
{
gpointer ctx;
gpointer res;
- MonoDomain *domain;
RgctxTrampInfo tmp_info;
RgctxTrampInfo *info;
- MonoMemoryManager *mem_manager;
+ MonoJitMemoryManager *jit_mm;
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
g_assert (((gpointer*)addr) [2] == 0);
ctx = mini_method_get_rgctx (m);
- domain = mono_domain_get ();
- mem_manager = m_method_get_mem_manager (m);
+ jit_mm = jit_mm_for_method (m);
/*
* In the AOT case, addr might point to either the method, or to an unbox trampoline,
* so make the hash keyed on the m+addr pair.
*/
- mono_domain_lock (domain);
- if (!domain_jit_info (domain)->static_rgctx_trampoline_hash)
- domain_jit_info (domain)->static_rgctx_trampoline_hash = g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal);
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->static_rgctx_trampoline_hash)
+ jit_mm->static_rgctx_trampoline_hash = g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal);
tmp_info.m = m;
tmp_info.addr = addr;
- res = g_hash_table_lookup (domain_jit_info (domain)->static_rgctx_trampoline_hash,
+ res = g_hash_table_lookup (jit_mm->static_rgctx_trampoline_hash,
&tmp_info);
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
if (res)
return res;
if (mono_aot_only)
res = mono_aot_get_static_rgctx_trampoline (ctx, addr);
else
- res = mono_arch_get_static_rgctx_trampoline (mem_manager, ctx, addr);
+ res = mono_arch_get_static_rgctx_trampoline (jit_mm->mem_manager, ctx, addr);
- mono_domain_lock (domain);
+ jit_mm_lock (jit_mm);
/* Duplicates inserted while we didn't hold the lock are OK */
info = (RgctxTrampInfo *)m_method_alloc (m, sizeof (RgctxTrampInfo));
info->m = m;
info->addr = addr;
- g_hash_table_insert (domain_jit_info (domain)->static_rgctx_trampoline_hash, info, res);
-
+ g_hash_table_insert (jit_mm->static_rgctx_trampoline_hash, info, res);
UnlockedIncrement (&static_rgctx_trampolines);
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
return res;
}
* We do this here instead of in mono_codegen () to cover the case when m
* was loaded from an aot image.
*/
- if (domain_jit_info (domain)->jump_target_got_slot_hash) {
- GSList *list, *tmp;
- MonoMethod *shared_method = mini_method_to_shared (m);
- m = shared_method ? shared_method : m;
-
- mono_domain_lock (domain);
- list = (GSList *)g_hash_table_lookup (domain_jit_info (domain)->jump_target_got_slot_hash, m);
+ MonoJitMemoryManager *jit_mm;
+ GSList *list, *tmp;
+ MonoMethod *shared_method = mini_method_to_shared (m);
+ m = shared_method ? shared_method : m;
+ jit_mm = jit_mm_for_method (m);
+
+ if (jit_mm->jump_target_got_slot_hash) {
+ jit_mm_lock (jit_mm);
+ list = (GSList *)g_hash_table_lookup (jit_mm->jump_target_got_slot_hash, m);
if (list) {
for (tmp = list; tmp; tmp = tmp->next) {
gpointer *got_slot = (gpointer *)tmp->data;
*got_slot = addr;
}
- g_hash_table_remove (domain_jit_info (domain)->jump_target_got_slot_hash, m);
+ g_hash_table_remove (jit_mm->jump_target_got_slot_hash, m);
g_slist_free (list);
}
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
}
return addr;
gpointer
mono_create_jump_trampoline (MonoDomain *domain, MonoMethod *method, gboolean add_sync_wrapper, MonoError *error)
{
+ MonoJitMemoryManager *jit_mm;
MonoJitInfo *ji;
gpointer code;
guint32 code_size = 0;
return ret;
}
- code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
+ code = mono_jit_find_compiled_method_with_jit_info (mono_get_root_domain (), method, &ji);
/*
* We cannot recover the correct type of a shared generic
* method from its native code address, so we use the
return code;
}
- mono_domain_lock (domain);
- code = g_hash_table_lookup (domain_jit_info (domain)->jump_trampoline_hash, method);
- mono_domain_unlock (domain);
+ jit_mm = jit_mm_for_method (method);
+
+ jit_mm_lock (jit_mm);
+ code = g_hash_table_lookup (jit_mm->jump_trampoline_hash, method);
+ jit_mm_unlock (jit_mm);
if (code)
return code;
mono_jit_info_table_add (domain, ji);
- mono_domain_lock (domain);
- g_hash_table_insert (domain_jit_info (domain)->jump_trampoline_hash, method, code);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ g_hash_table_insert (jit_mm->jump_trampoline_hash, method, code);
+ jit_mm_unlock (jit_mm);
return code;
}
gpointer
mono_create_jit_trampoline (MonoDomain *domain, MonoMethod *method, MonoError *error)
{
+ MonoJitMemoryManager *jit_mm;
gpointer tramp;
error_init (error);
}
}
- mono_domain_lock (domain);
- tramp = g_hash_table_lookup (domain_jit_info (domain)->jit_trampoline_hash, method);
- mono_domain_unlock (domain);
+ jit_mm = jit_mm_for_method (method);
+
+ jit_mm_lock (jit_mm);
+ tramp = g_hash_table_lookup (jit_mm->jit_trampoline_hash, method);
+ jit_mm_unlock (jit_mm);
if (tramp)
return tramp;
tramp = mono_create_specific_trampoline (method, MONO_TRAMPOLINE_JIT, domain, NULL);
-
- mono_domain_lock (domain);
- g_hash_table_insert (domain_jit_info (domain)->jit_trampoline_hash, method, tramp);
+
+ jit_mm_lock (jit_mm);
+ g_hash_table_insert (jit_mm->jit_trampoline_hash, method, tramp);
UnlockedIncrement (&jit_trampolines);
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
return tramp;
}
MonoDelegateTrampInfo *tramp_info;
MonoClassMethodPair pair, *dpair;
guint32 code_size = 0;
+ MonoJitMemoryManager *jit_mm;
pair.klass = klass;
pair.method = method;
- mono_domain_lock (domain);
- tramp_info = (MonoDelegateTrampInfo *)g_hash_table_lookup (domain_jit_info (domain)->delegate_trampoline_hash, &pair);
- mono_domain_unlock (domain);
+
+ // FIXME: Use the proper memory manager
+ jit_mm = get_default_jit_mm ();
+ jit_mm_lock (jit_mm);
+ tramp_info = (MonoDelegateTrampInfo *)g_hash_table_lookup (jit_mm->delegate_trampoline_hash, &pair);
+ jit_mm_unlock (jit_mm);
if (tramp_info)
return tramp_info;
memcpy (dpair, &pair, sizeof (MonoClassMethodPair));
/* store trampoline address */
- mono_domain_lock (domain);
- g_hash_table_insert (domain_jit_info (domain)->delegate_trampoline_hash, dpair, tramp_info);
- mono_domain_unlock (domain);
+ jit_mm_lock (jit_mm);
+ g_hash_table_insert (jit_mm->delegate_trampoline_hash, dpair, tramp_info);
+ jit_mm_unlock (jit_mm);
return tramp_info;
}
return mono_assembly_has_skip_verification (assembly);
}
-static void
-mono_dynamic_code_hash_insert (MonoDomain *domain, MonoMethod *method, MonoJitDynamicMethodInfo *ji)
-{
- if (!domain_jit_info (domain)->dynamic_code_hash)
- domain_jit_info (domain)->dynamic_code_hash = g_hash_table_new (NULL, NULL);
- g_hash_table_insert (domain_jit_info (domain)->dynamic_code_hash, method, ji);
-}
-
-static MonoJitDynamicMethodInfo*
-mono_dynamic_code_hash_lookup (MonoDomain *domain, MonoMethod *method)
-{
- MonoJitDynamicMethodInfo *res;
-
- if (domain_jit_info (domain)->dynamic_code_hash)
- res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (domain_jit_info (domain)->dynamic_code_hash, method);
- else
- res = NULL;
- return res;
-}
-
typedef struct {
MonoClass *vtype;
GList *active, *inactive;
/* Allocate the code into a separate memory pool so it can be freed */
cfg->dynamic_info = g_new0 (MonoJitDynamicMethodInfo, 1);
cfg->dynamic_info->code_mp = mono_code_manager_new_dynamic ();
- mono_domain_lock (cfg->domain);
- mono_dynamic_code_hash_insert (cfg->domain, cfg->method, cfg->dynamic_info);
- mono_domain_unlock (cfg->domain);
+
+ MonoJitMemoryManager *jit_mm = (MonoJitMemoryManager*)cfg->jit_mm;
+ jit_mm_lock (jit_mm);
+ if (!jit_mm->dynamic_code_hash)
+ jit_mm->dynamic_code_hash = g_hash_table_new (NULL, NULL);
+ g_hash_table_insert (jit_mm->dynamic_code_hash, cfg->method, cfg->dynamic_info);
+ jit_mm_unlock (jit_mm);
if (mono_using_xdebug)
/* See the comment for cfg->code_domain */
cfg->self_init = (flags & JIT_FLAG_SELF_INIT) != 0;
cfg->code_exec_only = (flags & JIT_FLAG_CODE_EXEC_ONLY) != 0;
cfg->backend = current_backend;
+ cfg->jit_mm = jit_mm_for_method (cfg->method);
cfg->mem_manager = m_method_get_mem_manager (cfg->method);
if (cfg->method->wrapper_type == MONO_WRAPPER_ALLOC) {
if (!cfg->compile_aot && !(flags & JIT_FLAG_DISCARD_RESULTS)) {
mono_domain_lock (cfg->domain);
mono_jit_info_table_add (cfg->domain, cfg->jit_info);
+ mono_domain_unlock (cfg->domain);
- if (cfg->method->dynamic)
- mono_dynamic_code_hash_lookup (cfg->domain, cfg->method)->ji = cfg->jit_info;
+ if (cfg->method->dynamic) {
+ MonoJitMemoryManager *jit_mm = (MonoJitMemoryManager*)cfg->jit_mm;
+ MonoJitDynamicMethodInfo *res;
- mono_postprocess_patches_after_ji_publish (cfg);
+ jit_mm_lock (jit_mm);
+ g_assert (jit_mm->dynamic_code_hash);
+ res = (MonoJitDynamicMethodInfo *)g_hash_table_lookup (jit_mm->dynamic_code_hash, method);
+ jit_mm_unlock (jit_mm);
+ g_assert (res);
+ res->ji = cfg->jit_info;
+ }
- mono_domain_unlock (cfg->domain);
+ mono_postprocess_patches_after_ji_publish (cfg);
}
#if 0
MonoGSharedVtMethodInfo *gsharedvt_info;
+ gpointer jit_mm;
MonoMemoryManager *mem_manager;
/* Points to the gsharedvt locals area at runtime */
MonoBasicBlock *bb;
GSList *bb_seq_points, *l;
MonoInst *last;
- MonoDomain *domain = cfg->domain;
int i, seq_info_size;
GSList **next = NULL;
SeqPoint* seq_points;
// FIXME: dynamic methods
if (!cfg->compile_aot) {
- mono_domain_lock (domain);
+ // FIXME:
+ MonoJitMemoryManager *jit_mm = get_default_jit_mm ();
+ jit_mm_lock (jit_mm);
// FIXME: The lookup can fail if the method is JITted recursively though a type cctor
- if (!g_hash_table_lookup (domain_jit_info (domain)->seq_points, cfg->method_to_register))
- g_hash_table_insert (domain_jit_info (domain)->seq_points, cfg->method_to_register, cfg->seq_point_info);
+ if (!g_hash_table_lookup (jit_mm->seq_points, cfg->method_to_register))
+ g_hash_table_insert (jit_mm->seq_points, cfg->method_to_register, cfg->seq_point_info);
else
mono_seq_point_info_free (cfg->seq_point_info);
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
g_assert (jinfo);
jinfo->seq_points = cfg->seq_point_info;
ERROR_DECL (error);
MonoSeqPointInfo *seq_points;
MonoMethod *declaring_generic_method = NULL, *shared_method = NULL;
+ MonoJitMemoryManager *jit_mm;
if (method->is_inflated) {
declaring_generic_method = mono_method_get_declaring_generic_method (method);
mono_error_assert_ok (error);
}
- mono_domain_lock (domain);
- seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, method);
+ // FIXME:
+ jit_mm = get_default_jit_mm ();
+ jit_mm_lock (jit_mm);
+ seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (jit_mm->seq_points, method);
if (!seq_points && method->is_inflated) {
/* generic sharing + aot */
- seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, declaring_generic_method);
+ seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (jit_mm->seq_points, declaring_generic_method);
if (!seq_points)
- seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->seq_points, shared_method);
+ seq_points = (MonoSeqPointInfo *)g_hash_table_lookup (jit_mm->seq_points, shared_method);
}
- mono_domain_unlock (domain);
+ jit_mm_unlock (jit_mm);
return seq_points;
}
projects / platform / upstream / dotnet / runtime.git / commitdiff