X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Ftramp-sparc.c;h=a1f5afd4576133a3587fef8681aff92673c94c6a;hb=ec3740aa803f594718e5080f733bd2b5988f7d4d;hp=f55c8bc7675d3356e6afcabbd5a34370bf1a2a30;hpb=538d3bb80572334c18ae117ea7703406a4a22872;p=mono.git diff --git a/mono/mini/tramp-sparc.c b/mono/mini/tramp-sparc.c index f55c8bc7675..a1f5afd4576 100644 --- a/mono/mini/tramp-sparc.c +++ b/mono/mini/tramp-sparc.c @@ -32,11 +32,8 @@ gpointer 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 */ @@ -58,28 +55,28 @@ mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) } 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) +mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs) { g_assert_not_reached (); } @@ -87,12 +84,16 @@ mono_arch_nullify_plt_entry (guint8 *code) #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 @@ -108,6 +109,17 @@ mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) 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 ++) @@ -140,26 +152,19 @@ mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) 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); @@ -176,6 +181,11 @@ mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) /* 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); @@ -224,7 +234,7 @@ mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) 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) @@ -233,43 +243,33 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty 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) { - guint8 *ptr, *buf; - - ptr = buf = mono_code_manager_reserve (codeman, 16); - + /* FIXME: implement! */ g_assert_not_reached (); - - return ptr; + return NULL; }