/*
* get_throw_exception:
*
* Generate a call to mono_x86_throw_exception/
* mono_x86_throw_corlib_exception.
* If LLVM is true, generate code which assumes the caller is LLVM generated code,
* which doesn't push the arguments.
*/
static guint8*
get_throw_exception (const char *name, gboolean rethrow, gboolean llvm, gboolean corlib)
{
guint8 *start, *code;
GSList *unwind_ops = NULL;
int i, stack_size, stack_offset, arg_offsets [5], regs_offset;
start = code = mono_global_codeman_reserve (128);
stack_size = 128;
/*
* On apple, the stack is misaligned by the pushing of the return address.
*/
if (!llvm && corlib)
/* On OSX, we don't generate alignment code to save space */
stack_size += 4;
else
stack_size += MONO_ARCH_FRAME_ALIGNMENT - 4;
/*
* The stack looks like this:
* <pc offset> (only if corlib is TRUE)
* <exception object>/<type token>
* <return addr> <- esp (unaligned on apple)
*/
mono_add_unwind_op_def_cfa (unwind_ops, (guint8*)NULL, (guint8*)NULL, X86_ESP, 4);
mono_add_unwind_op_offset (unwind_ops, (guint8*)NULL, (guint8*)NULL, X86_NREG, -4);
/* Alloc frame */
x86_alu_reg_imm (code, X86_SUB, X86_ESP, stack_size);
mono_add_unwind_op_def_cfa_offset (unwind_ops, code, start, stack_size + 4);
arg_offsets [0] = 0;
arg_offsets [1] = 4;
arg_offsets [2] = 8;
arg_offsets [3] = 12;
regs_offset = 16;
/* Save registers */
for (i = 0; i < X86_NREG; ++i)
if (i != X86_ESP)
x86_mov_membase_reg (code, X86_ESP, regs_offset + (i * 4), i, 4);
/* Calculate the offset between the current sp and the sp of the caller */
if (llvm) {
/* LLVM doesn't push the arguments */
stack_offset = stack_size + 4;
} else {
if (corlib) {
/* Two arguments */
stack_offset = stack_size + 4 + 8;
#ifdef __APPLE__
/* We don't generate stack alignment code on osx to save space */
#endif
} else {
/* One argument */
stack_offset = stack_size + 4 + 4;
#ifdef __APPLE__
/* Pop the alignment added by OP_THROW too */
stack_offset += MONO_ARCH_FRAME_ALIGNMENT - 4;
#endif
}
}
/* Save ESP */
x86_lea_membase (code, X86_EAX, X86_ESP, stack_offset);
x86_mov_membase_reg (code, X86_ESP, regs_offset + (X86_ESP * 4), X86_EAX, 4);
/* Set arg1 == regs */
x86_lea_membase (code, X86_EAX, X86_ESP, regs_offset);
x86_mov_membase_reg (code, X86_ESP, arg_offsets [0], X86_EAX, 4);
/* Set arg2 == exc */
x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size + 4, 4);
x86_mov_membase_reg (code, X86_ESP, arg_offsets [1], X86_EAX, 4);
/* Set arg3 == eip */
x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size, 4);
x86_mov_membase_reg (code, X86_ESP, arg_offsets [2], X86_EAX, 4);
if (corlib) {
/* Set arg4 == offset */
x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size + 8, 4);
x86_mov_membase_reg (code, X86_ESP, arg_offsets [3], X86_EAX, 4);
} else {
/* Set arg4 == rethrow */
x86_mov_membase_imm (code, X86_ESP, arg_offsets [3], rethrow, 4);
}
/* Make the call */
x86_call_code (code, corlib ? (gpointer)mono_x86_throw_corlib_exception : (gpointer)mono_x86_throw_exception);
x86_breakpoint (code);
g_assert ((code - start) < 128);
mono_save_trampoline_xdebug_info (corlib ? "llvm_throw_corlib_exception_trampoline" : "llvm_throw_exception_trampoline", start, code - start, unwind_ops);
return start;
}
/*
* get_throw_trampoline:
*
* Generate a call to mono_x86_throw_exception/
* mono_x86_throw_corlib_exception.
* If LLVM is true, generate code which assumes the caller is LLVM generated code,
* which doesn't push the arguments.
*/
static guint8*
get_throw_trampoline (const char *name, gboolean rethrow, gboolean llvm, gboolean corlib, gboolean llvm_abs, gboolean resume_unwind, MonoTrampInfo **info, gboolean aot)
{
guint8 *start, *code;
int i, stack_size, stack_offset, arg_offsets [5], regs_offset;
MonoJumpInfo *ji = NULL;
GSList *unwind_ops = NULL;
guint kMaxCodeSize = NACL_SIZE (128, 256);
start = code = mono_global_codeman_reserve (kMaxCodeSize);
stack_size = 128;
/*
* On apple, the stack is misaligned by the pushing of the return address.
*/
if (!llvm && corlib)
/* On OSX, we don't generate alignment code to save space */
stack_size += 4;
else
stack_size += MONO_ARCH_FRAME_ALIGNMENT - 4;
/*
* The stack looks like this:
* <pc offset> (only if corlib is TRUE)
* <exception object>/<type token>
* <return addr> <- esp (unaligned on apple)
*/
mono_add_unwind_op_def_cfa (unwind_ops, (guint8*)NULL, (guint8*)NULL, X86_ESP, 4);
mono_add_unwind_op_offset (unwind_ops, (guint8*)NULL, (guint8*)NULL, X86_NREG, -4);
/* Alloc frame */
x86_alu_reg_imm (code, X86_SUB, X86_ESP, stack_size);
mono_add_unwind_op_def_cfa_offset (unwind_ops, code, start, stack_size + 4);
arg_offsets [0] = 0;
arg_offsets [1] = 4;
arg_offsets [2] = 8;
arg_offsets [3] = 12;
regs_offset = 16;
/* Save registers */
for (i = 0; i < X86_NREG; ++i)
if (i != X86_ESP)
x86_mov_membase_reg (code, X86_ESP, regs_offset + (i * 4), i, 4);
/* Calculate the offset between the current sp and the sp of the caller */
if (llvm) {
/* LLVM doesn't push the arguments */
stack_offset = stack_size + 4;
} else {
if (corlib) {
/* Two arguments */
stack_offset = stack_size + 4 + 8;
#ifdef __APPLE__
/* We don't generate stack alignment code on osx to save space */
#endif
} else {
/* One argument + stack alignment */
stack_offset = stack_size + 4 + 4;
#ifdef __APPLE__
/* Pop the alignment added by OP_THROW too */
stack_offset += MONO_ARCH_FRAME_ALIGNMENT - 4;
#else
if (mono_do_x86_stack_align)
stack_offset += MONO_ARCH_FRAME_ALIGNMENT - 4;
#endif
}
}
/* Save ESP */
x86_lea_membase (code, X86_EAX, X86_ESP, stack_offset);
x86_mov_membase_reg (code, X86_ESP, regs_offset + (X86_ESP * 4), X86_EAX, 4);
/* Set arg1 == regs */
x86_lea_membase (code, X86_EAX, X86_ESP, regs_offset);
x86_mov_membase_reg (code, X86_ESP, arg_offsets [0], X86_EAX, 4);
/* Set arg2 == exc/ex_token_index */
if (resume_unwind)
x86_mov_reg_imm (code, X86_EAX, 0);
else
x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size + 4, 4);
x86_mov_membase_reg (code, X86_ESP, arg_offsets [1], X86_EAX, 4);
/* Set arg3 == eip */
if (llvm_abs)
x86_alu_reg_reg (code, X86_XOR, X86_EAX, X86_EAX);
else
x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size, 4);
x86_mov_membase_reg (code, X86_ESP, arg_offsets [2], X86_EAX, 4);
/* Set arg4 == rethrow/pc_offset */
if (resume_unwind) {
x86_mov_membase_imm (code, X86_ESP, arg_offsets [3], 0, 4);
} else if (corlib) {
x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size + 8, 4);
if (llvm_abs) {
/*
* The caller is LLVM code which passes the absolute address not a pc offset,
* so compensate by passing 0 as 'ip' and passing the negated abs address as
* the pc offset.
*/
x86_neg_reg (code, X86_EAX);
}
x86_mov_membase_reg (code, X86_ESP, arg_offsets [3], X86_EAX, 4);
} else {
x86_mov_membase_imm (code, X86_ESP, arg_offsets [3], rethrow, 4);
}
/* Make the call */
if (aot) {
// This can be called from runtime code, which can't guarantee that
// ebx contains the got address.
// So emit the got address loading code too
code = mono_arch_emit_load_got_addr (start, code, NULL, &ji);
code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, corlib ? "mono_x86_throw_corlib_exception" : "mono_x86_throw_exception");
x86_call_reg (code, X86_EAX);
} else {
x86_call_code (code, resume_unwind ? (gpointer)(mono_x86_resume_unwind) : (corlib ? (gpointer)mono_x86_throw_corlib_exception : (gpointer)mono_x86_throw_exception));
}
x86_breakpoint (code);
nacl_global_codeman_validate(&start, kMaxCodeSize, &code);
g_assert ((code - start) < kMaxCodeSize);
if (info)
*info = mono_tramp_info_create (name, start, code - start, ji, unwind_ops);
else {
GSList *l;
for (l = unwind_ops; l; l = l->next)
g_free (l->data);
g_slist_free (unwind_ops);
}
return start;
}
/*
* get_throw_trampoline:
*
* Generate a call to mono_amd64_throw_exception/
* mono_amd64_throw_corlib_exception.
*/
static gpointer
get_throw_trampoline (MonoTrampInfo **info, gboolean rethrow, gboolean corlib, gboolean llvm_abs, gboolean resume_unwind, const char *tramp_name, gboolean aot)
{
guint8* start;
guint8 *code;
MonoJumpInfo *ji = NULL;
GSList *unwind_ops = NULL;
int i, stack_size, arg_offsets [16], ctx_offset, regs_offset, dummy_stack_space;
const guint kMaxCodeSize = NACL_SIZE (256, 512);
#ifdef TARGET_WIN32
dummy_stack_space = 6 * sizeof(mgreg_t); /* Windows expects stack space allocated for all 6 dummy args. */
#else
dummy_stack_space = 0;
#endif
start = code = (guint8 *)mono_global_codeman_reserve (kMaxCodeSize);
/* The stack is unaligned on entry */
stack_size = ALIGN_TO (sizeof (MonoContext) + 64 + dummy_stack_space, MONO_ARCH_FRAME_ALIGNMENT) + 8;
code = start;
if (info)
unwind_ops = mono_arch_get_cie_program ();
/* Alloc frame */
amd64_alu_reg_imm (code, X86_SUB, AMD64_RSP, stack_size);
if (info)
mono_add_unwind_op_def_cfa_offset (unwind_ops, code, start, stack_size + 8);
/*
* To hide linux/windows calling convention differences, we pass all arguments on
* the stack by passing 6 dummy values in registers.
*/
arg_offsets [0] = dummy_stack_space + 0;
arg_offsets [1] = dummy_stack_space + sizeof(mgreg_t);
arg_offsets [2] = dummy_stack_space + sizeof(mgreg_t) * 2;
ctx_offset = dummy_stack_space + sizeof(mgreg_t) * 4;
regs_offset = ctx_offset + MONO_STRUCT_OFFSET (MonoContext, gregs);
/* Save registers */
for (i = 0; i < AMD64_NREG; ++i)
if (i != AMD64_RSP)
amd64_mov_membase_reg (code, AMD64_RSP, regs_offset + (i * sizeof(mgreg_t)), i, sizeof(mgreg_t));
/* Save RSP */
amd64_lea_membase (code, AMD64_RAX, AMD64_RSP, stack_size + sizeof(mgreg_t));
amd64_mov_membase_reg (code, AMD64_RSP, regs_offset + (AMD64_RSP * sizeof(mgreg_t)), X86_EAX, sizeof(mgreg_t));
/* Save IP */
amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RSP, stack_size, sizeof(mgreg_t));
amd64_mov_membase_reg (code, AMD64_RSP, regs_offset + (AMD64_RIP * sizeof(mgreg_t)), AMD64_RAX, sizeof(mgreg_t));
/* Set arg1 == ctx */
amd64_lea_membase (code, AMD64_RAX, AMD64_RSP, ctx_offset);
amd64_mov_membase_reg (code, AMD64_RSP, arg_offsets [0], AMD64_RAX, sizeof(mgreg_t));
/* Set arg2 == exc/ex_token_index */
if (resume_unwind)
amd64_mov_membase_imm (code, AMD64_RSP, arg_offsets [1], 0, sizeof(mgreg_t));
else
amd64_mov_membase_reg (code, AMD64_RSP, arg_offsets [1], AMD64_ARG_REG1, sizeof(mgreg_t));
/* Set arg3 == rethrow/pc offset */
if (resume_unwind) {
amd64_mov_membase_imm (code, AMD64_RSP, arg_offsets [2], 0, sizeof(mgreg_t));
} else if (corlib) {
if (llvm_abs)
/*
* The caller doesn't pass in a pc/pc offset, instead we simply use the
* caller ip. Negate the pc adjustment done in mono_amd64_throw_corlib_exception ().
*/
amd64_mov_membase_imm (code, AMD64_RSP, arg_offsets [2], 1, sizeof(mgreg_t));
else
amd64_mov_membase_reg (code, AMD64_RSP, arg_offsets [2], AMD64_ARG_REG2, sizeof(mgreg_t));
} else {
amd64_mov_membase_imm (code, AMD64_RSP, arg_offsets [2], rethrow, sizeof(mgreg_t));
}
if (aot) {
const char *icall_name;
if (resume_unwind)
icall_name = "mono_amd64_resume_unwind";
else if (corlib)
icall_name = "mono_amd64_throw_corlib_exception";
else
icall_name = "mono_amd64_throw_exception";
ji = mono_patch_info_list_prepend (ji, code - start, MONO_PATCH_INFO_JIT_ICALL_ADDR, icall_name);
amd64_mov_reg_membase (code, AMD64_R11, AMD64_RIP, 0, 8);
} else {
amd64_mov_reg_imm (code, AMD64_R11, resume_unwind ? ((gpointer)mono_amd64_resume_unwind) : (corlib ? (gpointer)mono_amd64_throw_corlib_exception : (gpointer)mono_amd64_throw_exception));
}
amd64_call_reg (code, AMD64_R11);
amd64_breakpoint (code);
mono_arch_flush_icache (start, code - start);
g_assert ((code - start) < kMaxCodeSize);
nacl_global_codeman_validate(&start, kMaxCodeSize, &code);
mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
if (info)
*info = mono_tramp_info_create (tramp_name, start, code - start, ji, unwind_ops);
return start;
}
