From 9623156cfdfdfcc55230160942a45baff98083b8 Mon Sep 17 00:00:00 2001 From: Zoltan Varga Date: Fri, 25 Sep 2020 17:41:32 -0400 Subject: [PATCH] [runtime] Transition the trampoline code to use memory managers for memory allocation. (#20408) * [runtime] Transition the trampoline code to use memory managers for memory allocation. * Fix a c++-ism. * Handle one more case. * Pass a memory manager to mono_method_alloc_generic_virtual_trampoline. * Remove now unused mono_domain_code_... functions. --- mono/metadata/domain-internals.h | 15 ----------- mono/metadata/domain.c | 56 --------------------------------------- mono/metadata/loader-internals.h | 6 +++++ mono/metadata/memory-manager.c | 10 ++++++- mono/metadata/object-internals.h | 4 +-- mono/metadata/object.c | 10 +++---- mono/mini/lldb.c | 6 ++--- mono/mini/llvm-jit.cpp | 2 +- mono/mini/mini-amd64.c | 10 ++++--- mono/mini/mini-arm.c | 10 ++++--- mono/mini/mini-arm64.c | 10 ++++--- mono/mini/mini-mips.c | 5 ++-- mono/mini/mini-ppc.c | 5 ++-- mono/mini/mini-s390x.c | 10 ++++--- mono/mini/mini-sparc.c | 10 ++++--- mono/mini/mini-trampolines.c | 18 ++++++++----- mono/mini/mini-x86.c | 10 ++++--- mono/mini/mini.h | 6 ++--- mono/mini/tramp-amd64-gsharedvt.c | 3 ++- mono/mini/tramp-amd64.c | 29 +++++++++++--------- mono/mini/tramp-arm.c | 33 ++++++++++++----------- mono/mini/tramp-arm64.c | 18 +++++++------ mono/mini/tramp-mips.c | 15 ++++++----- mono/mini/tramp-ppc.c | 26 ++++++++---------- mono/mini/tramp-riscv.c | 17 +++++++----- mono/mini/tramp-s390x.c | 15 ++++++----- mono/mini/tramp-sparc.c | 8 +++--- mono/mini/tramp-wasm.c | 4 +-- mono/mini/tramp-x86.c | 18 +++++++------ 29 files changed, 181 insertions(+), 208 deletions(-) diff --git a/mono/metadata/domain-internals.h b/mono/metadata/domain-internals.h index f31a9a73ead..acc8a515395 100644 --- a/mono/metadata/domain-internals.h +++ b/mono/metadata/domain-internals.h @@ -573,21 +573,6 @@ mono_domain_alloc0 (MonoDomain *domain, guint size); #define mono_domain_alloc0(domain, size) (g_cast (mono_domain_alloc0 ((domain), (size)))) -void* -mono_domain_code_reserve (MonoDomain *domain, int size); - -#define mono_domain_code_reserve(domain, size) (g_cast (mono_domain_code_reserve ((domain), (size)))) - -void* -mono_domain_code_reserve_align (MonoDomain *domain, int size, int alignment); - -#define mono_domain_code_reserve_align(domain, size, align) (g_cast (mono_domain_code_reserve_align ((domain), (size), (align)))) - -void -mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize); - -void -mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data); //#endif gpointer diff --git a/mono/metadata/domain.c b/mono/metadata/domain.c index 7671bea8e62..15ac596d199 100644 --- a/mono/metadata/domain.c +++ b/mono/metadata/domain.c @@ -1360,62 +1360,6 @@ gpointer return lock_free_mempool_alloc0 (domain->lock_free_mp, size); } -/* - * mono_domain_code_reserve: - * - * LOCKING: Acquires the default memory manager lock. - */ -void* -(mono_domain_code_reserve) (MonoDomain *domain, int size) -{ - MonoMemoryManager *memory_manager = mono_domain_memory_manager (domain); - - return mono_mem_manager_code_reserve (memory_manager, size); -} - -/* - * mono_domain_code_reserve_align: - * - * LOCKING: Acquires the default memory manager lock. - */ -void* -(mono_domain_code_reserve_align) (MonoDomain *domain, int size, int alignment) -{ - MonoMemoryManager *memory_manager = mono_domain_memory_manager (domain); - - return mono_mem_manager_code_reserve_align (memory_manager, size, alignment); -} - -/* - * mono_domain_code_commit: - * - * LOCKING: Acquires the default memory manager lock. - */ -void -mono_domain_code_commit (MonoDomain *domain, void *data, int size, int newsize) -{ - MonoMemoryManager *memory_manager = mono_domain_memory_manager (domain); - - mono_mem_manager_code_commit (memory_manager, data, size, newsize); -} - -/* - * mono_domain_code_foreach: - * Iterate over the code thunks of the code manager of @domain. - * - * The @func callback MUST not take any locks. If it really needs to, it must respect - * the locking rules of the runtime: http://www.mono-project.com/Mono:Runtime:Documentation:ThreadSafety - * LOCKING: Acquires the default memory manager lock. - */ - -void -mono_domain_code_foreach (MonoDomain *domain, MonoCodeManagerFunc func, void *user_data) -{ - MonoMemoryManager *memory_manager = mono_domain_memory_manager (domain); - - mono_mem_manager_code_foreach (memory_manager, func, user_data); -} - /** * mono_context_set: */ diff --git a/mono/metadata/loader-internals.h b/mono/metadata/loader-internals.h index f7742cdb6ed..e0d67f22763 100644 --- a/mono/metadata/loader-internals.h +++ b/mono/metadata/loader-internals.h @@ -27,6 +27,8 @@ #endif #endif +G_BEGIN_DECLS + typedef struct _MonoLoadedImages MonoLoadedImages; typedef struct _MonoAssemblyLoadContext MonoAssemblyLoadContext; typedef struct _MonoMemoryManager MonoMemoryManager; @@ -232,6 +234,8 @@ mono_mem_manager_alloc0_nolock (MonoMemoryManager *memory_manager, guint size); void * mono_mem_manager_code_reserve (MonoMemoryManager *memory_manager, int size); +#define mono_mem_manager_code_reserve(mem_manager, size) (g_cast (mono_mem_manager_code_reserve ((mem_manager), (size)))) + void * mono_mem_manager_code_reserve_align (MonoMemoryManager *memory_manager, int size, int newsize); @@ -244,4 +248,6 @@ mono_mem_manager_code_foreach (MonoMemoryManager *memory_manager, MonoCodeManage char* mono_mem_manager_strdup (MonoMemoryManager *memory_manager, const char *s); +G_END_DECLS + #endif diff --git a/mono/metadata/memory-manager.c b/mono/metadata/memory-manager.c index 01cb24e65bf..f61cb422a7b 100644 --- a/mono/metadata/memory-manager.c +++ b/mono/metadata/memory-manager.c @@ -182,7 +182,7 @@ mono_mem_manager_strdup (MonoMemoryManager *memory_manager, const char *s) } void * -mono_mem_manager_code_reserve (MonoMemoryManager *memory_manager, int size) +(mono_mem_manager_code_reserve) (MonoMemoryManager *memory_manager, int size) { void *res; @@ -213,6 +213,14 @@ mono_mem_manager_code_commit (MonoMemoryManager *memory_manager, void *data, int mono_mem_manager_unlock (memory_manager); } +/* + * mono_mem_manager_code_foreach: + * Iterate over the code thunks of the code manager of @memory_manager. + * + * The @func callback MUST not take any locks. If it really needs to, it must respect + * the locking rules of the runtime: http://www.mono-project.com/Mono:Runtime:Documentation:ThreadSafety + * LOCKING: Acquires the memory manager lock. + */ void mono_mem_manager_code_foreach (MonoMemoryManager *memory_manager, MonoCodeManagerFunc func, void *user_data) { diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index 0175b9134d3..5f1f5338070 100644 --- a/mono/metadata/object-internals.h +++ b/mono/metadata/object-internals.h @@ -1908,9 +1908,9 @@ mono_method_add_generic_virtual_invocation (MonoDomain *domain, MonoVTable *vtab MonoMethod *method, gpointer code); gpointer -mono_method_alloc_generic_virtual_trampoline (MonoDomain *domain, int size); +mono_method_alloc_generic_virtual_trampoline (MonoMemoryManager *mem_manager, int size); -#define mono_method_alloc_generic_virtual_trampoline(domain, size) (g_cast (mono_method_alloc_generic_virtual_trampoline ((domain), (size)))) +#define mono_method_alloc_generic_virtual_trampoline(mem_manager, size) (g_cast (mono_method_alloc_generic_virtual_trampoline ((mem_manager), (size)))) typedef enum { MONO_UNHANDLED_POLICY_LEGACY, diff --git a/mono/metadata/object.c b/mono/metadata/object.c index 22acc48e4c9..59481ff5ef1 100644 --- a/mono/metadata/object.c +++ b/mono/metadata/object.c @@ -1713,15 +1713,13 @@ mono_vtable_build_imt_slot (MonoVTable* vtable, int imt_slot) /** * mono_method_alloc_generic_virtual_trampoline: - * \param domain a domain + * \param mem_manager a memory manager * \param size size in bytes * Allocs \p size bytes to be used for the code of a generic virtual - * trampoline. It's either allocated from the domain's code manager or - * reused from a previously invalidated piece. - * LOCKING: The domain lock must be held. + * trampoline. */ gpointer -(mono_method_alloc_generic_virtual_trampoline) (MonoDomain *domain, int size) +(mono_method_alloc_generic_virtual_trampoline) (MonoMemoryManager *mem_manager, int size) { MONO_REQ_GC_NEUTRAL_MODE; @@ -1735,7 +1733,7 @@ gpointer } generic_virtual_trampolines_size += size; - return mono_domain_code_reserve (domain, size); + return mono_mem_manager_code_reserve (mem_manager, size); } typedef struct _GenericVirtualCase { diff --git a/mono/mini/lldb.c b/mono/mini/lldb.c index 3201c65b314..6f1c9b354f5 100644 --- a/mono/mini/lldb.c +++ b/mono/mini/lldb.c @@ -440,7 +440,7 @@ mono_lldb_save_method_info (MonoCompile *cfg) g_hash_table_insert (dyn_codegen_regions, cfg->method, GINT_TO_POINTER (region_id)); lldb_unlock (); } else { - mono_domain_code_foreach (cfg->domain, find_code_region, &udata); + mono_mem_manager_code_foreach (cfg->mem_manager, find_code_region, &udata); g_assert (udata.found); region_id = register_codegen_region (udata.region_start, udata.region_size, FALSE); @@ -564,7 +564,7 @@ mono_lldb_save_trampoline_info (MonoTrampInfo *info) udata.code = info->code; mono_global_codeman_foreach (find_code_region, &udata); if (!udata.found) - mono_domain_code_foreach (mono_get_root_domain (), find_code_region, &udata); + mono_mem_manager_code_foreach (mono_domain_ambient_memory_manager (mono_get_root_domain ()), find_code_region, &udata); if (!udata.found) /* Can happen with AOT */ return; @@ -612,7 +612,7 @@ mono_lldb_save_specific_trampoline_info (gpointer arg1, MonoTrampolineType tramp udata.code = code; mono_global_codeman_foreach (find_code_region, &udata); if (!udata.found) - mono_domain_code_foreach (mono_get_root_domain (), find_code_region, &udata); + mono_mem_manager_code_foreach (mono_domain_ambient_memory_manager (mono_get_root_domain ()), find_code_region, &udata); g_assert (udata.found); region_id = register_codegen_region (udata.region_start, udata.region_size, FALSE); diff --git a/mono/mini/llvm-jit.cpp b/mono/mini/llvm-jit.cpp index 8307990a4e2..17a9eb84463 100644 --- a/mono/mini/llvm-jit.cpp +++ b/mono/mini/llvm-jit.cpp @@ -89,7 +89,7 @@ alloc_code (LLVMValueRef function, int size) { auto cfg = (MonoCompile *)mono_native_tls_get_value (current_cfg_tls_id); g_assert (cfg); - return (unsigned char *)mono_domain_code_reserve (cfg->domain, size); + return (unsigned char *)mono_mem_manager_code_reserve (cfg->mem_manager, size); } class MonoJitMemoryManager : public RTDyldMemoryManager diff --git a/mono/mini/mini-amd64.c b/mono/mini/mini-amd64.c index a33c414825b..e31da7f3282 100644 --- a/mono/mini/mini-amd64.c +++ b/mono/mini/mini-amd64.c @@ -8660,10 +8660,12 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC } size += item->chunk_size; } - if (fail_tramp) - code = (guint8 *)mono_method_alloc_generic_virtual_trampoline (domain, size + MONO_TRAMPOLINE_UNWINDINFO_SIZE(0)); - else - code = (guint8 *)mono_domain_code_reserve (domain, size + MONO_TRAMPOLINE_UNWINDINFO_SIZE(0)); + if (fail_tramp) { + code = (guint8 *)mono_method_alloc_generic_virtual_trampoline (mono_domain_ambient_memory_manager (domain), size + MONO_TRAMPOLINE_UNWINDINFO_SIZE(0)); + } else { + MonoMemoryManager *mem_manager = m_class_get_mem_manager (domain, vtable->klass); + code = (guint8 *)mono_mem_manager_code_reserve (mem_manager, size + MONO_TRAMPOLINE_UNWINDINFO_SIZE(0)); + } start = code; unwind_ops = mono_arch_get_cie_program (); diff --git a/mono/mini/mini-arm.c b/mono/mini/mini-arm.c index b315929e204..03670f787d9 100644 --- a/mono/mini/mini-arm.c +++ b/mono/mini/mini-arm.c @@ -6974,10 +6974,12 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC if (large_offsets) size += 4 * count; /* The ARM_ADD_REG_IMM to pop the stack */ - if (fail_tramp) - code = mono_method_alloc_generic_virtual_trampoline (domain, size); - else - code = mono_domain_code_reserve (domain, size); + if (fail_tramp) { + code = mono_method_alloc_generic_virtual_trampoline (mono_domain_ambient_memory_manager (domain), size); + } else { + MonoMemoryManager *mem_manager = m_class_get_mem_manager (domain, vtable->klass); + code = mono_mem_manager_code_reserve (mem_manager, size); + } start = code; unwind_ops = mono_arch_get_cie_program (); diff --git a/mono/mini/mini-arm64.c b/mono/mini/mini-arm64.c index 317390249d6..c0aa7d387ad 100644 --- a/mono/mini/mini-arm64.c +++ b/mono/mini/mini-arm64.c @@ -5350,10 +5350,12 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC } } - if (fail_tramp) - buf = (guint8*)mono_method_alloc_generic_virtual_trampoline (domain, buf_len); - else - buf = mono_domain_code_reserve (domain, buf_len); + if (fail_tramp) { + buf = (guint8*)mono_method_alloc_generic_virtual_trampoline (mono_domain_ambient_memory_manager (domain), buf_len); + } else { + MonoMemoryManager *mem_manager = m_class_get_mem_manager (domain, vtable->klass); + buf = mono_mem_manager_code_reserve (mem_manager, buf_len); + } code = buf; MINI_BEGIN_CODEGEN (); diff --git a/mono/mini/mini-mips.c b/mono/mini/mini-mips.c index 13cf4e57803..91100bc30ba 100644 --- a/mono/mini/mini-mips.c +++ b/mono/mini/mini-mips.c @@ -5343,9 +5343,10 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC /* the initial load of the vtable address */ size += MIPS_LOAD_SEQUENCE_LENGTH; if (fail_tramp) { - code = mono_method_alloc_generic_virtual_trampoline (domain, size); + code = mono_method_alloc_generic_virtual_trampoline (mono_domain_ambient_memory_manager (domain), size); } else { - code = mono_domain_code_reserve (domain, size); + MonoMemoryManager *mem_manager = m_class_get_mem_manager (domain, vtable->klass); + code = mono_mem_manager_code_reserve (mem_manager, size); } start = code; diff --git a/mono/mini/mini-ppc.c b/mono/mini/mini-ppc.c index 0d65d4b88fb..3dca1bbd0c1 100644 --- a/mono/mini/mini-ppc.c +++ b/mono/mini/mini-ppc.c @@ -5512,9 +5512,10 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC /* the initial load of the vtable address */ size += PPC_LOAD_SEQUENCE_LENGTH + LOADSTORE_SIZE; if (fail_tramp) { - code = mono_method_alloc_generic_virtual_trampoline (domain, size); + code = mono_method_alloc_generic_virtual_trampoline (mono_domain_ambient_memory_manager (domain), size); } else { - code = mono_domain_code_reserve (domain, size); + MonoMemoryManager *mem_manager = m_class_get_mem_manager (domain, vtable->klass); + code = mono_mem_manager_code_reserve (mem_manager, size); } start = code; diff --git a/mono/mini/mini-s390x.c b/mono/mini/mini-s390x.c index ed36872f124..6c5eb8d6f79 100644 --- a/mono/mini/mini-s390x.c +++ b/mono/mini/mini-s390x.c @@ -6500,10 +6500,12 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, size += item->chunk_size; } - if (fail_tramp) - code = mono_method_alloc_generic_virtual_trampoline (domain, size); - else - code = mono_domain_code_reserve (domain, size); + if (fail_tramp) { + code = mono_method_alloc_generic_virtual_trampoline (mono_domain_ambient_memory_manager (domain), size); + } else { + MonoMemoryManager *mem_manager = m_class_get_mem_manager (domain, vtable->klass); + code = mono_mem_manager_code_reserve (mem_manager, size); + } start = code; diff --git a/mono/mini/mini-sparc.c b/mono/mini/mini-sparc.c index e5bce381534..767bea33665 100644 --- a/mono/mini/mini-sparc.c +++ b/mono/mini/mini-sparc.c @@ -2278,10 +2278,12 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC } size += item->chunk_size; } - if (fail_tramp) - code = mono_method_alloc_generic_virtual_trampoline (domain, size * 4); - else - code = mono_domain_code_reserve (domain, size * 4); + if (fail_tramp) { + code = mono_method_alloc_generic_virtual_trampoline (mono_domain_ambient_memory_manager (domain), size * 4); + } else { + MonoMemoryManager *mem_manager = m_class_get_mem_manager (domain, vtable->klass); + code = mono_mem_manager_code_reserve (mem_manager, size * 4); + } start = code; for (i = 0; i < count; ++i) { MonoIMTCheckItem *item = imt_entries [i]; diff --git a/mono/mini/mini-trampolines.c b/mono/mini/mini-trampolines.c index 6ea3696b1c1..7f120d21680 100644 --- a/mono/mini/mini-trampolines.c +++ b/mono/mini/mini-trampolines.c @@ -100,6 +100,7 @@ mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr) MonoDomain *domain; RgctxTrampInfo tmp_info; RgctxTrampInfo *info; + MonoMemoryManager *mem_manager; #ifdef PPC_USES_FUNCTION_DESCRIPTOR g_assert (((gpointer*)addr) [2] == 0); @@ -108,6 +109,7 @@ mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr) ctx = mini_method_get_rgctx (m); domain = mono_domain_get (); + mem_manager = m_method_get_mem_manager (domain, m); /* * In the AOT case, addr might point to either the method, or to an unbox trampoline, @@ -127,7 +129,7 @@ mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr) if (mono_aot_only) res = mono_aot_get_static_rgctx_trampoline (ctx, addr); else - res = mono_arch_get_static_rgctx_trampoline (ctx, addr); + res = mono_arch_get_static_rgctx_trampoline (mem_manager, ctx, addr); mono_domain_lock (domain); /* Duplicates inserted while we didn't hold the lock are OK */ @@ -158,16 +160,19 @@ gpointer mono_create_ftnptr_arg_trampoline (gpointer arg, gpointer addr) { gpointer res; + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_domain_get ()); + #ifdef MONO_ARCH_HAVE_FTNPTR_ARG_TRAMPOLINE if (mono_aot_only) res = mono_aot_get_ftnptr_arg_trampoline (arg, addr); else - res = mono_arch_get_ftnptr_arg_trampoline (arg, addr); + res = mono_arch_get_ftnptr_arg_trampoline (mem_manager, arg, addr); #else - if (mono_aot_only) + if (mono_aot_only) { res = mono_aot_get_static_rgctx_trampoline (arg, addr); - else - res = mono_arch_get_static_rgctx_trampoline (arg, addr); + } else { + res = mono_arch_get_static_rgctx_trampoline (mem_manager, arg, addr); + } #endif return res; @@ -1324,11 +1329,12 @@ mono_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, M { gpointer code; guint32 len; + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (domain); if (mono_aot_only) code = mono_aot_create_specific_trampoline (arg1, tramp_type, domain, &len); else - code = mono_arch_create_specific_trampoline (arg1, tramp_type, domain, &len); + code = mono_arch_create_specific_trampoline (arg1, tramp_type, mem_manager, &len); mono_lldb_save_specific_trampoline_info (arg1, tramp_type, domain, code, len); if (code_len) *code_len = len; diff --git a/mono/mini/mini-x86.c b/mono/mini/mini-x86.c index e717acdec85..d3cdf7f0c43 100644 --- a/mono/mini/mini-x86.c +++ b/mono/mini/mini-x86.c @@ -5549,10 +5549,12 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTC } size += item->chunk_size; } - if (fail_tramp) - code = (guint8*)mono_method_alloc_generic_virtual_trampoline (domain, size); - else - code = mono_domain_code_reserve (domain, size); + if (fail_tramp) { + code = (guint8*)mono_method_alloc_generic_virtual_trampoline (mono_domain_ambient_memory_manager (domain), size); + } else { + MonoMemoryManager *mem_manager = m_class_get_mem_manager (domain, vtable->klass); + code = mono_mem_manager_code_reserve (mem_manager, size); + } start = code; unwind_ops = mono_arch_get_cie_program (); diff --git a/mono/mini/mini.h b/mono/mini/mini.h index b5570f94e4a..5ac9f1b8be2 100644 --- a/mono/mini/mini.h +++ b/mono/mini/mini.h @@ -2477,8 +2477,8 @@ void mono_arch_create_vars (MonoCompile *cfg); void mono_arch_save_unwind_info (MonoCompile *cfg); void mono_arch_register_lowlevel_calls (void); gpointer mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr); -gpointer mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr); -gpointer mono_arch_get_ftnptr_arg_trampoline (gpointer arg, gpointer addr); +gpointer mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr); +gpointer mono_arch_get_ftnptr_arg_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr); gpointer mono_arch_get_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *method, int vt_offset); gpointer mono_arch_get_gsharedvt_arg_trampoline (MonoDomain *domain, gpointer arg, gpointer addr); void mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr); @@ -2488,7 +2488,7 @@ int mono_arch_get_this_arg_reg (guint8 *code); gpointer mono_arch_get_this_arg_from_call (host_mgreg_t *regs, guint8 *code); gpointer mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target); gpointer mono_arch_get_delegate_virtual_invoke_impl (MonoMethodSignature *sig, MonoMethod *method, int offset, gboolean load_imt_reg); -gpointer mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len); +gpointer mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len); MonoMethod* mono_arch_find_imt_method (host_mgreg_t *regs, guint8 *code); MonoVTable* mono_arch_find_static_call_vtable (host_mgreg_t *regs, guint8 *code); gpointer mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckItem **imt_entries, int count, gpointer fail_tramp); diff --git a/mono/mini/tramp-amd64-gsharedvt.c b/mono/mini/tramp-amd64-gsharedvt.c index c426c064953..3b3a894e439 100644 --- a/mono/mini/tramp-amd64-gsharedvt.c +++ b/mono/mini/tramp-amd64-gsharedvt.c @@ -170,10 +170,11 @@ gpointer mono_arch_get_gsharedvt_arg_trampoline (MonoDomain *domain, gpointer arg, gpointer addr) { guint8 *code, *start; + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (domain); const int buf_len = 32; - start = code = mono_domain_code_reserve (domain, buf_len); + start = code = mono_mem_manager_code_reserve (mem_manager, buf_len); amd64_mov_reg_imm (code, AMD64_RAX, arg); amd64_jump_code (code, addr); diff --git a/mono/mini/tramp-amd64.c b/mono/mini/tramp-amd64.c index 80df1225fae..2dae6161b9d 100644 --- a/mono/mini/tramp-amd64.c +++ b/mono/mini/tramp-amd64.c @@ -61,12 +61,12 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) guint8 *code, *start; GSList *unwind_ops; const int size = 20; - MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); const int this_reg = mono_arch_get_this_arg_reg (NULL); - start = code = (guint8 *)mono_domain_code_reserve (domain, size + MONO_TRAMPOLINE_UNWINDINFO_SIZE(0)); + start = code = (guint8 *)mono_mem_manager_code_reserve (mem_manager, size + MONO_TRAMPOLINE_UNWINDINFO_SIZE(0)); unwind_ops = mono_arch_get_cie_program (); @@ -91,12 +91,11 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) * Create a trampoline which sets RGCTX_REG to ARG, then jumps to ADDR. */ gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { guint8 *code, *start; GSList *unwind_ops; int buf_len; - MonoDomain *domain = mono_domain_get (); #ifdef MONO_ARCH_NOMAP32BIT @@ -109,7 +108,7 @@ mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) buf_len = 30; #endif - start = code = (guint8 *)mono_domain_code_reserve (domain, buf_len + MONO_TRAMPOLINE_UNWINDINFO_SIZE(0)); + start = code = (guint8 *)mono_mem_manager_code_reserve (mem_manager, buf_len + MONO_TRAMPOLINE_UNWINDINFO_SIZE(0)); unwind_ops = mono_arch_get_cie_program (); @@ -169,8 +168,9 @@ mono_arch_patch_callsite (guint8 *method_start, guint8 *orig_code, guint8 *addr) * This might happen with LLVM or when calling AOTed code. Create a thunk. */ guint8 *thunk_start, *thunk_code; + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_domain_get ()); - thunk_start = thunk_code = (guint8 *)mono_domain_code_reserve (mono_domain_get (), 32); + thunk_start = thunk_code = (guint8 *)mono_mem_manager_code_reserve (mem_manager, 32); amd64_jump_membase (thunk_code, AMD64_RIP, 0); *(guint64*)thunk_code = (guint64)addr; addr = thunk_start; @@ -205,8 +205,10 @@ mono_arch_create_llvm_native_thunk (MonoDomain *domain, guint8 *addr) * FIXME: Avoid this if possible if !MONO_ARCH_NOMAP32BIT and ADDR is 32 bits. */ guint8 *thunk_start, *thunk_code; + // FIXME: Has to be an argument + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (domain); - thunk_start = thunk_code = (guint8 *)mono_domain_code_reserve (mono_domain_get (), 32); + thunk_start = thunk_code = (guint8 *)mono_mem_manager_code_reserve (mem_manager, 32); amd64_jump_membase (thunk_code, AMD64_RIP, 0); *(guint64*)thunk_code = (guint64)addr; addr = thunk_start; @@ -583,7 +585,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf } gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { guint8 *code, *buf, *tramp; int size; @@ -596,7 +598,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty else size = 5 + 1 + 8; - code = buf = (guint8 *)mono_domain_code_reserve_align (domain, size, 1); + code = buf = (guint8 *)mono_mem_manager_code_reserve_align (mem_manager, size, 1); if (((gint64)tramp - (gint64)code) >> 31 != 0 && ((gint64)tramp - (gint64)code) >> 31 != -1) { #ifndef MONO_ARCH_NOMAP32BIT @@ -604,7 +606,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty #endif far_addr = TRUE; size += 16; - code = buf = (guint8 *)mono_domain_code_reserve_align (domain, size, 1); + code = buf = (guint8 *)mono_mem_manager_code_reserve_align (mem_manager, size, 1); } if (far_addr) { @@ -717,7 +719,8 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR, GUINT_TO_POINTER (slot)); amd64_jump_reg (code, AMD64_R11); } else { - tramp = (guint8 *)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL); + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_get_root_domain ()); + tramp = (guint8 *)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mem_manager, NULL); /* jump to the actual trampoline */ amd64_jump_code (code, tramp); @@ -1237,7 +1240,7 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { g_assert_not_reached (); return NULL; @@ -1258,7 +1261,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf } gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { g_assert_not_reached (); return NULL; diff --git a/mono/mini/tramp-arm.c b/mono/mini/tramp-arm.c index e9eb94ba827..e6c35e98f1a 100644 --- a/mono/mini/tramp-arm.c +++ b/mono/mini/tramp-arm.c @@ -445,7 +445,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf #define SPEC_TRAMP_SIZE 24 gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { guint8 *code, *buf, *tramp; guint32 *constants; @@ -454,14 +454,12 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty tramp = mono_get_trampoline_code (tramp_type); - if (domain) { - mono_domain_lock (domain); - code = buf = mono_domain_code_reserve_align (domain, size, 4); + if (mem_manager) { + code = buf = mono_mem_manager_code_reserve_align (mem_manager, size, 4); if ((short_branch = branch_for_target_reachable (code + 4, tramp))) { size = 12; - mono_domain_code_commit (domain, code, SPEC_TRAMP_SIZE, size); + mono_mem_manager_code_commit (mem_manager, code, SPEC_TRAMP_SIZE, size); } - mono_domain_unlock (domain); } else { code = buf = mono_global_codeman_reserve (size); short_branch = FALSE; @@ -523,10 +521,11 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) { guint8 *code, *start; MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); GSList *unwind_ops; guint32 size = 16; - start = code = mono_domain_code_reserve (domain, size); + start = code = mono_mem_manager_code_reserve (mem_manager, size); unwind_ops = mono_arch_get_cie_program (); @@ -547,14 +546,14 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { guint8 *code, *start; GSList *unwind_ops; int buf_len = 16; MonoDomain *domain = mono_domain_get (); - start = code = mono_domain_code_reserve (domain, buf_len); + start = code = mono_mem_manager_code_reserve (mem_manager, buf_len); unwind_ops = mono_arch_get_cie_program (); @@ -577,14 +576,14 @@ mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) /* Same as static rgctx trampoline, but clobbering ARMREG_IP, which is scratch */ gpointer -mono_arch_get_ftnptr_arg_trampoline (gpointer arg, gpointer addr) +mono_arch_get_ftnptr_arg_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { guint8 *code, *start; GSList *unwind_ops; int buf_len = 16; MonoDomain *domain = mono_domain_get (); - start = code = mono_domain_code_reserve (domain, buf_len); + start = code = mono_mem_manager_code_reserve (mem_manager, buf_len); unwind_ops = mono_arch_get_cie_program (); @@ -702,7 +701,8 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info code += 4; ARM_LDR_REG_REG (code, ARMREG_PC, ARMREG_PC, ARMREG_R1); } else { - tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), &code_len); + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_get_root_domain ()); + tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mem_manager, &code_len); /* Jump to the actual trampoline */ ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0); /* temp reg */ @@ -1029,7 +1029,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf } gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { g_assert_not_reached (); return NULL; @@ -1043,14 +1043,14 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { g_assert_not_reached (); return NULL; } gpointer -mono_arch_get_ftnptr_arg_trampoline (gpointer arg, gpointer addr) +mono_arch_get_ftnptr_arg_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { g_assert_not_reached (); return NULL; @@ -1171,10 +1171,11 @@ mono_arch_get_gsharedvt_arg_trampoline (MonoDomain *domain, gpointer arg, gpoint guint8 *code, *buf; int buf_len; gpointer *constants; + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (domain); buf_len = 24; - buf = code = mono_domain_code_reserve (domain, buf_len); + buf = code = mono_mem_manager_code_reserve (mem_manager, buf_len); /* Similar to the specialized trampoline code */ ARM_PUSH (code, (1 << ARMREG_R0) | (1 << ARMREG_R1) | (1 << ARMREG_R2) | (1 << ARMREG_R3) | (1 << ARMREG_LR)); diff --git a/mono/mini/tramp-arm64.c b/mono/mini/tramp-arm64.c index 7b889a3ffde..cab924cf773 100644 --- a/mono/mini/tramp-arm64.c +++ b/mono/mini/tramp-arm64.c @@ -318,7 +318,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf } gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { guint8 *code, *buf, *tramp; int buf_len = 64; @@ -329,7 +329,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty */ tramp = mono_get_trampoline_code (tramp_type); - buf = code = mono_domain_code_reserve (domain, buf_len); + buf = code = mono_mem_manager_code_reserve (mem_manager, buf_len); MINI_BEGIN_CODEGEN (); @@ -354,8 +354,9 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) guint8 *code, *start; guint32 size = 32; MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); - start = code = mono_domain_code_reserve (domain, size); + start = code = mono_mem_manager_code_reserve (mem_manager, size); MINI_BEGIN_CODEGEN (); @@ -371,13 +372,13 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { guint8 *code, *start; guint32 buf_len = 32; MonoDomain *domain = mono_domain_get (); - start = code = mono_domain_code_reserve (domain, buf_len); + start = code = mono_mem_manager_code_reserve (mem_manager, buf_len); MINI_BEGIN_CODEGEN (); @@ -476,7 +477,8 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info if (aot) { code = mono_arm_emit_aotconst (&ji, code, buf, ARMREG_IP0, MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR, GUINT_TO_POINTER (slot)); } else { - tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), &code_len); + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_get_root_domain ()); + tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mem_manager, &code_len); code = mono_arm_emit_imm64 (code, ARMREG_IP0, (guint64)tramp); } arm_brx (code, ARMREG_IP0); @@ -828,7 +830,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf } gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { g_assert_not_reached (); return NULL; @@ -842,7 +844,7 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { g_assert_not_reached (); return NULL; diff --git a/mono/mini/tramp-mips.c b/mono/mini/tramp-mips.c index 28431067820..82be944a7a9 100644 --- a/mono/mini/tramp-mips.c +++ b/mono/mini/tramp-mips.c @@ -42,8 +42,9 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) { guint8 *code, *start; MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); - start = code = mono_domain_code_reserve (domain, 20); + start = code = mono_mem_manager_code_reserve (mem_manager, 20); mips_load (code, mips_t9, addr); /* The this pointer is kept in a0 */ @@ -279,13 +280,13 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf } gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { guint8 *code, *buf, *tramp; tramp = mono_get_trampoline_code (tramp_type); - code = buf = mono_domain_code_reserve (domain, 32); + code = buf = mono_mem_manager_code_reserve (domain, 32); /* Prepare the jump to the generic trampoline code * mono_arch_create_trampoline_code() knows we're putting this in t8 @@ -310,16 +311,15 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { guint8 *code, *start; int buf_len; - MonoDomain *domain = mono_domain_get (); buf_len = 24; - start = code = mono_domain_code_reserve (domain, buf_len); + start = code = mono_mem_manager_code_reserve (mem_manager, buf_len); mips_load (code, MONO_ARCH_RGCTX_REG, arg); mips_load (code, mips_at, addr); @@ -431,7 +431,8 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info mips_jr (code, mips_at); mips_nop (code); } else { - tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), &code_len); + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_get_root_domain ()); + tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mem_manager, &code_len); mips_load (code, mips_at, tramp); mips_jr (code, mips_at); mips_nop (code); diff --git a/mono/mini/tramp-ppc.c b/mono/mini/tramp-ppc.c index 5e603b67d1d..d1b6929a521 100644 --- a/mono/mini/tramp-ppc.c +++ b/mono/mini/tramp-ppc.c @@ -83,17 +83,16 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) int this_pos = 3; guint32 short_branch; MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); int size = MONO_PPC_32_64_CASE (20, 32) + PPC_FTNPTR_SIZE; addr = mono_get_addr_from_ftnptr (addr); - mono_domain_lock (domain); - start = code = mono_domain_code_reserve (domain, size); + start = code = mono_mem_manager_code_reserve (mem_manager, size); code = mono_ppc_create_pre_code_ftnptr (code); short_branch = branch_for_target_reachable (code + 4, (guint8*)addr); if (short_branch) - mono_domain_code_commit (domain, code, size, 8); - mono_domain_unlock (domain); + mono_mem_manager_code_commit (mem_manager, code, size, 8); if (short_branch) { ppc_addi (code, this_pos, this_pos, MONO_ABI_SIZEOF (MonoObject)); @@ -121,7 +120,7 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) * Create a trampoline which sets RGCTX_REG to ARG, then jumps to ADDR. */ gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { guint8 *code, *start, *p; guint8 imm_buf [128]; @@ -137,13 +136,11 @@ mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) ppc_load_ptr (p, MONO_ARCH_RGCTX_REG, arg); imm_size = p - imm_buf; - mono_domain_lock (domain); - start = code = mono_domain_code_reserve (domain, size); + start = code = mono_mem_manager_code_reserve (mem_manager, size); code = mono_ppc_create_pre_code_ftnptr (code); short_branch = branch_for_target_reachable (code + imm_size, (guint8*)addr); if (short_branch) - mono_domain_code_commit (domain, code, size, imm_size + 4); - mono_domain_unlock (domain); + mono_mem_manager_code_commit (mem_manager, code, size, imm_size + 4); if (short_branch) { ppc_load_ptr (code, MONO_ARCH_RGCTX_REG, arg); @@ -493,23 +490,21 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf #define TRAMPOLINE_SIZE (MONO_PPC_32_64_CASE (24, (5+5+1+1)*4)) gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { guint8 *code, *buf, *tramp; guint32 short_branch; tramp = mono_get_trampoline_code (tramp_type); - mono_domain_lock (domain); - code = buf = mono_domain_code_reserve_align (domain, TRAMPOLINE_SIZE, 4); + code = buf = mono_mem_manager_code_reserve_align (mem_manager, TRAMPOLINE_SIZE, 4); short_branch = branch_for_target_reachable (code + MONO_PPC_32_64_CASE (8, 5*4), tramp); #ifdef __mono_ppc64__ /* FIXME: make shorter if possible */ #else if (short_branch) - mono_domain_code_commit (domain, code, TRAMPOLINE_SIZE, 12); + mono_mem_manager_code_commit (mem_manager, code, TRAMPOLINE_SIZE, 12); #endif - mono_domain_unlock (domain); if (short_branch) { ppc_load_sequence (code, ppc_r0, (target_mgreg_t)(gsize) arg1); @@ -646,8 +641,9 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info ppc_mtctr (code, ppc_r12); ppc_bcctr (code, PPC_BR_ALWAYS, 0); } else { + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_get_root_domain ()); tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), - MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL); + MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mem_manager, NULL); /* jump to the actual trampoline */ code = emit_trampoline_jump (code, tramp); diff --git a/mono/mini/tramp-riscv.c b/mono/mini/tramp-riscv.c index d58d8e46f19..37960dac6f7 100644 --- a/mono/mini/tramp-riscv.c +++ b/mono/mini/tramp-riscv.c @@ -77,9 +77,9 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf gpointer mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, - MonoDomain *domain, guint32 *code_len) + MonoMemoryManager *mem_manager, guint32 *code_len) { - guint8 *buf = mono_domain_code_reserve (domain, 64), *code = buf; + guint8 *buf = mono_mem_manager_code_reserve (mem_manager, 64), *code = buf; guint8 *tramp = mono_get_trampoline_code (tramp_type); // Pass the argument in scratch t0. @@ -98,7 +98,9 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty gpointer mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) { - guint8 *buf = mono_domain_code_reserve (mono_domain_get (), 64), *code = buf; + MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); + guint8 *buf = mono_mem_manager_code_reserve (mem_manager, 64), *code = buf; // Pass the argument in a0. code = mono_riscv_emit_imm (code, RISCV_A0, sizeof (MonoObject)); @@ -120,9 +122,10 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { - guint8 *buf = mono_domain_code_reserve (mono_domain_get (), 64), *code = buf; + MonoDomain *domain = mono_domain_get (); + guint8 *buf = mono_mem_manager_code_reserve (mem_manager, 64), *code = buf; // Pass the argument in the RGCTX register. code = mono_riscv_emit_imm (code, MONO_ARCH_RGCTX_REG, (gsize) arg); @@ -233,7 +236,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf gpointer mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, - MonoDomain *domain, guint32 *code_len) + MonoMemoryManager *mem_manager, guint32 *code_len) { g_assert_not_reached (); return NULL; @@ -256,7 +259,7 @@ mono_arch_build_imt_trampoline (MonoVTable *vtable, MonoDomain *domain, } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { g_assert_not_reached (); return NULL; diff --git a/mono/mini/tramp-s390x.c b/mono/mini/tramp-s390x.c index 2e068dda65d..40cf0bb431e 100644 --- a/mono/mini/tramp-s390x.c +++ b/mono/mini/tramp-s390x.c @@ -103,9 +103,10 @@ mono_arch_get_unbox_trampoline (MonoMethod *method, gpointer addr) guint8 *code, *start; int this_pos = s390_r2; MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); char trampName[128]; - start = code = mono_domain_code_reserve (domain, 28); + start = code = mono_mem_manager_code_reserve (mem_manager, 28); S390_SET (code, s390_r1, addr); s390_aghi (code, this_pos, MONO_ABI_SIZEOF (MonoObject)); @@ -549,7 +550,7 @@ mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg) /*------------------------------------------------------------------*/ gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { guint8 *code, *buf, *tramp; gint32 displace; @@ -561,7 +562,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty /* purpose is to provide the generic part with the */ /* MonoMethod *method pointer. We'll use r1 to keep it. */ /*----------------------------------------------------------*/ - code = buf = mono_domain_code_reserve (domain, SPECIFIC_TRAMPOLINE_SIZE); + code = buf = mono_mem_manager_code_reserve (mem_manager, SPECIFIC_TRAMPOLINE_SIZE); S390_SET (buf, s390_r1, arg1); displace = (tramp - buf) / 2; @@ -680,8 +681,9 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info s390_lgr (code, MONO_ARCH_VTABLE_REG, s390_r2); #endif + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_get_root_domain ()); tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), - MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL); + MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mem_manager, NULL); /* jump to the actual trampoline */ displace = (tramp - code) / 2; @@ -711,17 +713,16 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info /*------------------------------------------------------------------*/ gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { guint8 *code, *start; gint32 displace; int buf_len; - MonoDomain *domain = mono_domain_get (); buf_len = 32; - start = code = mono_domain_code_reserve (domain, buf_len); + start = code = mono_mem_manager_code_reserve (mem_manager, buf_len); S390_SET (code, MONO_ARCH_RGCTX_REG, arg); displace = ((uintptr_t) addr - (uintptr_t) code) / 2; diff --git a/mono/mini/tramp-sparc.c b/mono/mini/tramp-sparc.c index 02228625363..21580e53e90 100644 --- a/mono/mini/tramp-sparc.c +++ b/mono/mini/tramp-sparc.c @@ -34,10 +34,12 @@ gpointer mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) { + MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); guint8 *code, *start; int reg; - start = code = mono_domain_code_reserve (mono_domain_get (), 36); + start = code = mono_mem_manager_code_reserve (mem_manager, 36); /* This executes in the context of the caller, hence o0 */ sparc_add_imm (code, 0, sparc_o0, MONO_ABI_SIZEOF (MonoObject), sparc_o0); @@ -225,13 +227,13 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf #define TRAMPOLINE_SIZE (SPARC_SET_MAX_SIZE + 3) gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { guint32 *code, *buf, *tramp; tramp = mono_get_trampoline_code (tramp_type); - code = buf = mono_domain_code_reserve (domain, TRAMPOLINE_SIZE * 4); + code = buf = mono_mem_manager_code_reserve (mem_manager, TRAMPOLINE_SIZE * 4); /* We have to use g5 here because there is no other free register */ sparc_set (code, tramp, sparc_g5); diff --git a/mono/mini/tramp-wasm.c b/mono/mini/tramp-wasm.c index 61e75291892..37253239fee 100644 --- a/mono/mini/tramp-wasm.c +++ b/mono/mini/tramp-wasm.c @@ -10,7 +10,7 @@ mono_wasm_specific_trampoline (void) } gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { return (gpointer)mono_wasm_specific_trampoline; } @@ -47,7 +47,7 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { g_error (__func__); return NULL; diff --git a/mono/mini/tramp-x86.c b/mono/mini/tramp-x86.c index 10900c8113d..7d41eabdae8 100644 --- a/mono/mini/tramp-x86.c +++ b/mono/mini/tramp-x86.c @@ -44,9 +44,10 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) guint8 *code, *start; int this_pos = 4, size = 16; MonoDomain *domain = mono_domain_get (); + MonoMemoryManager *mem_manager = m_method_get_mem_manager (domain, m); GSList *unwind_ops; - start = code = mono_domain_code_reserve (domain, size); + start = code = mono_mem_manager_code_reserve (mem_manager, size); unwind_ops = mono_arch_get_cie_program (); @@ -62,16 +63,15 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) } gpointer -mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr) +mono_arch_get_static_rgctx_trampoline (MonoMemoryManager *mem_manager, gpointer arg, gpointer addr) { guint8 *code, *start; GSList *unwind_ops; - MonoDomain *domain = mono_domain_get (); const int buf_len = 10; - start = code = mono_domain_code_reserve (domain, buf_len); + start = code = mono_mem_manager_code_reserve (mem_manager, buf_len); unwind_ops = mono_arch_get_cie_program (); @@ -399,7 +399,7 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf #define TRAMPOLINE_SIZE 10 gpointer -mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoMemoryManager *mem_manager, guint32 *code_len) { guint8 *code, *buf, *tramp; @@ -407,7 +407,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty const int size = TRAMPOLINE_SIZE; - code = buf = mono_domain_code_reserve_align (domain, size, 4); + code = buf = mono_mem_manager_code_reserve_align (mem_manager, size, 4); x86_push_imm (buf, (gsize)arg1); x86_jump_code (buf, tramp); @@ -501,7 +501,8 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR, GUINT_TO_POINTER (slot)); x86_jump_reg (code, X86_EAX); } else { - tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL); + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (mono_get_root_domain ()); + tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mem_manager, NULL); /* jump to the actual trampoline */ x86_jump_code (code, tramp); @@ -599,10 +600,11 @@ mono_arch_get_gsharedvt_arg_trampoline (MonoDomain *domain, gpointer arg, gpoint { guint8 *code, *start; GSList *unwind_ops; + MonoMemoryManager *mem_manager = mono_domain_ambient_memory_manager (domain); const int buf_len = 10; - start = code = mono_domain_code_reserve (domain, buf_len); + start = code = mono_mem_manager_code_reserve (mem_manager, buf_len); unwind_ops = mono_arch_get_cie_program (); -- 2.11.4.GIT