X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Ftramp-ppc.c;h=1b2cc1dfb91f0b043c62cfcef28161ddd6f8880b;hb=e52f1e1f5a18fe5bf2a84719b237847e31e1d7a2;hp=7cec84281ebd8c12065fb0b56256d0156647873b;hpb=424595ea7043f30b0553f2842654db13baeda3ca;p=mono.git diff --git a/mono/mini/tramp-ppc.c b/mono/mini/tramp-ppc.c index 7cec84281eb..1b2cc1dfb91 100644 --- a/mono/mini/tramp-ppc.c +++ b/mono/mini/tramp-ppc.c @@ -14,6 +14,7 @@ #include #include +#include #include #include #include @@ -203,12 +204,6 @@ mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs) mono_arch_patch_callsite (NULL, code, mini_get_nullified_class_init_trampoline ()); } -void -mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs) -{ - mono_arch_patch_plt_entry (code, NULL, regs, mini_get_nullified_class_init_trampoline ()); -} - /* Stack size for trampoline function * PPC_MINIMAL_STACK_SIZE + 16 (args + alignment to ppc_magic_trampoline) * + MonoLMF + 14 fp regs + 13 gregs + alignment @@ -300,44 +295,44 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf if (aot) { code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_get_lmf_addr"); #ifdef PPC_USES_FUNCTION_DESCRIPTOR - ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11); - ppc_ldptr (code, ppc_r11, 0, ppc_r11); + ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r12); + ppc_ldptr (code, ppc_r12, 0, ppc_r12); #endif - ppc_mtlr (code, ppc_r11); + ppc_mtlr (code, ppc_r12); ppc_blrl (code); } else { - ppc_load_func (code, ppc_r0, mono_get_lmf_addr); - ppc_mtlr (code, ppc_r0); + ppc_load_func (code, PPC_CALL_REG, mono_get_lmf_addr); + ppc_mtlr (code, PPC_CALL_REG); ppc_blrl (code); } /* we build the MonoLMF structure on the stack - see mini-ppc.h - * The pointer to the struct is put in ppc_r11. + * The pointer to the struct is put in ppc_r12. */ - ppc_addi (code, ppc_r11, ppc_sp, STACK - sizeof (MonoLMF)); - ppc_stptr (code, ppc_r3, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11); + ppc_addi (code, ppc_r12, ppc_sp, STACK - sizeof (MonoLMF)); + ppc_stptr (code, ppc_r3, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r12); /* new_lmf->previous_lmf = *lmf_addr */ ppc_ldptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3); - ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r11); - /* *(lmf_addr) = r11 */ - ppc_stptr (code, ppc_r11, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3); + ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r12); + /* *(lmf_addr) = r12 */ + ppc_stptr (code, ppc_r12, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r3); /* save method info (it's stored on the stack, so get it first). */ if ((tramp_type == MONO_TRAMPOLINE_JIT) || (tramp_type == MONO_TRAMPOLINE_JUMP)) { ppc_ldr (code, ppc_r0, GREGS_OFFSET, ppc_r1); - ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r11); + ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r12); } else { ppc_load (code, ppc_r0, 0); - ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r11); + ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r12); } /* store the frame pointer of the calling method */ ppc_addi (code, ppc_r0, ppc_sp, STACK); - ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, ebp), ppc_r11); + ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, ebp), ppc_r12); /* save the IP (caller ip) */ if (tramp_type == MONO_TRAMPOLINE_JUMP) { ppc_li (code, ppc_r0, 0); } else { ppc_ldr (code, ppc_r0, STACK + PPC_RET_ADDR_OFFSET, ppc_r1); } - ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, eip), ppc_r11); + ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, eip), ppc_r12); /* * Now we're ready to call trampoline (mgreg_t *regs, guint8 *code, gpointer value, guint8 *tramp) @@ -361,15 +356,15 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf if (aot) { code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("trampoline_func_%d", tramp_type)); #ifdef PPC_USES_FUNCTION_DESCRIPTOR - ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11); - ppc_ldptr (code, ppc_r11, 0, ppc_r11); + ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r12); + ppc_ldptr (code, ppc_r12, 0, ppc_r12); #endif - ppc_mtlr (code, ppc_r11); + ppc_mtlr (code, ppc_r12); ppc_blrl (code); } else { tramp_handler = mono_get_trampoline_func (tramp_type); - ppc_load_func (code, ppc_r0, tramp_handler); - ppc_mtlr (code, ppc_r0); + ppc_load_func (code, PPC_CALL_REG, tramp_handler); + ppc_mtlr (code, PPC_CALL_REG); ppc_blrl (code); } @@ -389,20 +384,20 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf * Now we restore the MonoLMF (see emit_epilogue in mini-ppc.c) * and the rest of the registers, so the method called will see * the same state as before we executed. - * The pointer to MonoLMF is in ppc_r11. + * The pointer to MonoLMF is in ppc_r12. */ - ppc_addi (code, ppc_r11, ppc_r1, STACK - sizeof (MonoLMF)); + ppc_addi (code, ppc_r12, ppc_r1, STACK - sizeof (MonoLMF)); /* r5 = previous_lmf */ - ppc_ldptr (code, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r11); + ppc_ldptr (code, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r12); /* r6 = lmf_addr */ - ppc_ldptr (code, ppc_r6, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11); + ppc_ldptr (code, ppc_r6, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r12); /* *(lmf_addr) = previous_lmf */ ppc_stptr (code, ppc_r5, G_STRUCT_OFFSET(MonoLMF, previous_lmf), ppc_r6); /* restore iregs */ - ppc_ldr_multiple (code, ppc_r13, G_STRUCT_OFFSET(MonoLMF, iregs), ppc_r11); + ppc_ldr_multiple (code, ppc_r13, G_STRUCT_OFFSET(MonoLMF, iregs), ppc_r12); /* restore fregs */ for (i = 14; i < 32; i++) - ppc_lfd (code, i, G_STRUCT_OFFSET(MonoLMF, fregs) + ((i-14) * sizeof (gdouble)), ppc_r11); + ppc_lfd (code, i, G_STRUCT_OFFSET(MonoLMF, fregs) + ((i-14) * sizeof (gdouble)), ppc_r12); /* restore the volatile registers, we skip r1, of course */ offset = STACK - sizeof (MonoLMF) - (14 * sizeof (double)); @@ -424,8 +419,8 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf */ /* Restore stack pointer and LR and jump to the code */ ppc_ldr (code, ppc_r1, 0, ppc_r1); - ppc_ldr (code, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_r1); - ppc_mtlr (code, ppc_r11); + ppc_ldr (code, ppc_r12, PPC_RET_ADDR_OFFSET, ppc_r1); + ppc_mtlr (code, ppc_r12); if (MONO_TRAMPOLINE_TYPE_MUST_RETURN (tramp_type)) ppc_blr (code); else @@ -551,7 +546,7 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info ppc_mr (code, ppc_r4, PPC_FIRST_ARG_REG); } else { /* load rgctx ptr from vtable */ - ppc_ldptr (code, ppc_r4, G_STRUCT_OFFSET (MonoVTable, runtime_generic_context), PPC_FIRST_ARG_REG); + ppc_ldptr (code, ppc_r4, MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context), PPC_FIRST_ARG_REG); /* is the rgctx ptr null? */ ppc_compare_reg_imm (code, 0, ppc_r4, 0); /* if yes, jump to actual trampoline */ @@ -596,9 +591,9 @@ mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot)); /* Branch to the trampoline */ #ifdef PPC_USES_FUNCTION_DESCRIPTOR - ppc_ldptr (code, ppc_r11, 0, ppc_r11); + ppc_ldptr (code, ppc_r12, 0, ppc_r12); #endif - ppc_mtctr (code, ppc_r11); + ppc_mtctr (code, ppc_r12); ppc_bcctr (code, PPC_BR_ALWAYS, 0); } else { tramp = mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), @@ -658,9 +653,9 @@ mono_arch_create_generic_class_init_trampoline (MonoTrampInfo **info, gboolean a code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_generic_class_init"); /* Branch to the trampoline */ #ifdef PPC_USES_FUNCTION_DESCRIPTOR - ppc_ldptr (code, ppc_r11, 0, ppc_r11); + ppc_ldptr (code, ppc_r12, 0, ppc_r12); #endif - ppc_mtctr (code, ppc_r11); + ppc_mtctr (code, ppc_r12); ppc_bcctr (code, PPC_BR_ALWAYS, 0); } else { tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_GENERIC_CLASS_INIT,