Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE:13.2:Update
mono-core
mono-core-ppc64le-swr11r12.diff
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File mono-core-ppc64le-swr11r12.diff of Package mono-core
Switch ppc_r11 with ppc_r12 This is a preliminary patch for ppc64le ELFv2 support. That one requires r12 to hold a functions address at calls to normal (global) C functions. As is r12 is also used by mini for its IMT_REG, VTABLE_REG and RGCTX_REG to pass around values to functions outside the normal argument registers (ugh!), so there's a conflict. This mechanical (by sed) patch simply switches ppc_r11 and ppc_r12 everywhere, r11 doesn't have any special use in the ABI. Index: mono-3.4.0/mono/arch/ppc/ppc-codegen.h =================================================================== --- mono-3.4.0.orig/mono/arch/ppc/ppc-codegen.h +++ mono-3.4.0/mono/arch/ppc/ppc-codegen.h @@ -810,9 +810,9 @@ my and Ximian's copyright to this code. #define ppc_load_func(c,D,V) ppc_load_sequence ((c), (D), (V)) #else #define ppc_load_func(c,D,v) G_STMT_START { \ - ppc_load_sequence ((c), ppc_r11, (guint64)(gsize)(v)); \ - ppc_ldptr ((c), ppc_r2, sizeof (gpointer), ppc_r11); \ - ppc_ldptr ((c), (D), 0, ppc_r11); \ + ppc_load_sequence ((c), ppc_r12, (guint64)(gsize)(v)); \ + ppc_ldptr ((c), ppc_r2, sizeof (gpointer), ppc_r12); \ + ppc_ldptr ((c), (D), 0, ppc_r12); \ } G_STMT_END #endif Index: mono-3.4.0/mono/mini/aot-compiler.c =================================================================== --- mono-3.4.0.orig/mono/mini/aot-compiler.c +++ mono-3.4.0/mono/mini/aot-compiler.c @@ -1842,14 +1842,14 @@ arch_emit_imt_thunk (MonoAotCompile *acf code = buf; /* Load the mscorlib got address */ - ppc_ldptr (code, ppc_r11, sizeof (gpointer), ppc_r30); + ppc_ldptr (code, ppc_r12, sizeof (gpointer), ppc_r30); /* Load the parameter from the GOT */ ppc_load (code, ppc_r0, offset * sizeof (gpointer)); - ppc_ldptr_indexed (code, ppc_r11, ppc_r11, ppc_r0); + ppc_ldptr_indexed (code, ppc_r12, ppc_r12, ppc_r0); /* Load and check key */ labels [1] = code; - ppc_ldptr (code, ppc_r0, 0, ppc_r11); + ppc_ldptr (code, ppc_r0, 0, ppc_r12); ppc_cmp (code, 0, sizeof (gpointer) == 8 ? 1 : 0, ppc_r0, MONO_ARCH_IMT_REG); labels [2] = code; ppc_bc (code, PPC_BR_TRUE, PPC_BR_EQ, 0); @@ -1860,18 +1860,18 @@ arch_emit_imt_thunk (MonoAotCompile *acf ppc_bc (code, PPC_BR_TRUE, PPC_BR_EQ, 0); /* Loop footer */ - ppc_addi (code, ppc_r11, ppc_r11, 2 * sizeof (gpointer)); + ppc_addi (code, ppc_r12, ppc_r12, 2 * sizeof (gpointer)); labels [4] = code; ppc_b (code, 0); mono_ppc_patch (labels [4], labels [1]); /* Match */ mono_ppc_patch (labels [2], code); - ppc_ldptr (code, ppc_r11, sizeof (gpointer), ppc_r11); - /* r11 now contains the value of the vtable slot */ + ppc_ldptr (code, ppc_r12, sizeof (gpointer), ppc_r12); + /* r12 now contains the value of the vtable slot */ /* this is not a function descriptor on ppc64 */ - ppc_ldptr (code, ppc_r11, 0, ppc_r11); - ppc_mtctr (code, ppc_r11); + ppc_ldptr (code, ppc_r12, 0, ppc_r12); + ppc_mtctr (code, ppc_r12); ppc_bcctr (code, PPC_BR_ALWAYS, 0); /* Fail */ Index: mono-3.4.0/mono/mini/exceptions-ppc.c =================================================================== --- mono-3.4.0.orig/mono/mini/exceptions-ppc.c +++ mono-3.4.0/mono/mini/exceptions-ppc.c @@ -381,13 +381,13 @@ mono_arch_get_throw_exception_generic (i if (aot) { code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_IMAGE, mono_defaults.corlib); - ppc_mr (code, ppc_r3, ppc_r11); + ppc_mr (code, ppc_r3, ppc_r12); code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_exception_from_token"); #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_mtctr (code, ppc_r11); + ppc_mtctr (code, ppc_r12); ppc_bcctrl (code, PPC_BR_ALWAYS, 0); } else { ppc_load (code, ppc_r3, (gulong)mono_defaults.corlib); @@ -420,10 +420,10 @@ mono_arch_get_throw_exception_generic (i code = mono_arch_emit_load_got_addr (start, code, NULL, &ji); code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_ppc_throw_exception"); #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_mtctr (code, ppc_r11); + ppc_mtctr (code, ppc_r12); ppc_bcctrl (code, PPC_BR_ALWAYS, 0); } else { ppc_load_func (code, ppc_r0, mono_ppc_throw_exception); Index: mono-3.4.0/mono/mini/mini-mips.c =================================================================== --- mono-3.4.0.orig/mono/mini/mini-mips.c +++ mono-3.4.0/mono/mini/mini-mips.c @@ -3298,8 +3298,8 @@ emit_reserve_param_area (MonoCompile *cf if (ppc_is_imm16 (-size)) { ppc_stwu (code, ppc_r0, -size, ppc_sp); } else { - ppc_load (code, ppc_r11, -size); - ppc_stwux (code, ppc_r0, ppc_sp, ppc_r11); + ppc_load (code, ppc_r12, -size); + ppc_stwux (code, ppc_r0, ppc_sp, ppc_r12); } #endif return code; @@ -3320,8 +3320,8 @@ emit_unreserve_param_area (MonoCompile * if (ppc_is_imm16 (size)) { ppc_stwu (code, ppc_r0, size, ppc_sp); } else { - ppc_load (code, ppc_r11, size); - ppc_stwux (code, ppc_r0, ppc_sp, ppc_r11); + ppc_load (code, ppc_r12, size); + ppc_stwux (code, ppc_r0, ppc_sp, ppc_r12); } #endif return code; @@ -3712,8 +3712,8 @@ mono_arch_output_basic_block (MonoCompil case OP_DIV_IMM: g_assert_not_reached (); #if 0 - ppc_load (code, ppc_r11, ins->inst_imm); - ppc_divwod (code, ins->dreg, ins->sreg1, ppc_r11); + ppc_load (code, ppc_r12, ins->inst_imm); + ppc_divwod (code, ins->dreg, ins->sreg1, ppc_r12); ppc_mfspr (code, ppc_r0, ppc_xer); ppc_andisd (code, ppc_r0, ppc_r0, (1<<14)); /* FIXME: use OverflowException for 0x80000000/-1 */ Index: mono-3.4.0/mono/mini/mini-ppc.c =================================================================== --- mono-3.4.0.orig/mono/mini/mini-ppc.c +++ mono-3.4.0/mono/mini/mini-ppc.c @@ -103,11 +103,11 @@ offsets_from_pthread_key (guint32 key, i /* FIXME: ensure the sc call preserves all but r3 */ #define emit_darwing4_tls(code,dreg,key) do {\ int off1 = 0x48 + key * sizeof (gpointer); \ - if ((dreg) != ppc_r3) ppc_mr ((code), ppc_r11, ppc_r3); \ + if ((dreg) != ppc_r3) ppc_mr ((code), ppc_r12, ppc_r3); \ ppc_li ((code), ppc_r0, 0x7FF2); \ ppc_sc ((code)); \ ppc_lwz ((code), (dreg), off1, ppc_r3); \ - if ((dreg) != ppc_r3) ppc_mr ((code), ppc_r3, ppc_r11); \ + if ((dreg) != ppc_r3) ppc_mr ((code), ppc_r3, ppc_r12); \ } while (0); #ifdef PPC_THREAD_PTR_REG @@ -118,8 +118,8 @@ offsets_from_pthread_key (guint32 key, i ppc_ldptr ((code), (dreg), off1, PPC_THREAD_PTR_REG); \ } else { \ int off3 = (off2 + 1) > 1; \ - ppc_addis ((code), ppc_r11, PPC_THREAD_PTR_REG, off3); \ - ppc_ldptr ((code), (dreg), off1, ppc_r11); \ + ppc_addis ((code), ppc_r12, PPC_THREAD_PTR_REG, off3); \ + ppc_ldptr ((code), (dreg), off1, ppc_r12); \ } \ } while (0); #else @@ -190,29 +190,29 @@ emit_memcpy (guint8 *code, int size, int ppc_load (code, ppc_r0, shifted); ppc_mtctr (code, ppc_r0); - //g_assert (sreg == ppc_r11); - ppc_addi (code, ppc_r12, dreg, (doffset - sizeof (gpointer))); - ppc_addi (code, ppc_r11, sreg, (soffset - sizeof (gpointer))); + //g_assert (sreg == ppc_r12); + ppc_addi (code, ppc_r11, dreg, (doffset - sizeof (gpointer))); + ppc_addi (code, ppc_r12, sreg, (soffset - sizeof (gpointer))); copy_loop_start = code; - ppc_ldptr_update (code, ppc_r0, (unsigned int)sizeof (gpointer), ppc_r11); - ppc_stptr_update (code, ppc_r0, (unsigned int)sizeof (gpointer), ppc_r12); + ppc_ldptr_update (code, ppc_r0, (unsigned int)sizeof (gpointer), ppc_r12); + ppc_stptr_update (code, ppc_r0, (unsigned int)sizeof (gpointer), ppc_r11); copy_loop_jump = code; ppc_bc (code, PPC_BR_DEC_CTR_NONZERO, 0, 0); ppc_patch (copy_loop_jump, copy_loop_start); size -= shifted * sizeof (gpointer); doffset = soffset = 0; - dreg = ppc_r12; + dreg = ppc_r11; } #ifdef __mono_ppc64__ /* the hardware has multiple load/store units and the move is long enough to use more then one regiester, then use load/load/store/store to execute 2 instructions per cycle. */ - if ((cpu_hw_caps & PPC_MULTIPLE_LS_UNITS) && (dreg != ppc_r12) && (sreg != ppc_r12)) { + if ((cpu_hw_caps & PPC_MULTIPLE_LS_UNITS) && (dreg != ppc_r11) && (sreg != ppc_r11)) { while (size >= 16) { ppc_ldptr (code, ppc_r0, soffset, sreg); - ppc_ldptr (code, ppc_r12, soffset+8, sreg); + ppc_ldptr (code, ppc_r11, soffset+8, sreg); ppc_stptr (code, ppc_r0, doffset, dreg); - ppc_stptr (code, ppc_r12, doffset+8, dreg); + ppc_stptr (code, ppc_r11, doffset+8, dreg); size -= 16; soffset += 16; doffset += 16; @@ -226,12 +226,12 @@ emit_memcpy (guint8 *code, int size, int doffset += 8; } #else - if ((cpu_hw_caps & PPC_MULTIPLE_LS_UNITS) && (dreg != ppc_r12) && (sreg != ppc_r12)) { + if ((cpu_hw_caps & PPC_MULTIPLE_LS_UNITS) && (dreg != ppc_r11) && (sreg != ppc_r11)) { while (size >= 8) { ppc_lwz (code, ppc_r0, soffset, sreg); - ppc_lwz (code, ppc_r12, soffset+4, sreg); + ppc_lwz (code, ppc_r11, soffset+4, sreg); ppc_stw (code, ppc_r0, doffset, dreg); - ppc_stw (code, ppc_r12, doffset+4, dreg); + ppc_stw (code, ppc_r11, doffset+4, dreg); size -= 8; soffset += 8; doffset += 8; @@ -737,7 +737,7 @@ mono_arch_get_global_int_regs (MonoCompi for (i = 14; i < top; ++i) { /* * Reserve r29 for holding the vtable address for virtual calls in AOT mode, - * since the trampolines can clobber r11. + * since the trampolines can clobber r12. */ if (!(cfg->compile_aot && i == 29)) regs = g_list_prepend (regs, GUINT_TO_POINTER (i)); @@ -2922,7 +2922,7 @@ ppc_patch_full (guchar *code, const guch if (!is_fd) { guint8 *buf = (guint8*)&seq [5]; - ppc_mr (buf, ppc_r0, ppc_r11); + ppc_mr (buf, ppc_r0, ppc_r12); ppc_nop (buf); } } else { @@ -2932,8 +2932,8 @@ ppc_patch_full (guchar *code, const guch /* FIXME: make this thread safe */ #ifdef PPC_USES_FUNCTION_DESCRIPTOR - /* FIXME: we're assuming we're using r11 here */ - ppc_load_ptr_sequence (code, ppc_r11, target); + /* FIXME: we're assuming we're using r12 here */ + ppc_load_ptr_sequence (code, ppc_r12, target); #else ppc_load_ptr_sequence (code, ppc_r0, target); #endif @@ -3009,8 +3009,8 @@ emit_reserve_param_area (MonoCompile *cf if (ppc_is_imm16 (-size)) { ppc_stptr_update (code, ppc_r0, -size, ppc_sp); } else { - ppc_load (code, ppc_r11, -size); - ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r11); + ppc_load (code, ppc_r12, -size); + ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r12); } return code; @@ -3031,8 +3031,8 @@ emit_unreserve_param_area (MonoCompile * if (ppc_is_imm16 (size)) { ppc_stptr_update (code, ppc_r0, size, ppc_sp); } else { - ppc_load (code, ppc_r11, size); - ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r11); + ppc_load (code, ppc_r12, size); + ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r12); } return code; @@ -3106,8 +3106,8 @@ mono_arch_output_basic_block (MonoCompil * a breakpoint is hit will step to the next IL offset. */ if (ins->flags & MONO_INST_SINGLE_STEP_LOC) { - ppc_load (code, ppc_r11, (gsize)ss_trigger_page); - ppc_ldptr (code, ppc_r11, 0, ppc_r11); + ppc_load (code, ppc_r12, (gsize)ss_trigger_page); + ppc_ldptr (code, ppc_r12, 0, ppc_r12); } mono_add_seq_point (cfg, bb, ins, code - cfg->native_code); @@ -3141,8 +3141,8 @@ mono_arch_output_basic_block (MonoCompil ppc_stb (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); - ppc_stb (code, ins->sreg1, ins->inst_offset, ppc_r12); + ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_stb (code, ins->sreg1, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); ppc_stbx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0); @@ -3154,8 +3154,8 @@ mono_arch_output_basic_block (MonoCompil ppc_sth (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); - ppc_sth (code, ins->sreg1, ins->inst_offset, ppc_r12); + ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_sth (code, ins->sreg1, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); ppc_sthx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0); @@ -3167,8 +3167,8 @@ mono_arch_output_basic_block (MonoCompil ppc_stptr (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); - ppc_stptr (code, ins->sreg1, ins->inst_offset, ppc_r12); + ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_stptr (code, ins->sreg1, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); ppc_stptr_indexed (code, ins->sreg1, ins->inst_destbasereg, ppc_r0); @@ -3724,7 +3724,7 @@ mono_arch_output_basic_block (MonoCompil */ g_assert (!cfg->method->save_lmf); /* - * Note: we can use ppc_r11 here because it is dead anyway: + * Note: we can use ppc_r12 here because it is dead anyway: * we're leaving the method. */ if (1 || cfg->flags & MONO_CFG_HAS_CALLS) { @@ -3732,26 +3732,26 @@ mono_arch_output_basic_block (MonoCompil if (ppc_is_imm16 (ret_offset)) { ppc_ldptr (code, ppc_r0, ret_offset, cfg->frame_reg); } else { - ppc_load (code, ppc_r11, ret_offset); - ppc_ldptr_indexed (code, ppc_r0, cfg->frame_reg, ppc_r11); + ppc_load (code, ppc_r12, ret_offset); + ppc_ldptr_indexed (code, ppc_r0, cfg->frame_reg, ppc_r12); } ppc_mtlr (code, ppc_r0); } if (ppc_is_imm16 (cfg->stack_usage)) { - ppc_addi (code, ppc_r11, cfg->frame_reg, cfg->stack_usage); + ppc_addi (code, ppc_r12, cfg->frame_reg, cfg->stack_usage); } else { /* cfg->stack_usage is an int, so we can use * an addis/addi sequence here even in 64-bit. */ - ppc_addis (code, ppc_r11, cfg->frame_reg, ppc_ha(cfg->stack_usage)); - ppc_addi (code, ppc_r11, ppc_r11, cfg->stack_usage); + ppc_addis (code, ppc_r12, cfg->frame_reg, ppc_ha(cfg->stack_usage)); + ppc_addi (code, ppc_r12, ppc_r12, cfg->stack_usage); } if (!cfg->method->save_lmf) { pos = 0; for (i = 31; i >= 13; --i) { if (cfg->used_int_regs & (1 << i)) { pos += sizeof (gpointer); - ppc_ldptr (code, i, -pos, ppc_r11); + ppc_ldptr (code, i, -pos, ppc_r12); } } } else { @@ -3760,27 +3760,27 @@ mono_arch_output_basic_block (MonoCompil /* Copy arguments on the stack to our argument area */ if (call->stack_usage) { - code = emit_memcpy (code, call->stack_usage, ppc_r11, PPC_STACK_PARAM_OFFSET, ppc_sp, PPC_STACK_PARAM_OFFSET); - /* r11 was clobbered */ + code = emit_memcpy (code, call->stack_usage, ppc_r12, PPC_STACK_PARAM_OFFSET, ppc_sp, PPC_STACK_PARAM_OFFSET); + /* r12 was clobbered */ g_assert (cfg->frame_reg == ppc_sp); if (ppc_is_imm16 (cfg->stack_usage)) { - ppc_addi (code, ppc_r11, cfg->frame_reg, cfg->stack_usage); + ppc_addi (code, ppc_r12, cfg->frame_reg, cfg->stack_usage); } else { /* cfg->stack_usage is an int, so we can use * an addis/addi sequence here even in 64-bit. */ - ppc_addis (code, ppc_r11, cfg->frame_reg, ppc_ha(cfg->stack_usage)); - ppc_addi (code, ppc_r11, ppc_r11, cfg->stack_usage); + ppc_addis (code, ppc_r12, cfg->frame_reg, ppc_ha(cfg->stack_usage)); + ppc_addi (code, ppc_r12, ppc_r12, cfg->stack_usage); } } - ppc_mr (code, ppc_sp, ppc_r11); + ppc_mr (code, ppc_sp, ppc_r12); mono_add_patch_info (cfg, (guint8*) code - cfg->native_code, MONO_PATCH_INFO_METHOD_JUMP, call->method); if (cfg->compile_aot) { /* arch_emit_got_access () patches this */ ppc_load32 (code, ppc_r0, 0); #ifdef PPC_USES_FUNCTION_DESCRIPTOR - ppc_ldptr_indexed (code, ppc_r11, ppc_r30, ppc_r0); - ppc_ldptr (code, ppc_r0, 0, ppc_r11); + ppc_ldptr_indexed (code, ppc_r12, ppc_r30, ppc_r0); + ppc_ldptr (code, ppc_r0, 0, ppc_r12); #else ppc_ldptr_indexed (code, ppc_r0, ppc_r30, ppc_r0); #endif @@ -3852,7 +3852,7 @@ mono_arch_output_basic_block (MonoCompil case OP_VCALL2_MEMBASE: case OP_VOIDCALL_MEMBASE: case OP_CALL_MEMBASE: - if (cfg->compile_aot && ins->sreg1 == ppc_r11) { + if (cfg->compile_aot && ins->sreg1 == ppc_r12) { /* The trampolines clobber this */ ppc_mr (code, ppc_r29, ins->sreg1); ppc_ldptr (code, ppc_r0, ins->inst_offset, ppc_r29); @@ -3870,9 +3870,9 @@ mono_arch_output_basic_block (MonoCompil int alloca_waste = PPC_STACK_PARAM_OFFSET + cfg->param_area + 31; int area_offset = alloca_waste; area_offset &= ~31; - ppc_addi (code, ppc_r11, ins->sreg1, alloca_waste + 31); + ppc_addi (code, ppc_r12, ins->sreg1, alloca_waste + 31); /* FIXME: should be calculated from MONO_ARCH_FRAME_ALIGNMENT */ - ppc_clear_right_imm (code, ppc_r11, ppc_r11, 4); + ppc_clear_right_imm (code, ppc_r12, ppc_r12, 4); /* use ctr to store the number of words to 0 if needed */ if (ins->flags & MONO_INST_INIT) { /* we zero 4 bytes at a time: @@ -3885,8 +3885,8 @@ mono_arch_output_basic_block (MonoCompil ppc_mtctr (code, ppc_r0); } ppc_ldptr (code, ppc_r0, 0, ppc_sp); - ppc_neg (code, ppc_r11, ppc_r11); - ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r11); + ppc_neg (code, ppc_r12, ppc_r12); + ppc_stptr_update_indexed (code, ppc_r0, ppc_sp, ppc_r12); /* FIXME: make this loop work in 8 byte increments on PPC64 */ @@ -3896,9 +3896,9 @@ mono_arch_output_basic_block (MonoCompil * run at least once */ ppc_addi (code, ins->dreg, ppc_sp, (area_offset - 8)); - ppc_li (code, ppc_r11, 0); + ppc_li (code, ppc_r12, 0); zero_loop_start = code; - ppc_stwu (code, ppc_r11, 4, ins->dreg); + ppc_stwu (code, ppc_r12, 4, ins->dreg); zero_loop_jump = code; ppc_bc (code, PPC_BR_DEC_CTR_NONZERO, 0, 0); ppc_patch (zero_loop_jump, zero_loop_start); @@ -3942,8 +3942,8 @@ mono_arch_output_basic_block (MonoCompil if (ppc_is_imm16 (spvar->inst_offset)) { ppc_stptr (code, ppc_r0, spvar->inst_offset, spvar->inst_basereg); } else { - ppc_load (code, ppc_r11, spvar->inst_offset); - ppc_stptr_indexed (code, ppc_r0, ppc_r11, spvar->inst_basereg); + ppc_load (code, ppc_r12, spvar->inst_offset); + ppc_stptr_indexed (code, ppc_r0, ppc_r12, spvar->inst_basereg); } break; } @@ -3956,8 +3956,8 @@ mono_arch_output_basic_block (MonoCompil if (ppc_is_imm16 (spvar->inst_offset)) { ppc_ldptr (code, ppc_r0, spvar->inst_offset, spvar->inst_basereg); } else { - ppc_load (code, ppc_r11, spvar->inst_offset); - ppc_ldptr_indexed (code, ppc_r0, spvar->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, spvar->inst_offset); + ppc_ldptr_indexed (code, ppc_r0, spvar->inst_basereg, ppc_r12); } ppc_mtlr (code, ppc_r0); ppc_blr (code); @@ -4063,11 +4063,11 @@ mono_arch_output_basic_block (MonoCompil /* FIXME: Optimize this */ ppc_bl (code, 1); - ppc_mflr (code, ppc_r11); + ppc_mflr (code, ppc_r12); ppc_b (code, 3); *(double*)code = *(double*)ins->inst_p0; code += 8; - ppc_lfd (code, ins->dreg, 8, ppc_r11); + ppc_lfd (code, ins->dreg, 8, ppc_r12); break; case OP_R4CONST: g_assert_not_reached (); @@ -4077,8 +4077,8 @@ mono_arch_output_basic_block (MonoCompil ppc_stfd (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); - ppc_stfd (code, ins->sreg1, ins->inst_offset, ppc_r12); + ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_stfd (code, ins->sreg1, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); ppc_stfdx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0); @@ -4090,8 +4090,8 @@ mono_arch_output_basic_block (MonoCompil ppc_lfd (code, ins->dreg, ins->inst_offset, ins->inst_basereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); - ppc_lfd (code, ins->dreg, ins->inst_offset, ppc_r12); + ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_lfd (code, ins->dreg, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); ppc_lfdx (code, ins->dreg, ins->inst_destbasereg, ppc_r0); @@ -4104,8 +4104,8 @@ mono_arch_output_basic_block (MonoCompil ppc_stfs (code, ins->sreg1, ins->inst_offset, ins->inst_destbasereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); - ppc_stfs (code, ins->sreg1, ins->inst_offset, ppc_r12); + ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_stfs (code, ins->sreg1, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); ppc_stfsx (code, ins->sreg1, ins->inst_destbasereg, ppc_r0); @@ -4117,8 +4117,8 @@ mono_arch_output_basic_block (MonoCompil ppc_lfs (code, ins->dreg, ins->inst_offset, ins->inst_basereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r12, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); - ppc_lfs (code, ins->dreg, ins->inst_offset, ppc_r12); + ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_lfs (code, ins->dreg, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); ppc_lfsx (code, ins->dreg, ins->inst_destbasereg, ppc_r0); @@ -4723,12 +4723,12 @@ mono_arch_emit_prolog (MonoCompile *cfg) code = save_registers (cfg, code, alloc_size - pos, ppc_sp, method->save_lmf, cfg->used_int_regs, cfa_offset); } else { if (pos) - ppc_addi (code, ppc_r11, ppc_sp, -pos); + ppc_addi (code, ppc_r12, ppc_sp, -pos); ppc_load (code, ppc_r0, -alloc_size); ppc_str_update_indexed (code, ppc_sp, ppc_sp, ppc_r0); cfa_offset = alloc_size; mono_emit_unwind_op_def_cfa_offset (cfg, code, alloc_size); - code = save_registers (cfg, code, 0, ppc_r11, method->save_lmf, cfg->used_int_regs, cfa_offset); + code = save_registers (cfg, code, 0, ppc_r12, method->save_lmf, cfg->used_int_regs, cfa_offset); } } if (cfg->frame_reg != ppc_sp) { @@ -4774,8 +4774,8 @@ mono_arch_emit_prolog (MonoCompile *cfg) if (ppc_is_imm16 (inst->inst_offset)) { ppc_stptr (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_stptr_indexed (code, ainfo->reg, ppc_r11, inst->inst_basereg); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stptr_indexed (code, ainfo->reg, ppc_r12, inst->inst_basereg); } } @@ -4792,8 +4792,8 @@ mono_arch_emit_prolog (MonoCompile *cfg) else if (ainfo->regtype == RegTypeFP) ppc_fmr (code, inst->dreg, ainfo->reg); else if (ainfo->regtype == RegTypeBase) { - ppc_ldr (code, ppc_r11, 0, ppc_sp); - ppc_ldptr (code, inst->dreg, ainfo->offset, ppc_r11); + ppc_ldr (code, ppc_r12, 0, ppc_sp); + ppc_ldptr (code, inst->dreg, ainfo->offset, ppc_r12); } else g_assert_not_reached (); @@ -4808,11 +4808,11 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_stb (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); } else { if (ppc_is_imm32 (inst->inst_offset)) { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_stb (code, ainfo->reg, inst->inst_offset, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_stb (code, ainfo->reg, inst->inst_offset, ppc_r12); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_stbx (code, ainfo->reg, inst->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stbx (code, ainfo->reg, inst->inst_basereg, ppc_r12); } } break; @@ -4821,11 +4821,11 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_sth (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); } else { if (ppc_is_imm32 (inst->inst_offset)) { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_sth (code, ainfo->reg, inst->inst_offset, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_sth (code, ainfo->reg, inst->inst_offset, ppc_r12); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_sthx (code, ainfo->reg, inst->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_sthx (code, ainfo->reg, inst->inst_basereg, ppc_r12); } } break; @@ -4835,11 +4835,11 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_stw (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); } else { if (ppc_is_imm32 (inst->inst_offset)) { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_stw (code, ainfo->reg, inst->inst_offset, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_stw (code, ainfo->reg, inst->inst_offset, ppc_r12); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_stwx (code, ainfo->reg, inst->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stwx (code, ainfo->reg, inst->inst_basereg, ppc_r12); } } break; @@ -4847,8 +4847,8 @@ mono_arch_emit_prolog (MonoCompile *cfg) if (ppc_is_imm16 (inst->inst_offset)) { ppc_str (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_str_indexed (code, ainfo->reg, ppc_r11, inst->inst_basereg); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_str_indexed (code, ainfo->reg, ppc_r12, inst->inst_basereg); } break; #else @@ -4857,10 +4857,10 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_stw (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); ppc_stw (code, ainfo->reg + 1, inst->inst_offset + 4, inst->inst_basereg); } else { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_addi (code, ppc_r11, ppc_r11, inst->inst_offset); - ppc_stw (code, ainfo->reg, 0, ppc_r11); - ppc_stw (code, ainfo->reg + 1, 4, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_addi (code, ppc_r12, ppc_r12, inst->inst_offset); + ppc_stw (code, ainfo->reg, 0, ppc_r12); + ppc_stw (code, ainfo->reg + 1, 4, ppc_r12); } break; #endif @@ -4869,31 +4869,31 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_stptr (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); } else { if (ppc_is_imm32 (inst->inst_offset)) { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_stptr (code, ainfo->reg, inst->inst_offset, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_stptr (code, ainfo->reg, inst->inst_offset, ppc_r12); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_stptr_indexed (code, ainfo->reg, inst->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stptr_indexed (code, ainfo->reg, inst->inst_basereg, ppc_r12); } } break; } } else if (ainfo->regtype == RegTypeBase) { g_assert (ppc_is_imm16 (ainfo->offset)); - /* load the previous stack pointer in r11 */ - ppc_ldr (code, ppc_r11, 0, ppc_sp); - ppc_ldptr (code, ppc_r0, ainfo->offset, ppc_r11); + /* load the previous stack pointer in r12 */ + ppc_ldr (code, ppc_r12, 0, ppc_sp); + ppc_ldptr (code, ppc_r0, ainfo->offset, ppc_r12); switch (ainfo->size) { case 1: if (ppc_is_imm16 (inst->inst_offset)) { ppc_stb (code, ppc_r0, inst->inst_offset, inst->inst_basereg); } else { if (ppc_is_imm32 (inst->inst_offset)) { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_stb (code, ppc_r0, inst->inst_offset, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_stb (code, ppc_r0, inst->inst_offset, ppc_r12); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_stbx (code, ppc_r0, inst->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stbx (code, ppc_r0, inst->inst_basereg, ppc_r12); } } break; @@ -4902,11 +4902,11 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_sth (code, ppc_r0, inst->inst_offset, inst->inst_basereg); } else { if (ppc_is_imm32 (inst->inst_offset)) { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_sth (code, ppc_r0, inst->inst_offset, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_sth (code, ppc_r0, inst->inst_offset, ppc_r12); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_sthx (code, ppc_r0, inst->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_sthx (code, ppc_r0, inst->inst_basereg, ppc_r12); } } break; @@ -4916,11 +4916,11 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_stw (code, ppc_r0, inst->inst_offset, inst->inst_basereg); } else { if (ppc_is_imm32 (inst->inst_offset)) { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_stw (code, ppc_r0, inst->inst_offset, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_stw (code, ppc_r0, inst->inst_offset, ppc_r12); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_stwx (code, ppc_r0, inst->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stwx (code, ppc_r0, inst->inst_basereg, ppc_r12); } } break; @@ -4928,8 +4928,8 @@ mono_arch_emit_prolog (MonoCompile *cfg) if (ppc_is_imm16 (inst->inst_offset)) { ppc_str (code, ppc_r0, inst->inst_offset, inst->inst_basereg); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_str_indexed (code, ppc_r0, ppc_r11, inst->inst_basereg); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_str_indexed (code, ppc_r0, ppc_r12, inst->inst_basereg); } break; #else @@ -4937,15 +4937,15 @@ mono_arch_emit_prolog (MonoCompile *cfg) g_assert (ppc_is_imm16 (ainfo->offset + 4)); if (ppc_is_imm16 (inst->inst_offset + 4)) { ppc_stw (code, ppc_r0, inst->inst_offset, inst->inst_basereg); - ppc_lwz (code, ppc_r0, ainfo->offset + 4, ppc_r11); + ppc_lwz (code, ppc_r0, ainfo->offset + 4, ppc_r12); ppc_stw (code, ppc_r0, inst->inst_offset + 4, inst->inst_basereg); } else { - /* use r12 to load the 2nd half of the long before we clobber r11. */ - ppc_lwz (code, ppc_r12, ainfo->offset + 4, ppc_r11); - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_addi (code, ppc_r11, ppc_r11, inst->inst_offset); - ppc_stw (code, ppc_r0, 0, ppc_r11); - ppc_stw (code, ppc_r12, 4, ppc_r11); + /* use r11 to load the 2nd half of the long before we clobber r12. */ + ppc_lwz (code, ppc_r11, ainfo->offset + 4, ppc_r12); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_addi (code, ppc_r12, ppc_r12, inst->inst_offset); + ppc_stw (code, ppc_r0, 0, ppc_r12); + ppc_stw (code, ppc_r11, 4, ppc_r12); } break; #endif @@ -4954,11 +4954,11 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_stptr (code, ppc_r0, inst->inst_offset, inst->inst_basereg); } else { if (ppc_is_imm32 (inst->inst_offset)) { - ppc_addis (code, ppc_r11, inst->inst_basereg, ppc_ha(inst->inst_offset)); - ppc_stptr (code, ppc_r0, inst->inst_offset, ppc_r11); + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_stptr (code, ppc_r0, inst->inst_offset, ppc_r12); } else { - ppc_load (code, ppc_r11, inst->inst_offset); - ppc_stptr_indexed (code, ppc_r0, inst->inst_basereg, ppc_r11); + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stptr_indexed (code, ppc_r0, inst->inst_basereg, ppc_r12); } } break; @@ -5017,39 +5017,39 @@ mono_arch_emit_prolog (MonoCompile *cfg) /* FIXME: we need to do the shifting here, too */ if (ainfo->bytes) NOT_IMPLEMENTED; - /* load the previous stack pointer in r11 (r0 gets overwritten by the memcpy) */ - ppc_ldr (code, ppc_r11, 0, ppc_sp); + /* load the previous stack pointer in r12 (r0 gets overwritten by the memcpy) */ + ppc_ldr (code, ppc_r12, 0, ppc_sp); if ((size & MONO_PPC_32_64_CASE (3, 7)) != 0) { code = emit_memcpy (code, size - soffset, inst->inst_basereg, doffset, - ppc_r11, ainfo->offset + soffset); + ppc_r12, ainfo->offset + soffset); } else { code = emit_memcpy (code, ainfo->vtsize * sizeof (gpointer), inst->inst_basereg, doffset, - ppc_r11, ainfo->offset + soffset); + ppc_r12, ainfo->offset + soffset); } } } else if (ainfo->regtype == RegTypeStructByAddr) { /* if it was originally a RegTypeBase */ if (ainfo->offset) { - /* load the previous stack pointer in r11 */ - ppc_ldr (code, ppc_r11, 0, ppc_sp); - ppc_ldptr (code, ppc_r11, ainfo->offset, ppc_r11); + /* load the previous stack pointer in r12 */ + ppc_ldr (code, ppc_r12, 0, ppc_sp); + ppc_ldptr (code, ppc_r12, ainfo->offset, ppc_r12); } else { - ppc_mr (code, ppc_r11, ainfo->reg); + ppc_mr (code, ppc_r12, ainfo->reg); } if (cfg->tailcall_valuetype_addrs) { MonoInst *addr = cfg->tailcall_valuetype_addrs [tailcall_struct_index]; g_assert (ppc_is_imm16 (addr->inst_offset)); - ppc_stptr (code, ppc_r11, addr->inst_offset, addr->inst_basereg); + ppc_stptr (code, ppc_r12, addr->inst_offset, addr->inst_basereg); tailcall_struct_index++; } g_assert (ppc_is_imm16 (inst->inst_offset)); - code = emit_memcpy (code, ainfo->vtsize, inst->inst_basereg, inst->inst_offset, ppc_r11, 0); + code = emit_memcpy (code, ainfo->vtsize, inst->inst_basereg, inst->inst_offset, ppc_r12, 0); /*g_print ("copy in %s: %d bytes from %d to offset: %d\n", method->name, ainfo->vtsize, ainfo->reg, inst->inst_offset);*/ } else g_assert_not_reached (); @@ -5081,25 +5081,25 @@ mono_arch_emit_prolog (MonoCompile *cfg) /* lmf_offset is the offset from the previous stack pointer, * alloc_size is the total stack space allocated, so the offset * of MonoLMF from the current stack ptr is alloc_size - lmf_offset. - * The pointer to the struct is put in ppc_r11 (new_lmf). + * The pointer to the struct is put in ppc_r12 (new_lmf). * The callee-saved registers are already in the MonoLMF structure */ - ppc_addi (code, ppc_r11, ppc_sp, alloc_size - lmf_offset); + ppc_addi (code, ppc_r12, ppc_sp, alloc_size - lmf_offset); /* ppc_r3 is the result from mono_get_lmf_addr () */ - ppc_stptr (code, ppc_r3, G_STRUCT_OFFSET(MonoLMF, lmf_addr), ppc_r11); + 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 */ if (cfg->compile_aot) // FIXME: ppc_load (code, ppc_r0, 0); else ppc_load_ptr (code, ppc_r0, method); - ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r11); - ppc_stptr (code, ppc_sp, G_STRUCT_OFFSET(MonoLMF, ebp), ppc_r11); + ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, method), ppc_r12); + ppc_stptr (code, ppc_sp, G_STRUCT_OFFSET(MonoLMF, ebp), ppc_r12); /* save the current IP */ if (cfg->compile_aot) { ppc_bl (code, 1); @@ -5112,7 +5112,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) ppc_load_sequence (code, ppc_r0, (gulong)0x01010101L); #endif } - ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, eip), ppc_r11); + ppc_stptr (code, ppc_r0, G_STRUCT_OFFSET(MonoLMF, eip), ppc_r12); } if (tracing) @@ -5164,21 +5164,21 @@ mono_arch_emit_epilog (MonoCompile *cfg) lmf_offset = pos; /* save the frame reg in r8 */ ppc_mr (code, ppc_r8, cfg->frame_reg); - ppc_addi (code, ppc_r11, cfg->frame_reg, cfg->stack_usage - lmf_offset); + ppc_addi (code, ppc_r12, cfg->frame_reg, cfg->stack_usage - lmf_offset); /* 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); /* FIXME: speedup: there is no actual need to restore the registers if * we didn't actually change them (idea from Zoltan). */ /* 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); }*/ g_assert (ppc_is_imm16 (cfg->stack_usage + PPC_RET_ADDR_OFFSET)); /* use the saved copy of the frame reg in r8 */ @@ -5193,8 +5193,8 @@ mono_arch_emit_epilog (MonoCompile *cfg) if (ppc_is_imm16 (return_offset)) { ppc_ldr (code, ppc_r0, return_offset, cfg->frame_reg); } else { - ppc_load (code, ppc_r11, return_offset); - ppc_ldr_indexed (code, ppc_r0, cfg->frame_reg, ppc_r11); + ppc_load (code, ppc_r12, return_offset); + ppc_ldr_indexed (code, ppc_r0, cfg->frame_reg, ppc_r12); } ppc_mtlr (code, ppc_r0); } @@ -5205,7 +5205,7 @@ mono_arch_emit_epilog (MonoCompile *cfg) offset -= sizeof (mgreg_t); } if (cfg->frame_reg != ppc_sp) - ppc_mr (code, ppc_r11, cfg->frame_reg); + ppc_mr (code, ppc_r12, cfg->frame_reg); /* note r31 (possibly the frame register) is restored last */ for (i = 13; i <= 31; i++) { if (cfg->used_int_regs & (1 << i)) { @@ -5214,22 +5214,22 @@ mono_arch_emit_epilog (MonoCompile *cfg) } } if (cfg->frame_reg != ppc_sp) - ppc_addi (code, ppc_sp, ppc_r11, cfg->stack_usage); + ppc_addi (code, ppc_sp, ppc_r12, cfg->stack_usage); else ppc_addi (code, ppc_sp, ppc_sp, cfg->stack_usage); } else { - ppc_load32 (code, ppc_r11, cfg->stack_usage); + ppc_load32 (code, ppc_r12, cfg->stack_usage); if (cfg->used_int_regs) { - ppc_add (code, ppc_r11, cfg->frame_reg, ppc_r11); + ppc_add (code, ppc_r12, cfg->frame_reg, ppc_r12); for (i = 31; i >= 13; --i) { if (cfg->used_int_regs & (1 << i)) { pos += sizeof (mgreg_t); - ppc_ldr (code, i, -pos, ppc_r11); + ppc_ldr (code, i, -pos, ppc_r12); } } - ppc_mr (code, ppc_sp, ppc_r11); + ppc_mr (code, ppc_sp, ppc_r12); } else { - ppc_add (code, ppc_sp, cfg->frame_reg, ppc_r11); + ppc_add (code, ppc_sp, cfg->frame_reg, ppc_r12); } } @@ -5618,15 +5618,15 @@ mono_arch_build_imt_thunk (MonoVTable *v start = code; /* - * We need to save and restore r11 because it might be + * We need to save and restore r12 because it might be * used by the caller as the vtable register, so * clobbering it will trip up the magic trampoline. * - * FIXME: Get rid of this by making sure that r11 is + * FIXME: Get rid of this by making sure that r12 is * not used as the vtable register in interface calls. */ - ppc_stptr (code, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_sp); - ppc_load (code, ppc_r11, (gsize)(& (vtable->vtable [0]))); + ppc_stptr (code, ppc_r12, PPC_RET_ADDR_OFFSET, ppc_sp); + ppc_load (code, ppc_r12, (gsize)(& (vtable->vtable [0]))); for (i = 0; i < count; ++i) { MonoIMTCheckItem *item = imt_entries [i]; @@ -5642,8 +5642,8 @@ mono_arch_build_imt_thunk (MonoVTable *v if (item->has_target_code) { ppc_load_ptr (code, ppc_r0, item->value.target_code); } else { - ppc_ldptr (code, ppc_r0, (sizeof (gpointer) * item->value.vtable_slot), ppc_r11); - ppc_ldptr (code, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_sp); + ppc_ldptr (code, ppc_r0, (sizeof (gpointer) * item->value.vtable_slot), ppc_r12); + ppc_ldptr (code, ppc_r12, PPC_RET_ADDR_OFFSET, ppc_sp); } ppc_mtctr (code, ppc_r0); ppc_bcctr (code, PPC_BR_ALWAYS, 0); @@ -5675,8 +5675,8 @@ mono_arch_build_imt_thunk (MonoVTable *v item->jmp_code = code; ppc_bc (code, PPC_BR_FALSE, PPC_BR_EQ, 0); #endif - ppc_ldptr (code, ppc_r0, (sizeof (gpointer) * item->value.vtable_slot), ppc_r11); - ppc_ldptr (code, ppc_r11, PPC_RET_ADDR_OFFSET, ppc_sp); + ppc_ldptr (code, ppc_r0, (sizeof (gpointer) * item->value.vtable_slot), ppc_r12); + ppc_ldptr (code, ppc_r12, PPC_RET_ADDR_OFFSET, ppc_sp); ppc_mtctr (code, ppc_r0); ppc_bcctr (code, PPC_BR_ALWAYS, 0); #if ENABLE_WRONG_METHOD_CHECK @@ -5802,17 +5802,17 @@ mono_arch_emit_load_got_addr (guint8 *st * Emit code to load the contents of the GOT slot identified by TRAMP_TYPE and * TARGET from the mscorlib GOT in full-aot code. * On PPC, the GOT address is assumed to be in r30, and the result is placed into - * r11. + * r12. */ guint8* mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target) { /* Load the mscorlib got address */ - ppc_ldptr (code, ppc_r11, sizeof (gpointer), ppc_r30); + ppc_ldptr (code, ppc_r12, sizeof (gpointer), ppc_r30); *ji = mono_patch_info_list_prepend (*ji, code - start, tramp_type, target); /* arch_emit_got_access () patches this */ ppc_load32 (code, ppc_r0, 0); - ppc_ldptr_indexed (code, ppc_r11, ppc_r11, ppc_r0); + ppc_ldptr_indexed (code, ppc_r12, ppc_r12, ppc_r0); return code; } @@ -5835,8 +5835,8 @@ mono_arch_set_breakpoint (MonoJitInfo *j guint8 *code = ip; guint8 *orig_code = code; - ppc_load_sequence (code, ppc_r11, (gsize)bp_trigger_page); - ppc_ldptr (code, ppc_r11, 0, ppc_r11); + ppc_load_sequence (code, ppc_r12, (gsize)bp_trigger_page); + ppc_ldptr (code, ppc_r12, 0, ppc_r12); g_assert (code - orig_code == BREAKPOINT_SIZE); Index: mono-3.4.0/mono/mini/mini-ppc.h =================================================================== --- mono-3.4.0.orig/mono/mini/mini-ppc.h +++ mono-3.4.0/mono/mini/mini-ppc.h @@ -105,7 +105,7 @@ typedef struct MonoCompileArch { #define MONO_ARCH_GC_MAPS_SUPPORTED 1 /* Parameters used by the register allocator */ -#define MONO_ARCH_CALLEE_REGS ((0xff << ppc_r3) | (1 << ppc_r11) | (1 << ppc_r12)) +#define MONO_ARCH_CALLEE_REGS ((0xff << ppc_r3) | (1 << ppc_r12) | (1 << ppc_r11)) #define MONO_ARCH_CALLEE_SAVED_REGS (0xfffff << ppc_r13) /* ppc_13 - ppc_31 */ #if defined(__APPLE__) || defined(__mono_ppc64__) @@ -179,9 +179,9 @@ typedef struct MonoCompileArch { #define MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE #define MONO_ARCH_HAVE_IMT 1 -#define MONO_ARCH_IMT_REG ppc_r12 +#define MONO_ARCH_IMT_REG ppc_r11 -#define MONO_ARCH_VTABLE_REG ppc_r12 +#define MONO_ARCH_VTABLE_REG ppc_r11 #define MONO_ARCH_RGCTX_REG MONO_ARCH_IMT_REG #define MONO_ARCH_NO_IOV_CHECK 1 Index: mono-3.4.0/mono/mini/tramp-ppc.c =================================================================== --- mono-3.4.0.orig/mono/mini/tramp-ppc.c +++ mono-3.4.0/mono/mini/tramp-ppc.c @@ -300,10 +300,10 @@ mono_arch_create_generic_trampoline (Mon 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); @@ -311,33 +311,33 @@ mono_arch_create_generic_trampoline (Mon 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,10 +361,10 @@ mono_arch_create_generic_trampoline (Mon 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); @@ -389,20 +389,20 @@ mono_arch_create_generic_trampoline (Mon * 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 +424,8 @@ mono_arch_create_generic_trampoline (Mon */ /* 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 @@ -596,9 +596,9 @@ mono_arch_create_rgctx_lazy_fetch_trampo 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 +658,9 @@ mono_arch_create_generic_class_init_tram 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,
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
