rpm/mono-core
SHA256
1
0
Fork 0
forked from pool/mono-core
Code Pull Requests Activity
24dcde2c02
mono-core/mono-core-ppc64le-swr11r12.diff
Stephen Shaw 24dcde2c02 - Refresh patches 
- Update to 3.4.0
  * Revamped HttpWebRequest/ServicePoint stack
    - Should properly reuse connections.
    - Uses the specified idle times
    - NTLM support has been improved.
    - SSL/TLS operations on via async APIs are now
      implemented using async patterns internally
      to greatly alleviate Thread Pool abuse.
  * Network stack
    - Now allows developers to control which cipher
      suites to use with TLS/SSL.
  * ARM
    - Emit shorter floating point operations when possible
    - Hard float support: Mono now should work on Linux
      distributions which uses a hard float (armhf) ABI,
      like the Raspberry PI.
      Notes: Homogeneous floating point aggregates are not
      yet supported on armhf.
  * Documentation
    - Updated documentation stubs to the 4.5 .NET API.
  * mono-api-html
    - Now supports regular expressions when specifying
      members to ignore (e.g. mono-api-html -i 'INSCopying$')

OBS-URL: https://build.opensuse.org/package/show/Mono:Factory/mono-core?expand=0&rev=129
2014-05-29 06:10:29 +00:00

1169 lines
51 KiB
Diff
Raw Blame History

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,
View Git Blame Copy Permalink