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. diff -x 'Makefile*' -x 'config*' -x '*.m4' -urp mono-3.2.3.orig/mono/arch/ppc/ppc-codegen.h mono-3.2.3/mono/arch/ppc/ppc-codegen.h --- mono-3.2.3.orig/mono/arch/ppc/ppc-codegen.h 2014-01-04 04:16:29.000000000 +0000 +++ mono-3.2.3/mono/arch/ppc/ppc-codegen.h 2014-01-04 19:04:29.000000000 +0000 @@ -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 diff -x 'Makefile*' -x 'config*' -x '*.m4' -urp mono-3.2.3.orig/mono/mini/aot-compiler.c mono-3.2.3/mono/mini/aot-compiler.c --- mono-3.2.3.orig/mono/mini/aot-compiler.c 2013-09-13 22:38:21.000000000 +0000 +++ mono-3.2.3/mono/mini/aot-compiler.c 2014-01-04 19:17:32.000000000 +0000 @@ -1830,14 +1830,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); @@ -1848,18 +1848,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 */ diff -x 'Makefile*' -x 'config*' -x '*.m4' -urp mono-3.2.3.orig/mono/mini/exceptions-ppc.c mono-3.2.3/mono/mini/exceptions-ppc.c --- mono-3.2.3.orig/mono/mini/exceptions-ppc.c 2013-09-13 22:22:23.000000000 +0000 +++ mono-3.2.3/mono/mini/exceptions-ppc.c 2014-01-04 19:04:35.000000000 +0000 @@ -385,13 +385,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); @@ -424,10 +424,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); diff -x 'Makefile*' -x 'config*' -x '*.m4' -urp mono-3.2.3.orig/mono/mini/mini-mips.c mono-3.2.3/mono/mini/mini-mips.c --- mono-3.2.3.orig/mono/mini/mini-mips.c 2013-09-13 22:22:14.000000000 +0000 +++ mono-3.2.3/mono/mini/mini-mips.c 2014-01-04 19:04:36.000000000 +0000 @@ -3299,8 +3299,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; @@ -3321,8 +3321,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; @@ -3713,8 +3713,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 */ diff -x 'Makefile*' -x 'config*' -x '*.m4' -urp mono-3.2.3.orig/mono/mini/mini-ppc.c mono-3.2.3/mono/mini/mini-ppc.c --- mono-3.2.3.orig/mono/mini/mini-ppc.c 2014-01-04 04:16:29.000000000 +0000 +++ mono-3.2.3/mono/mini/mini-ppc.c 2014-01-04 19:16:23.000000000 +0000 @@ -104,11 +104,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 @@ -119,8 +119,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 @@ -191,29 +191,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; @@ -227,12 +227,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; @@ -738,7 +738,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)); @@ -2923,7 +2923,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 { @@ -2933,8 +2933,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 @@ -3010,8 +3010,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; @@ -3032,8 +3032,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; @@ -3107,8 +3107,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); @@ -3142,8 +3142,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); @@ -3155,8 +3155,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); @@ -3168,8 +3168,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); @@ -3725,7 +3725,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) { @@ -3733,26 +3733,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 { @@ -3761,27 +3761,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 @@ -3853,7 +3853,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); @@ -3871,9 +3871,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: @@ -3886,8 +3886,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 */ @@ -3897,9 +3897,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); @@ -3943,8 +3943,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; } @@ -3957,8 +3957,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); @@ -4064,11 +4064,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 (); @@ -4078,8 +4078,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); @@ -4091,8 +4091,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); @@ -4105,8 +4105,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); @@ -4118,8 +4118,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); } } @@ -5630,15 +5630,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]; @@ -5654,8 +5654,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); @@ -5687,8 +5687,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 @@ -5827,17 +5827,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; } @@ -5860,8 +5860,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); diff -x 'Makefile*' -x 'config*' -x '*.m4' -urp mono-3.2.3.orig/mono/mini/mini-ppc.h mono-3.2.3/mono/mini/mini-ppc.h --- mono-3.2.3.orig/mono/mini/mini-ppc.h 2014-01-04 04:16:29.000000000 +0000 +++ mono-3.2.3/mono/mini/mini-ppc.h 2014-01-04 19:04:36.000000000 +0000 @@ -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 diff -x 'Makefile*' -x 'config*' -x '*.m4' -urp mono-3.2.3.orig/mono/mini/tramp-ppc.c mono-3.2.3/mono/mini/tramp-ppc.c --- mono-3.2.3.orig/mono/mini/tramp-ppc.c 2013-09-13 22:22:19.000000000 +0000 +++ mono-3.2.3/mono/mini/tramp-ppc.c 2014-01-04 19:16:53.000000000 +0000 @@ -303,10 +303,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); @@ -314,33 +314,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) @@ -364,10 +364,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); @@ -392,20 +392,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)); @@ -427,8 +427,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 @@ -604,9 +604,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), @@ -666,9 +666,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,