#include <mono/metadata/monitor.h>
#include <mono/arch/amd64/amd64-codegen.h>
-#ifdef HAVE_VALGRIND_MEMCHECK_H
-#include <valgrind/memcheck.h>
-#endif
+#include <mono/utils/memcheck.h>
#include "mini.h"
#include "mini-amd64.h"
if (code [-5] != 0xe8) {
if (can_write) {
InterlockedExchangePointer ((gpointer*)(orig_code - 11), addr);
-#ifdef HAVE_VALGRIND_MEMCHECK_H
VALGRIND_DISCARD_TRANSLATIONS (orig_code - 11, sizeof (gpointer));
-#endif
}
} else {
if ((((guint64)(addr)) >> 32) != 0) {
g_assert ((((guint64)(orig_code)) >> 32) == 0);
if (can_write) {
InterlockedExchange ((gint32*)(orig_code - 4), ((gint64)addr - (gint64)orig_code));
-#ifdef HAVE_VALGRIND_MEMCHECK_H
VALGRIND_DISCARD_TRANSLATIONS (orig_code - 5, 4);
-#endif
}
}
}
gpointer *got_entry = (gpointer*)((guint8*)orig_code + (*(guint32*)(orig_code - 4)));
if (can_write) {
InterlockedExchangePointer (got_entry, addr);
-#ifdef HAVE_VALGRIND_MEMCHECK_H
VALGRIND_DISCARD_TRANSLATIONS (orig_code - 5, sizeof (gpointer));
-#endif
}
}
}
if (!can_write)
return;
- code -= 3;
-
/*
* A given byte sequence can match more than case here, so we have to be
* really careful about the ordering of the cases. Longer sequences
gpointer *vtable_slot;
/* call *<OFFSET>(%rip) */
- vtable_slot = mono_get_vcall_slot_addr (code + 3, regs);
+ vtable_slot = mono_get_vcall_slot_addr (code, regs);
g_assert (vtable_slot);
*vtable_slot = nullified_class_init_trampoline;
buf [4] = 0x90;
*/
- mono_arch_patch_callsite (code - 2, code - 2 + 5, nullified_class_init_trampoline);
- } else if ((buf [4] == 0x41) && (buf [5] == 0xff)) {
- /* call <REG> */
- /* happens on machines without MAP_32BIT like freebsd */
- /* amd64_set_reg_template is 10 bytes long */
- guint8* buf = code - 10;
-
- /* FIXME: Make this thread safe */
- /* Padding code suggested by the AMD64 Opt Manual */
- buf [0] = 0x66;
- buf [1] = 0x66;
- buf [2] = 0x66;
- buf [3] = 0x90;
- buf [4] = 0x66;
- buf [5] = 0x66;
- buf [6] = 0x66;
- buf [7] = 0x90;
- buf [8] = 0x66;
- buf [9] = 0x66;
- buf [10] = 0x90;
- buf [11] = 0x66;
- buf [12] = 0x90;
+ mono_arch_patch_callsite (code - 5, code, nullified_class_init_trampoline);
+ } else if ((buf [5] == 0xff) && x86_modrm_mod (buf [6]) == 3 && x86_modrm_reg (buf [6]) == 2) {
+ /* call *<reg> */
+ /* Generated by the LLVM JIT or on platforms without MAP_32BIT set */
+ mono_arch_patch_callsite (code - 13, code, nullified_class_init_trampoline);
} else if (buf [4] == 0x90 || buf [5] == 0xeb || buf [6] == 0x66) {
/* Already changed by another thread */
;
mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
{
if (mono_aot_only && !nullified_class_init_trampoline)
- nullified_class_init_trampoline = mono_aot_get_named_code ("nullified_class_init_trampoline");
+ nullified_class_init_trampoline = mono_aot_get_trampoline ("nullified_class_init_trampoline");
mono_arch_patch_plt_entry (code, NULL, regs, nullified_class_init_trampoline);
}
guchar*
-mono_arch_create_trampoline_code (MonoTrampolineType tramp_type)
-{
- MonoJumpInfo *ji;
- guint32 code_size;
- guchar *code;
- GSList *unwind_ops, *l;
-
- code = mono_arch_create_trampoline_code_full (tramp_type, &code_size, &ji, &unwind_ops, FALSE);
-
- mono_save_trampoline_xdebug_info ("<generic_trampoline>", code, code_size, unwind_ops);
-
- for (l = unwind_ops; l; l = l->next)
- g_free (l->data);
- g_slist_free (unwind_ops);
-
- return code;
-}
-
-guchar*
-mono_arch_create_trampoline_code_full (MonoTrampolineType tramp_type, guint32 *code_size, MonoJumpInfo **ji, GSList **out_unwind_ops, gboolean aot)
+mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
{
guint8 *buf, *code, *tramp, *br [2], *r11_save_code, *after_r11_save_code;
- int i, lmf_offset, offset, res_offset, arg_offset, rax_offset, tramp_offset, saved_regs_offset;
+ int i, lmf_offset, offset, res_offset, arg_offset, rax_offset, tramp_offset;
+ int buf_len, saved_regs_offset;
int saved_fpregs_offset, rbp_offset, framesize, orig_rsp_to_rbp_offset, cfa_offset;
gboolean has_caller;
GSList *unwind_ops = NULL;
+ MonoJumpInfo *ji = NULL;
if (tramp_type == MONO_TRAMPOLINE_JUMP)
has_caller = FALSE;
else
has_caller = TRUE;
- code = buf = mono_global_codeman_reserve (538);
-
- *ji = NULL;
+ buf_len = 548;
+ code = buf = mono_global_codeman_reserve (buf_len);
framesize = 538 + sizeof (MonoLMF);
framesize = (framesize + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~ (MONO_ARCH_FRAME_ALIGNMENT - 1);
amd64_mov_membase_reg (code, AMD64_RBP, lmf_offset + G_STRUCT_OFFSET (MonoLMF, r15), AMD64_R15, 8);
if (aot) {
- *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_get_lmf_addr");
- amd64_mov_reg_membase (code, AMD64_R11, AMD64_RIP, 0, 8);
+ code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_get_lmf_addr");
} else {
amd64_mov_reg_imm (code, AMD64_R11, mono_get_lmf_addr);
}
if (aot) {
char *icall_name = g_strdup_printf ("trampoline_func_%d", tramp_type);
- *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, icall_name);
- amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RIP, 0, 8);
+ code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, icall_name);
} else {
tramp = (guint8*)mono_get_trampoline_func (tramp_type);
- amd64_mov_reg_imm (code, AMD64_RAX, tramp);
+ amd64_mov_reg_imm (code, AMD64_R11, tramp);
}
- amd64_call_reg (code, AMD64_RAX);
+ amd64_call_reg (code, AMD64_R11);
/* Check for thread interruption */
/* This is not perf critical code so no need to check the interrupt flag */
*/
amd64_mov_membase_reg (code, AMD64_RBP, res_offset, AMD64_RAX, 8);
if (aot) {
- *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_thread_force_interruption_checkpoint");
- amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RIP, 0, 8);
+ code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_thread_force_interruption_checkpoint");
} else {
- amd64_mov_reg_imm (code, AMD64_RAX, (guint8*)mono_thread_force_interruption_checkpoint);
+ amd64_mov_reg_imm (code, AMD64_R11, (guint8*)mono_thread_force_interruption_checkpoint);
}
- amd64_call_reg (code, AMD64_RAX);
+ amd64_call_reg (code, AMD64_R11);
+
amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RBP, res_offset, 8);
/* Restore LMF */
*/
amd64_mov_membase_reg (code, AMD64_RBP, rax_offset, AMD64_RAX, 8);
- /* Restore argument registers, r10 (needed to pass rgctx to
- static shared generic methods), r11 (imt register for
- interface calls), and rax (needed for direct calls to C vararg functions). */
+ /* Restore argument registers, r10 (imt method/rgxtx)
+ and rax (needed for direct calls to C vararg functions). */
for (i = 0; i < AMD64_NREG; ++i)
- if (AMD64_IS_ARGUMENT_REG (i) || i == AMD64_R10 || i == AMD64_R11 || i == AMD64_RAX)
+ if (AMD64_IS_ARGUMENT_REG (i) || i == AMD64_R10 || i == AMD64_RAX)
amd64_mov_reg_membase (code, i, AMD64_RBP, saved_regs_offset + (i * 8), 8);
for (i = 0; i < 8; ++i)
amd64_jump_membase (code, AMD64_RSP, rax_offset - 0x8);
}
- g_assert ((code - buf) <= 538);
+ g_assert ((code - buf) <= buf_len);
mono_arch_flush_icache (buf, code - buf);
- *code_size = code - buf;
-
if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT) {
- guint32 code_len;
-
/* Initialize the nullified class init trampoline used in the AOT case */
- nullified_class_init_trampoline = mono_arch_get_nullified_class_init_trampoline (&code_len);
+ nullified_class_init_trampoline = mono_arch_get_nullified_class_init_trampoline (NULL);
}
- *out_unwind_ops = unwind_ops;
-
+ if (info)
+ *info = mono_tramp_info_create (mono_get_generic_trampoline_name (tramp_type), buf, code - buf, ji, unwind_ops);
+
return buf;
}
gpointer
-mono_arch_get_nullified_class_init_trampoline (guint32 *code_len)
+mono_arch_get_nullified_class_init_trampoline (MonoTrampInfo **info)
{
guint8 *code, *buf;
mono_arch_flush_icache (buf, code - buf);
- *code_len = code - buf;
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf ("nullified_class_init_trampoline"), buf, code - buf, NULL, NULL);
return buf;
}
}
gpointer
-mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot)
-{
- guint32 code_size;
- MonoJumpInfo *ji;
-
- return mono_arch_create_rgctx_lazy_fetch_trampoline_full (slot, &code_size, &ji, FALSE);
-}
-
-gpointer
-mono_arch_create_rgctx_lazy_fetch_trampoline_full (guint32 slot, guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
{
guint8 *tramp;
guint8 *code, *buf;
int depth, index;
int i;
gboolean mrgctx;
-
- *ji = NULL;
+ MonoJumpInfo *ji = NULL;
+ GSList *unwind_ops = NULL;
mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
index = MONO_RGCTX_SLOT_INDEX (slot);
code = buf = mono_global_codeman_reserve (tramp_size);
+ unwind_ops = mono_arch_get_cie_program ();
+
rgctx_null_jumps = g_malloc (sizeof (guint8*) * (depth + 2));
if (mrgctx) {
amd64_mov_reg_reg (code, MONO_ARCH_VTABLE_REG, AMD64_ARG_REG1, 8);
if (aot) {
- *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot));
- amd64_mov_reg_membase (code, AMD64_R11, AMD64_RIP, 0, 8);
+ code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot));
amd64_jump_reg (code, AMD64_R11);
} else {
tramp = mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
g_assert (code - buf <= tramp_size);
- *code_size = code - buf;
+ if (info)
+ *info = mono_tramp_info_create (mono_get_rgctx_fetch_trampoline_name (slot), buf, code - buf, ji, unwind_ops);
return buf;
}
gpointer
-mono_arch_create_generic_class_init_trampoline (void)
-{
- guint32 code_size;
- MonoJumpInfo *ji;
-
- return mono_arch_create_generic_class_init_trampoline_full (&code_size, &ji, FALSE);
-}
-
-gpointer
-mono_arch_create_generic_class_init_trampoline_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_create_generic_class_init_trampoline (MonoTrampInfo **info, gboolean aot)
{
guint8 *tramp;
guint8 *code, *buf;
static guint8 bitmask;
guint8 *jump;
int tramp_size;
-
- *ji = NULL;
+ GSList *unwind_ops = NULL;
+ MonoJumpInfo *ji = NULL;
tramp_size = 64;
x86_patch (jump, code);
if (aot) {
- *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_generic_class_init");
- amd64_mov_reg_membase (code, AMD64_R11, AMD64_RIP, 0, 8);
+ code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_generic_class_init");
amd64_jump_reg (code, AMD64_R11);
} else {
tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_GENERIC_CLASS_INIT, mono_get_root_domain (), NULL);
g_assert (code - buf <= tramp_size);
- *code_size = code - buf;
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf ("generic_class_init_trampoline"), buf, code - buf, ji, unwind_ops);
return buf;
}
#ifdef MONO_ARCH_MONITOR_OBJECT_REG
gpointer
-mono_arch_create_monitor_enter_trampoline (void)
-{
- guint32 code_size;
- MonoJumpInfo *ji;
-
- return mono_arch_create_monitor_enter_trampoline_full (&code_size, &ji, FALSE);
-}
-
-gpointer
-mono_arch_create_monitor_enter_trampoline_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_create_monitor_enter_trampoline (MonoTrampInfo **info, gboolean aot)
{
-
guint8 *tramp;
guint8 *code, *buf;
guint8 *jump_obj_null, *jump_sync_null, *jump_cmpxchg_failed, *jump_other_owner, *jump_tid;
int tramp_size;
int owner_offset, nest_offset, dummy;
-
- *ji = NULL;
+ MonoJumpInfo *ji = NULL;
+ GSList *unwind_ops = NULL;
g_assert (MONO_ARCH_MONITOR_OBJECT_REG == AMD64_RDI);
#endif
if (aot) {
- *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_monitor_enter");
- amd64_mov_reg_membase (code, AMD64_R11, AMD64_RIP, 0, 8);
+ code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_monitor_enter");
amd64_jump_reg (code, AMD64_R11);
} else {
tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_MONITOR_ENTER, mono_get_root_domain (), NULL);
mono_arch_flush_icache (code, code - buf);
g_assert (code - buf <= tramp_size);
- *code_size = code - buf;
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf ("monitor_enter_trampoline"), buf, code - buf, ji, unwind_ops);
return buf;
}
gpointer
-mono_arch_create_monitor_exit_trampoline (void)
-{
- guint32 code_size;
- MonoJumpInfo *ji;
-
- return mono_arch_create_monitor_exit_trampoline_full (&code_size, &ji, FALSE);
-}
-
-gpointer
-mono_arch_create_monitor_exit_trampoline_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_create_monitor_exit_trampoline (MonoTrampInfo **info, gboolean aot)
{
guint8 *tramp;
guint8 *code, *buf;
- guint8 *jump_obj_null, *jump_have_waiters;
+ guint8 *jump_obj_null, *jump_have_waiters, *jump_sync_null, *jump_not_owned;
guint8 *jump_next;
int tramp_size;
int owner_offset, nest_offset, entry_count_offset;
-
- *ji = NULL;
+ MonoJumpInfo *ji = NULL;
+ GSList *unwind_ops = NULL;
g_assert (MONO_ARCH_MONITOR_OBJECT_REG == AMD64_RDI);
amd64_mov_reg_membase (code, AMD64_RCX, AMD64_RDI, G_STRUCT_OFFSET (MonoObject, synchronisation), 8);
/* is synchronization null? */
amd64_test_reg_reg (code, AMD64_RCX, AMD64_RCX);
- /* if not, jump to next case */
- jump_next = code;
- amd64_branch8 (code, X86_CC_NZ, -1, 1);
- /* if yes, just return */
- amd64_ret (code);
+ /* if yes, jump to actual trampoline */
+ jump_sync_null = code;
+ amd64_branch8 (code, X86_CC_Z, -1, 1);
/* next case: synchronization is not null */
- x86_patch (jump_next, code);
/* load MonoInternalThread* into RDX */
code = mono_amd64_emit_tls_get (code, AMD64_RDX, mono_thread_get_tls_offset ());
/* load TID into RDX */
amd64_mov_reg_membase (code, AMD64_RDX, AMD64_RDX, G_STRUCT_OFFSET (MonoInternalThread, tid), 8);
/* is synchronization->owner == TID */
amd64_alu_membase_reg_size (code, X86_CMP, AMD64_RCX, owner_offset, AMD64_RDX, 8);
- /* if yes, jump to next case */
- jump_next = code;
- amd64_branch8 (code, X86_CC_Z, -1, 1);
- /* if not, just return */
- amd64_ret (code);
+ /* if no, jump to actual trampoline */
+ jump_not_owned = code;
+ amd64_branch8 (code, X86_CC_NZ, -1, 1);
/* next case: synchronization->owner == TID */
- x86_patch (jump_next, code);
/* is synchronization->nest == 1 */
amd64_alu_membase_imm_size (code, X86_CMP, AMD64_RCX, nest_offset, 1, 4);
/* if not, jump to next case */
x86_patch (jump_obj_null, code);
x86_patch (jump_have_waiters, code);
+ x86_patch (jump_not_owned, code);
+ x86_patch (jump_sync_null, code);
}
/* jump to the actual trampoline */
#endif
if (aot) {
- *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_monitor_exit");
- amd64_mov_reg_membase (code, AMD64_R11, AMD64_RIP, 0, 8);
+ code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_monitor_exit");
amd64_jump_reg (code, AMD64_R11);
} else {
tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_MONITOR_EXIT, mono_get_root_domain (), NULL);
mono_arch_flush_icache (code, code - buf);
g_assert (code - buf <= tramp_size);
- *code_size = code - buf;
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf ("monitor_exit_trampoline"), buf, code - buf, ji, unwind_ops);
return buf;
}
x86_push_imm (code, (guint64)func_arg);
amd64_call_reg (code, AMD64_R11);
}
+
+/*
+ * mono_arch_get_call_target:
+ *
+ * Return the address called by the code before CODE if exists.
+ */
+guint8*
+mono_arch_get_call_target (guint8 *code)
+{
+ if (code [-5] == 0xe8) {
+ guint32 disp = *(guint32*)(code - 4);
+ guint8 *target = code + disp;
+
+ return target;
+ } else {
+ return NULL;
+ }
+}
+
+/*
+ * mono_arch_get_plt_info_offset:
+ *
+ * Return the PLT info offset belonging to the plt entry PLT_ENTRY.
+ */
+guint32
+mono_arch_get_plt_info_offset (guint8 *plt_entry, mgreg_t *regs, guint8 *code)
+{
+ return *(guint32*)(plt_entry + 6);
+}
projects / mono.git / blobdiff