#define NOT_IMPLEMENTED g_assert_not_reached ()
#define GP_SCRATCH_REG 31
+#define GP_SCRATCH_REG2 30
/*
- * get_unbox_trampoline:
+ * mono_arch_get_unbox_trampoline:
* @m: method pointer
* @addr: pointer to native code for @m
*
* this argument. This method returns a pointer to a trampoline which does
* unboxing before calling the method
*/
-static gpointer
-get_unbox_trampoline (MonoMethod *m, gpointer addr)
+gpointer
+mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr)
{
guint8 *buf;
gpointer func_addr, func_gp;
return desc;
}
-/**
- * ia64_magic_trampoline:
- */
-static gpointer
-ia64_magic_trampoline (long *regs, guint8 *code, MonoMethod *m, guint8* tramp)
+void
+mono_arch_patch_callsite (guint8 *code, guint8 *addr)
{
- gpointer addr;
- gpointer *vtable_slot;
+ guint8 *callsite_begin;
+ guint64 *callsite = (guint64*)(gpointer)(code - 16);
+ guint64 instructions [3];
+ guint64 buf [16];
+ Ia64CodegenState gen;
+ gpointer func = ((gpointer*)(gpointer)addr)[0];
+
+ while ((ia64_bundle_template (callsite) != IA64_TEMPLATE_MLX) &&
+ (ia64_bundle_template (callsite) != IA64_TEMPLATE_MLXS))
+ callsite -= 2;
+ callsite_begin = (guint8*)callsite;
+
+ /* Patch the code generated by emit_call */
+
+ instructions [0] = ia64_bundle_ins1 (callsite);
+ instructions [1] = ia64_bundle_ins2 (callsite);
+ instructions [2] = ia64_bundle_ins3 (callsite);
+
+ ia64_codegen_init (gen, (guint8*)buf);
+ ia64_movl (gen, GP_SCRATCH_REG, func);
+ instructions [1] = gen.instructions [0];
+ instructions [2] = gen.instructions [1];
+
+ ia64_codegen_init (gen, (guint8*)buf);
+ ia64_emit_bundle_template (&gen, ia64_bundle_template (callsite), instructions [0], instructions [1], instructions [2]);
+ ia64_codegen_close (gen);
+
+ /* This might not be safe, but not all itanium processors support st16 */
+ callsite [0] = buf [0];
+ callsite [1] = buf [1];
+
+ mono_arch_flush_icache (callsite_begin, code - callsite_begin);
+}
- addr = mono_compile_method (m);
- g_assert (addr);
+void
+mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+{
+ guint8 *callsite_begin;
+ guint64 *callsite = (guint64*)(gpointer)(code - 16);
+ guint64 instructions [3];
+ guint64 buf [16];
+ Ia64CodegenState gen;
- //printf ("ENTER: %s\n", mono_method_full_name (m, TRUE));
+ while ((ia64_bundle_template (callsite) != IA64_TEMPLATE_MLX) &&
+ (ia64_bundle_template (callsite) != IA64_TEMPLATE_MLXS))
+ callsite -= 2;
+ callsite_begin = (guint8*)callsite;
- /* the method was jumped to */
- if (!code)
- /* FIXME: Optimize the case when the call is from a delegate wrapper */
- return addr;
+ /* Replace the code generated by emit_call with a sets of nops */
- vtable_slot = mono_arch_get_vcall_slot_addr (code, (gpointer*)regs);
+ /* The first bundle might have other instructions in it */
+ instructions [0] = ia64_bundle_ins1 (callsite);
+ instructions [1] = IA64_NOP_X;
+ instructions [2] = IA64_NOP_X;
- if (vtable_slot) {
- if (m->klass->valuetype)
- addr = get_unbox_trampoline (m, addr);
+ ia64_codegen_init (gen, (guint8*)buf);
+ ia64_emit_bundle_template (&gen, ia64_bundle_template (callsite), instructions [0], instructions [1], instructions [2]);
+ ia64_codegen_close (gen);
- g_assert (*vtable_slot);
+ /* This might not be safe, but not all itanium processors support st16 */
+ callsite [0] = buf [0];
+ callsite [1] = buf [1];
- if (mono_aot_is_got_entry (code, (guint8*)vtable_slot) || mono_domain_owns_vtable_slot (mono_domain_get (), vtable_slot))
- *vtable_slot = addr;
- }
- else {
- /* FIXME: Patch calling code */
- }
+ callsite += 2;
- return addr;
-}
+ /* The other bundles can be full replaced with nops */
-/*
- * ia64_aot_trampoline:
- *
- * This trampoline handles calls made from AOT code. We try to bypass the
- * normal JIT compilation logic to avoid loading the metadata for the method.
- */
-static gpointer
-ia64_aot_trampoline (long *regs, guint8 *code, guint8 *token_info,
- guint8* tramp)
-{
- NOT_IMPLEMENTED;
+ ia64_codegen_init (gen, (guint8*)buf);
+ ia64_emit_bundle_template (&gen, IA64_TEMPLATE_MII, IA64_NOP_M, IA64_NOP_I, IA64_NOP_I);
+ ia64_codegen_close (gen);
- return NULL;
+ while ((guint8*)callsite < code) {
+ callsite [0] = buf [0];
+ callsite [1] = buf [1];
+ callsite += 2;
+ }
+
+ mono_arch_flush_icache (callsite_begin, code - callsite_begin);
}
-/**
- * ia64_class_init_trampoline:
- *
- * This method calls mono_runtime_class_init () to run the static constructor
- * for the type, then patches the caller code so it is not called again.
- */
-static void
-ia64_class_init_trampoline (long *regs, guint8 *code, MonoVTable *vtable, guint8 *tramp)
+void
+mono_arch_patch_delegate_trampoline (guint8 *code, guint8 *tramp, gssize *regs, guint8 *addr)
{
- mono_runtime_class_init (vtable);
-
- /* FIXME: Patch calling code */
+ /*
+ * This is called by the code generated by OP_CALL_REG:
+ * ld8 r30=[r8],8
+ * nop.i 0x0;;
+ * mov.sptk b6=r30
+ * ld8 r1=[r8]
+ * br.call.sptk.few b0=b6
+ */
+
+ /* We patch the function descriptor instead of delegate->method_ptr */
+ //g_assert (((gpointer*)(regs [8] - 8))[0] == tramp);
+ ((gpointer*)(regs [8] - 8))[0] = mono_get_addr_from_ftnptr (addr);
+ ((gpointer*)(regs [8] - 8))[1] = NULL;
}
guchar*
mono_arch_create_trampoline_code (MonoTrampolineType tramp_type)
{
guint8 *buf, *tramp;
- int i, lmf_offset, offset, tramp_offset, saved_regs_offset, saved_fpregs_offset, framesize;
- int l0, l1, l2, l3, l4, l5, l6, l7, o0, o1, o2, o3;
- gint64 disp;
+ 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;
+ /*
+ * 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
/* FIXME: Save/restore lmf */
/* Stacked Registers */
+ in0 = 32;
+ local0 = in0 + 8;
+ out0 = local0 + 16;
l0 = 40;
l1 = 41;
l2 = 42;
l5 = 45; /* saved ar.pfs */
l6 = 46; /* arg */
l7 = 47; /* code */
- o0 = 48; /* regs */
- o1 = 49; /* code */
- o2 = 50; /* arg */
- o3 = 51; /* tramp */
+ 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)
- * 8 locals
+ * 16 locals
* 4 output (number of parameters passed to trampoline)
*/
- ia64_alloc (code, l5, 8, 8, 4, 0);
+ 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 */
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 */
- saved_regs_offset = offset;
- offset += 128 * 8;
- /*
- * Only the registers which are needed for computing vtable slots need
- * to be saved.
- */
- for (i = 0; i < 64; ++i)
- if ((1 << i) & MONO_ARCH_CALLEE_REGS) {
- ia64_adds_imm (code, l1, saved_regs_offset + (i * 8), IA64_SP);
- ia64_st8_hint (code, l1, i, 0);
- }
+ /* 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;
ia64_mov (code, o3, 0);
if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT)
- tramp = (guint8*)ia64_class_init_trampoline;
+ tramp = (guint8*)mono_class_init_trampoline;
else if (tramp_type == MONO_TRAMPOLINE_AOT)
- tramp = (guint8*)ia64_aot_trampoline;
+ tramp = (guint8*)mono_aot_trampoline;
+ else if (tramp_type == MONO_TRAMPOLINE_DELEGATE)
+ tramp = (guint8*)mono_delegate_trampoline;
else
- tramp = (guint8*)ia64_magic_trampoline;
+ tramp = (guint8*)mono_magic_trampoline;
/* Call the trampoline using an indirect call */
ia64_movl (code, l0, tramp);
/* FIXME: Handle NATs in fp regs / scratch regs */
- /* Load method address from function descriptor */
- ia64_ld8 (code, l0, IA64_R8);
- ia64_mov_to_br (code, IA64_B6, l0);
+ 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);
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;
#define TRAMPOLINE_SIZE 128
-static MonoJitInfo*
-create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain)
+gpointer
+mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
{
- MonoJitInfo *ji;
guint8 *buf, *tramp;
gint64 disp;
Ia64CodegenState code;
ia64_begin_bundle (code);
disp = (tramp - code.buf) >> 4;
- ia64_br_cond (code, disp);
+ if (ia64_is_imm21 (disp)) {
+ ia64_br_cond (code, disp);
+ }
+ else {
+ ia64_movl (code, GP_SCRATCH_REG2, tramp);
+ ia64_mov_to_br (code, IA64_B6, GP_SCRATCH_REG2);
+ ia64_br_cond_reg (code, IA64_B6);
+ }
ia64_codegen_close (code);
- mono_arch_flush_icache (buf, code.buf - buf);
-
- ji = g_new0 (MonoJitInfo, 1);
- ji->code_start = buf;
- ji->code_size = code.buf - buf;
-
- return ji;
-}
-
-MonoJitInfo*
-mono_arch_create_jump_trampoline (MonoMethod *method)
-{
- MonoJitInfo *ji = create_specific_trampoline (method, MONO_TRAMPOLINE_JUMP, mono_domain_get ());
-
- ji->method = method;
- return ji;
-}
-
-gpointer
-mono_arch_create_jit_trampoline (MonoMethod *method)
-{
- MonoJitInfo *ji;
- gpointer code_start;
-
- ji = create_specific_trampoline (method, MONO_TRAMPOLINE_GENERIC, mono_domain_get ());
- code_start = ji->code_start;
- g_free (ji);
-
- return code_start;
-}
+ g_assert (code.buf - buf <= TRAMPOLINE_SIZE);
-gpointer
-mono_arch_create_jit_trampoline_from_token (MonoImage *image, guint32 token)
-{
- MonoDomain *domain = mono_domain_get ();
- MonoJitInfo *ji;
- gpointer code_start;
- guint8 *buf, *start;
-
- mono_domain_lock (domain);
- buf = start = mono_code_manager_reserve (domain->code_mp, 2 * sizeof (gpointer));
- mono_domain_unlock (domain);
-
- *(gpointer*)(gpointer)buf = image;
- buf += sizeof (gpointer);
- *(guint32*)(gpointer)buf = token;
-
- ji = create_specific_trampoline (start, MONO_TRAMPOLINE_AOT, domain);
- code_start = ji->code_start;
- g_free (ji);
-
- return code_start;
-}
-
-/**
- * mono_arch_create_class_init_trampoline:
- * @vtable: the type to initialize
- *
- * Creates a trampoline function to run a type initializer.
- * If the trampoline is called, it calls mono_runtime_class_init with the
- * given vtable, then patches the caller code so it does not get called any
- * more.
- *
- * Returns: a pointer to the newly created code
- */
-gpointer
-mono_arch_create_class_init_trampoline (MonoVTable *vtable)
-{
- MonoJitInfo *ji;
- gpointer code;
+ mono_arch_flush_icache (buf, code.buf - buf);
- ji = create_specific_trampoline (vtable, MONO_TRAMPOLINE_CLASS_INIT, vtable->domain);
- code = ji->code_start;
- g_free (ji);
+ if (code_len)
+ *code_len = code.buf - buf;
- return code;
+ return buf;
}
void
projects / mono.git / blobdiff