static gpointer
get_real_call_filter (void)
{
static gpointer filter;
static gboolean inited = FALSE;
guint8 *start;
Ia64CodegenState code;
int in0, local0, out0, nout;
unw_dyn_info_t *di;
unw_dyn_region_info_t *r_pro, *r_body, *r_epilog;
if (inited)
return filter;
start = mono_global_codeman_reserve (1024);
/* int call_filter (guint64 fp, guint64 ip) */
/*
* We have to create a register+stack frame similar to the frame which
* contains the filter.
* - setting fp
* - setting up a register stack frame
* These cannot be set up in this function, because the fp register is a
* stacked register which is different in each method. Also, the register
* stack frame is different in each method. So we pass the FP value in a a
* non-stacked register and the code generated by the OP_START_HANDLER
* opcode will copy it to the appropriate register after setting up the
* register stack frame.
* The stacked registers are not need to be set since variables used in
* handler regions are never allocated to registers.
*/
in0 = 32;
local0 = in0 + 2;
out0 = local0 + 4;
nout = 0;
ia64_codegen_init (code, start);
ia64_codegen_set_one_ins_per_bundle (code, TRUE);
ia64_unw_save_reg (code, UNW_IA64_AR_PFS, UNW_IA64_GR + local0 + 0);
ia64_alloc (code, local0 + 0, local0 - in0, out0 - local0, nout, 0);
ia64_unw_save_reg (code, UNW_IA64_RP, UNW_IA64_GR + local0 + 1);
ia64_mov_from_br (code, local0 + 1, IA64_B0);
ia64_begin_bundle (code);
r_pro = mono_ia64_create_unwind_region (&code);
/* Frame pointer */
ia64_mov (code, IA64_R15, in0 + 0);
/* Target ip */
ia64_mov_to_br (code, IA64_B6, in0 + 1);
/* Call the filter */
ia64_br_call_reg (code, IA64_B0, IA64_B6);
/* R8 contains the result of the filter */
/* FIXME: Add unwind info for this */
ia64_begin_bundle (code);
r_body = mono_ia64_create_unwind_region (&code);
r_pro->next = r_body;
ia64_mov_to_ar_i (code, IA64_PFS, local0 + 0);
ia64_mov_ret_to_br (code, IA64_B0, local0 + 1);
ia64_br_ret_reg (code, IA64_B0);
ia64_begin_bundle (code);
r_epilog = mono_ia64_create_unwind_region (&code);
r_body->next = r_epilog;
ia64_codegen_set_one_ins_per_bundle (code, FALSE);
ia64_codegen_close (code);
g_assert ((code.buf - start) <= 256);
mono_arch_flush_icache (start, code.buf - start);
di = g_malloc0 (sizeof (unw_dyn_info_t));
di->start_ip = (unw_word_t) start;
di->end_ip = (unw_word_t) code.buf;
di->gp = 0;
di->format = UNW_INFO_FORMAT_DYNAMIC;
di->u.pi.name_ptr = (unw_word_t)"throw_trampoline";
di->u.pi.regions = r_body;
_U_dyn_register (di);
filter = ia64_create_ftnptr (start);
inited = TRUE;
return filter;
}
guchar*
mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
{
guint8 *buf, *tramp;
int i, offset, saved_regs_offset, saved_fpregs_offset, last_offset, framesize;
int in0, local0, out0, l0, l1, l2, l3, l4, l5, l6, l7, l8, o0, o1, o2, o3;
gboolean has_caller;
Ia64CodegenState code;
unw_dyn_info_t *di;
unw_dyn_region_info_t *r_pro;
g_assert (!aot);
*info = NULL;
/*
* Since jump trampolines are not patched, this trampoline is executed every
* time a call is made to a jump trampoline. So we try to keep things faster
* in that case.
*/
if (tramp_type == MONO_TRAMPOLINE_JUMP)
has_caller = FALSE;
else
has_caller = TRUE;
buf = mono_global_codeman_reserve (2048);
ia64_codegen_init (code, buf);
/* Stacked Registers */
in0 = 32;
local0 = in0 + 8;
out0 = local0 + 16;
l0 = 40;
l1 = 41;
l2 = 42;
l3 = 43;
l4 = 44;
l5 = 45; /* saved ar.pfs */
l6 = 46; /* arg */
l7 = 47; /* code */
l8 = 48; /* saved sp */
o0 = out0 + 0; /* regs */
o1 = out0 + 1; /* code */
o2 = out0 + 2; /* arg */
o3 = out0 + 3; /* tramp */
framesize = (128 * 8) + 1024;
framesize = (framesize + (MONO_ARCH_FRAME_ALIGNMENT - 1)) & ~ (MONO_ARCH_FRAME_ALIGNMENT - 1);
/*
* Allocate a new register+memory stack frame.
* 8 input registers (the max used by the ABI)
* 16 locals
* 4 output (number of parameters passed to trampoline)
*/
ia64_unw_save_reg (code, UNW_IA64_AR_PFS, UNW_IA64_GR + l5);
ia64_alloc (code, l5, local0 - in0, out0 - local0, 4, 0);
ia64_unw_save_reg (code, UNW_IA64_SP, UNW_IA64_GR + l8);
ia64_mov (code, l8, IA64_SP);
ia64_adds_imm (code, IA64_SP, (-framesize), IA64_SP);
offset = 16; /* scratch area */
/* Save the argument received from the specific trampoline */
ia64_mov (code, l6, GP_SCRATCH_REG);
/* Save the calling address */
ia64_unw_save_reg (code, UNW_IA64_RP, UNW_IA64_GR + local0 + 7);
ia64_mov_from_br (code, l7, IA64_B0);
/* Create unwind info for the prolog */
ia64_begin_bundle (code);
r_pro = mono_ia64_create_unwind_region (&code);
/* Save registers */
/* Not needed for jump trampolines */
if (tramp_type != MONO_TRAMPOLINE_JUMP) {
saved_regs_offset = offset;
offset += 128 * 8;
/*
* Only the registers which are needed for computing vtable slots need
* to be saved.
*/
last_offset = -1;
for (i = 0; i < 64; ++i)
if ((1 << i) & MONO_ARCH_CALLEE_REGS) {
if (last_offset != i * 8)
ia64_adds_imm (code, l1, saved_regs_offset + (i * 8), IA64_SP);
ia64_st8_spill_inc_imm_hint (code, l1, i, 8, 0);
last_offset = (i + 1) * 8;
}
}
/* Save fp registers */
saved_fpregs_offset = offset;
offset += 8 * 8;
ia64_adds_imm (code, l1, saved_fpregs_offset, IA64_SP);
for (i = 0; i < 8; ++i)
ia64_stfd_inc_imm_hint (code, l1, i + 8, 8, 0);
g_assert (offset < framesize);
/* Arg1 is the pointer to the saved registers */
ia64_adds_imm (code, o0, saved_regs_offset, IA64_SP);
/* Arg2 is the address of the calling code */
if (has_caller)
ia64_mov (code, o1, l7);
else
ia64_mov (code, o1, 0);
/* Arg3 is the method/vtable ptr */
ia64_mov (code, o2, l6);
/* Arg4 is the trampoline address */
/* FIXME: */
ia64_mov (code, o3, 0);
tramp = (guint8*)mono_get_trampoline_func (tramp_type);
/* Call the trampoline using an indirect call */
ia64_movl (code, l0, tramp);
ia64_ld8_inc_imm (code, l1, l0, 8);
ia64_mov_to_br (code, IA64_B6, l1);
ia64_ld8 (code, IA64_GP, l0);
ia64_br_call_reg (code, 0, IA64_B6);
/* Check for thread interruption */
/* This is not perf critical code so no need to check the interrupt flag */
ia64_mov (code, l2, IA64_R8);
tramp = (guint8*)mono_thread_force_interruption_checkpoint;
ia64_movl (code, l0, tramp);
ia64_ld8_inc_imm (code, l1, l0, 8);
ia64_mov_to_br (code, IA64_B6, l1);
ia64_ld8 (code, IA64_GP, l0);
ia64_br_call_reg (code, 0, IA64_B6);
ia64_mov (code, IA64_R8, l2);
/* Restore fp regs */
ia64_adds_imm (code, l1, saved_fpregs_offset, IA64_SP);
for (i = 0; i < 8; ++i)
ia64_ldfd_inc_imm (code, i + 8, l1, 8);
/* FIXME: Handle NATs in fp regs / scratch regs */
if (tramp_type != MONO_TRAMPOLINE_CLASS_INIT) {
/* Load method address from function descriptor */
ia64_ld8 (code, l0, IA64_R8);
ia64_mov_to_br (code, IA64_B6, l0);
}
/* Clean up register/memory stack frame */
ia64_adds_imm (code, IA64_SP, framesize, IA64_SP);
ia64_mov_to_ar_i (code, IA64_PFS, l5);
if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT) {
ia64_mov_ret_to_br (code, IA64_B0, l7);
ia64_br_ret_reg (code, IA64_B0);
}
else {
/* Call the compiled method */
ia64_mov_to_br (code, IA64_B0, l7);
ia64_br_cond_reg (code, IA64_B6);
}
ia64_codegen_close (code);
g_assert ((code.buf - buf) <= 2048);
/* FIXME: emit unwind info for epilog */
di = g_malloc0 (sizeof (unw_dyn_info_t));
di->start_ip = (unw_word_t) buf;
di->end_ip = (unw_word_t) code.buf;
di->gp = 0;
di->format = UNW_INFO_FORMAT_DYNAMIC;
di->u.pi.name_ptr = (unw_word_t)"ia64_generic_trampoline";
di->u.pi.regions = r_pro;
_U_dyn_register (di);
mono_arch_flush_icache (buf, code.buf - buf);
return buf;
}
