void
mono_arch_patch_callsite (guint8 *method_start, guint8 *orig_code, guint8 *addr)
{
guint8 *code;
guint8 buf [8];
gboolean can_write = mono_breakpoint_clean_code (method_start, orig_code, 8, buf, sizeof (buf));
code = buf + 8;
/* go to the start of the call instruction
*
* address_byte = (m << 6) | (o << 3) | reg
* call opcode: 0xff address_byte displacement
* 0xff m=1,o=2 imm8
* 0xff m=2,o=2 imm32
*/
code -= 6;
orig_code -= 6;
if (code [1] == 0xe8) {
if (can_write) {
mono_atomic_xchg_i32 ((gint32*)(orig_code + 2), (guint)addr - ((guint)orig_code + 1) - 5);
/* Tell valgrind to recompile the patched code */
VALGRIND_DISCARD_TRANSLATIONS (orig_code + 2, 4);
}
} else if (code [1] == 0xe9) {
/* A PLT entry: jmp <DISP> */
if (can_write)
mono_atomic_xchg_i32 ((gint32*)(orig_code + 2), (guint)addr - ((guint)orig_code + 1) - 5);
} else {
printf ("Invalid trampoline sequence: %x %x %x %x %x %x %x\n", code [0], code [1], code [2], code [3],
code [4], code [5], code [6]);
g_assert_not_reached ();
}
}
/*
* mono_x86_throw_exception:
*
* C function called from the throw trampolines.
*/
void
mono_x86_throw_exception (mgreg_t *regs, MonoObject *exc,
mgreg_t eip, gboolean rethrow)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
if (!restore_context)
restore_context = mono_get_restore_context ();
ctx.esp = regs [X86_ESP];
ctx.eip = eip;
ctx.ebp = regs [X86_EBP];
ctx.edi = regs [X86_EDI];
ctx.esi = regs [X86_ESI];
ctx.ebx = regs [X86_EBX];
ctx.edx = regs [X86_EDX];
ctx.ecx = regs [X86_ECX];
ctx.eax = regs [X86_EAX];
#ifdef __APPLE__
/* The OSX ABI specifies 16 byte alignment at call sites */
g_assert ((ctx.esp % MONO_ARCH_FRAME_ALIGNMENT) == 0);
#endif
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
if (mono_debug_using_mono_debugger ()) {
guint8 buf [16], *code;
mono_breakpoint_clean_code (NULL, (gpointer)eip, 8, buf, sizeof (buf));
code = buf + 8;
if (buf [3] == 0xe8) {
MonoContext ctx_cp = ctx;
ctx_cp.eip = eip - 5;
if (mono_debugger_handle_exception (&ctx_cp, exc)) {
restore_context (&ctx_cp);
g_assert_not_reached ();
}
}
}
/* adjust eip so that it point into the call instruction */
ctx.eip -= 1;
mono_handle_exception (&ctx, exc);
restore_context (&ctx);
g_assert_not_reached ();
}
/*
* The first few arguments are dummy, to force the other arguments to be passed on
* the stack, this avoids overwriting the argument registers in the throw trampoline.
*/
void
mono_amd64_throw_exception (guint64 dummy1, guint64 dummy2, guint64 dummy3, guint64 dummy4,
guint64 dummy5, guint64 dummy6,
mgreg_t *regs, mgreg_t rip,
MonoObject *exc, gboolean rethrow)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
if (!restore_context)
restore_context = mono_get_restore_context ();
ctx.rsp = regs [AMD64_RSP];
ctx.rip = rip;
ctx.rbx = regs [AMD64_RBX];
ctx.rbp = regs [AMD64_RBP];
ctx.r12 = regs [AMD64_R12];
ctx.r13 = regs [AMD64_R13];
ctx.r14 = regs [AMD64_R14];
ctx.r15 = regs [AMD64_R15];
ctx.rdi = regs [AMD64_RDI];
ctx.rsi = regs [AMD64_RSI];
ctx.rax = regs [AMD64_RAX];
ctx.rcx = regs [AMD64_RCX];
ctx.rdx = regs [AMD64_RDX];
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
if (mono_debug_using_mono_debugger ()) {
guint8 buf [16];
mono_breakpoint_clean_code (NULL, (gpointer)rip, 8, buf, sizeof (buf));
if (buf [3] == 0xe8) {
MonoContext ctx_cp = ctx;
ctx_cp.rip = rip - 5;
if (mono_debugger_handle_exception (&ctx_cp, exc)) {
restore_context (&ctx_cp);
g_assert_not_reached ();
}
}
}
/* adjust eip so that it point into the call instruction */
ctx.rip -= 1;
mono_handle_exception (&ctx, exc);
restore_context (&ctx);
g_assert_not_reached ();
}
