mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr)
{
guint8 *code, *start;
- int this_pos = 4, reg;
+ int reg;
- if (!mono_method_signature (m)->ret->byref && MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
- this_pos = 8;
-
start = code = mono_global_codeman_reserve (36);
/* This executes in the context of the caller, hence o0 */
}
void
-mono_arch_patch_callsite (guint8 *code, guint8 *addr)
+mono_arch_patch_callsite (guint8 *method_start, guint8 *code, guint8 *addr)
{
- if (sparc_inst_op (*code) == 0x1) {
+ if (sparc_inst_op (*(guint32*)code) == 0x1) {
sparc_call_simple (code, (guint8*)addr - (guint8*)code);
}
}
void
-mono_arch_patch_plt_entry (guint8 *code, guint8 *addr)
+mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
{
g_assert_not_reached ();
}
void
-mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
+mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
{
/* Patch calling code */
sparc_nop (code);
}
-void
-mono_arch_nullify_plt_entry (guint8 *code)
-{
- g_assert_not_reached ();
-}
-
#define ALIGN_TO(val,align) (((val) + ((align) - 1)) & ~((align) - 1))
guchar*
-mono_arch_create_trampoline_code (MonoTrampolineType tramp_type)
+mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
{
guint8 *buf, *code, *tramp_addr;
guint32 lmf_offset, regs_offset, method_reg, i;
gboolean has_caller;
+ g_assert (!aot);
+ if (info)
+ *info = NULL;
+
if (tramp_type == MONO_TRAMPOLINE_JUMP)
has_caller = FALSE;
else
method_reg = sparc_g1;
#endif
+ regs_offset = MONO_SPARC_STACK_BIAS + 1000;
+
+ /* Save r1 needed by the IMT code */
+ sparc_sti_imm (code, sparc_g1, sparc_sp, regs_offset + (sparc_g1 * sizeof (gpointer)));
+
+ /*
+ * sparc_g5 contains the return address, the trampoline argument is stored in the
+ * instruction stream after the call.
+ */
+ sparc_ld_imm (code, sparc_g5, 8, method_reg);
+
#ifdef SPARCV9
/* Save fp regs since they are not preserved by calls */
for (i = 0; i < 16; i ++)
code = mono_sparc_emit_save_lmf (code, lmf_offset);
- regs_offset = MONO_SPARC_STACK_BIAS + 1000;
-
if (has_caller) {
/* Load all registers of the caller into a table inside this frame */
/* first the out registers */
for (i = 0; i < 8; ++i)
- sparc_sti_imm (code, sparc_i0 + i, sparc_sp, regs_offset + (i * sizeof (gpointer)));
+ sparc_sti_imm (code, sparc_i0 + i, sparc_sp, regs_offset + ((sparc_o0 + i) * sizeof (gpointer)));
/* then the in+local registers */
for (i = 0; i < 16; i ++) {
sparc_ldi_imm (code, sparc_fp, MONO_SPARC_STACK_BIAS + (i * sizeof (gpointer)), sparc_o7);
- sparc_sti_imm (code, sparc_o7, sparc_sp, regs_offset + ((i + 8) * sizeof (gpointer)));
+ sparc_sti_imm (code, sparc_o7, sparc_sp, regs_offset + ((sparc_l0 + i) * sizeof (gpointer)));
}
}
- if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT)
- tramp_addr = &mono_class_init_trampoline;
- else if (tramp_type == MONO_TRAMPOLINE_AOT)
- tramp_addr = mono_aot_trampoline;
- else
- tramp_addr = &mono_magic_trampoline;
+ tramp_addr = mono_get_trampoline_func (tramp_type);
sparc_ldi_imm (code, sparc_sp, MONO_SPARC_STACK_BIAS + 200, sparc_o2);
/* pass address of register table as third argument */
sparc_add_imm (code, FALSE, sparc_sp, regs_offset, sparc_o0);
/* Save result */
sparc_sti_imm (code, sparc_o0, sparc_sp, MONO_SPARC_STACK_BIAS + 304);
+ /* Check for thread interruption */
+ sparc_set (code, (guint8*)mono_thread_force_interruption_checkpoint, sparc_o7);
+ sparc_jmpl (code, sparc_o7, sparc_g0, sparc_o7);
+ sparc_nop (code);
+
/* Restore lmf */
code = mono_sparc_emit_restore_lmf (code, lmf_offset);
return buf;
}
-#define TRAMPOLINE_SIZE (((SPARC_SET_MAX_SIZE >> 2) * 2) + 2)
+#define TRAMPOLINE_SIZE (SPARC_SET_MAX_SIZE + 3)
gpointer
mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
tramp = mono_get_trampoline_code (tramp_type);
- mono_domain_lock (domain);
- code = buf = mono_code_manager_reserve (domain->code_mp, TRAMPOLINE_SIZE * 4);
- mono_domain_unlock (domain);
+ code = buf = mono_domain_code_reserve (domain, TRAMPOLINE_SIZE * 4);
/* We have to use g5 here because there is no other free register */
sparc_set (code, tramp, sparc_g5);
+ sparc_jmpl (code, sparc_g5, sparc_g0, sparc_g5);
+ sparc_nop (code);
#ifdef SPARCV9
- sparc_set (code, arg1, sparc_g4);
+ g_assert_not_reached ();
#else
- sparc_set (code, arg1, sparc_g1);
+ *code = (guint32)arg1;
+ code ++;
#endif
- sparc_jmpl (code, sparc_g5, sparc_g0, sparc_g0);
- sparc_nop (code);
g_assert ((code - buf) <= TRAMPOLINE_SIZE);
if (code_len)
*code_len = (code - buf) * 4;
- mono_jit_stats.method_trampolines++;
-
- mono_arch_flush_icache (buf, (code - buf) * 4);
+ mono_arch_flush_icache ((guint8*)buf, (code - buf) * 4);
return buf;
}
-/*
- * This method is only called when running in the Mono Debugger.
- */
gpointer
-mono_debugger_create_notification_function (MonoCodeManager *codeman)
+mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
+{
+ /* FIXME: implement! */
+ g_assert_not_reached ();
+ return NULL;
+}
+
+gpointer
+mono_arch_get_nullified_class_init_trampoline (MonoTrampInfo **info)
{
- guint8 *ptr, *buf;
+ guint8 *buf, *code;
- ptr = buf = mono_code_manager_reserve (codeman, 16);
+ code = buf = mono_global_codeman_reserve (16);
- g_assert_not_reached ();
+ sparc_ret (code);
- return ptr;
+ mono_arch_flush_icache (buf, code - buf);
+
+ if (info)
+ *info = mono_tramp_info_create ("nullified_class_init_trampoline", buf, code - buf, NULL, NULL);
+
+ return buf;
}
projects / mono.git / blobdiff