Use ppc_r12 for some global call sequences

After the mechanical exchange of ppc_r11 and ppc_r12 we now can use
ppc_r12 for global calls to hold the callees address without clobbering
r11 (which potentially contains IMT_REG, VTABLE_REG and RGCTX_REG).
We don't need to change all indirect calls, only those potentially reaching
functions containing a TOC setup based on r12 (in particular functions
in shared libs).  As the instruction sequence patcher can only deal
with one destination register we also need to make some additional
calls use r12.  We probably should convert all calls that currently
use r0 to use r12 if no other conflicts arise but this is enough to build.

Author: Michael Matz <matz@suse.de>
Origin: https://build.opensuse.org/request/show/225490
Changes: Mauricio Faria de Oliveira <mauricfo@linux.vnet.ibm.com>

Signed-off-by: Mauricio Faria de Oliveira <mauricfo@linux.vnet.ibm.com>

diff --git a/mono/mini/exceptions-ppc.c b/mono/mini/exceptions-ppc.c
index c1f982d84b265567414544b24957aee5dc11e7de..d9ae91e05aeb77a29aa799443ee78131fbfdeaa1 100644 (file)
--- a/mono/mini/exceptions-ppc.c
+++ b/mono/mini/exceptions-ppc.c
@@ -391,8 +391,8 @@ mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info, int corli
                        ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
                } else {
                        ppc_load (code, ppc_r3, (gulong)mono_defaults.corlib);
-                       ppc_load_func (code, ppc_r0, mono_exception_from_token);
-                       ppc_mtctr (code, ppc_r0);
+                       ppc_load_func (code, PPC_CALL_REG, mono_exception_from_token);
+                       ppc_mtctr (code, PPC_CALL_REG);
                        ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
                }
        }
@@ -426,8 +426,8 @@ mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info, int corli
                ppc_mtctr (code, ppc_r12);
                ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
        } else {
-               ppc_load_func (code, ppc_r0, mono_ppc_throw_exception);
-               ppc_mtctr (code, ppc_r0);
+               ppc_load_func (code, PPC_CALL_REG, mono_ppc_throw_exception);
+               ppc_mtctr (code, PPC_CALL_REG);
                ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
        }
        /* we should never reach this breakpoint */

diff --git a/mono/mini/mini-ppc.c b/mono/mini/mini-ppc.c
index 31dd5c284029557d8ebebb2999a227d1551c7d57..594a72e06b10430a1967798a5203bdecf951dbfe 100644 (file)
--- a/mono/mini/mini-ppc.c
+++ b/mono/mini/mini-ppc.c
@@ -1789,8 +1789,8 @@ mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean ena
 
        ppc_load_ptr (code, ppc_r3, cfg->method);
        ppc_li (code, ppc_r4, 0); /* NULL ebp for now */
-       ppc_load_func (code, ppc_r0, func);
-       ppc_mtlr (code, ppc_r0);
+       ppc_load_func (code, PPC_CALL_REG, func);
+       ppc_mtlr (code, PPC_CALL_REG);
        ppc_blrl (code);
        return code;
 }
@@ -1887,8 +1887,8 @@ mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolea
        }
 
        ppc_load_ptr (code, ppc_r3, cfg->method);
-       ppc_load_func (code, ppc_r0, func);
-       ppc_mtlr (code, ppc_r0);
+       ppc_load_func (code, PPC_CALL_REG, func);
+       ppc_mtlr (code, PPC_CALL_REG);
        ppc_blrl (code);
 
        switch (save_mode) {
@@ -2933,7 +2933,7 @@ ppc_patch_full (guchar *code, const guchar *target, gboolean is_fd)
 
                        if (!is_fd) {
                                guint8 *buf = (guint8*)&seq [5];
-                               ppc_mr (buf, ppc_r0, ppc_r12);
+                               ppc_mr (buf, PPC_CALL_REG, ppc_r12);
                                ppc_nop (buf);
                        }
                } else {
@@ -2946,7 +2946,7 @@ ppc_patch_full (guchar *code, const guchar *target, gboolean is_fd)
                /* 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);
+               ppc_load_ptr_sequence (code, PPC_CALL_REG, target);
 #endif
                mono_arch_flush_icache ((guint8*)seq, 28);
 #else
@@ -2962,8 +2962,8 @@ ppc_patch_full (guchar *code, const guchar *target, gboolean is_fd)
                g_assert ((seq [2] >> 26) == 31);
                g_assert (seq [3] == 0x4e800021 || seq [3] == 0x4e800020 || seq [3] == 0x4e800420);
                /* FIXME: make this thread safe */
-               ppc_lis (code, ppc_r0, (guint32)(target) >> 16);
-               ppc_ori (code, ppc_r0, ppc_r0, (guint32)(target) & 0xffff);
+               ppc_lis (code, PPC_CALL_REG, (guint32)(target) >> 16);
+               ppc_ori (code, PPC_CALL_REG, PPC_CALL_REG, (guint32)(target) & 0xffff);
                mono_arch_flush_icache (code - 8, 8);
 #endif
        } else {
@@ -3381,8 +3381,8 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD, 
                                             (gpointer)"mono_break");
                        if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
-                               ppc_load_func (code, ppc_r0, 0);
-                               ppc_mtlr (code, ppc_r0);
+                               ppc_load_func (code, PPC_CALL_REG, 0);
+                               ppc_mtlr (code, PPC_CALL_REG);
                                ppc_blrl (code);
                        } else {
                                ppc_bl (code, 0);
@@ -3829,8 +3829,8 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        else
                                mono_add_patch_info (cfg, offset, MONO_PATCH_INFO_ABS, call->fptr);
                        if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
-                               ppc_load_func (code, ppc_r0, 0);
-                               ppc_mtlr (code, ppc_r0);
+                               ppc_load_func (code, PPC_CALL_REG, 0);
+                               ppc_mtlr (code, PPC_CALL_REG);
                                ppc_blrl (code);
                        } else {
                                ppc_bl (code, 0);
@@ -3923,8 +3923,8 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD, 
                                             (gpointer)"mono_arch_throw_exception");
                        if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
-                               ppc_load_func (code, ppc_r0, 0);
-                               ppc_mtlr (code, ppc_r0);
+                               ppc_load_func (code, PPC_CALL_REG, 0);
+                               ppc_mtlr (code, PPC_CALL_REG);
                                ppc_blrl (code);
                        } else {
                                ppc_bl (code, 0);
@@ -3937,8 +3937,8 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb)
                        mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD, 
                                             (gpointer)"mono_arch_rethrow_exception");
                        if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
-                               ppc_load_func (code, ppc_r0, 0);
-                               ppc_mtlr (code, ppc_r0);
+                               ppc_load_func (code, PPC_CALL_REG, 0);
+                               ppc_mtlr (code, PPC_CALL_REG);
                                ppc_blrl (code);
                        } else {
                                ppc_bl (code, 0);
@@ -5098,8 +5098,8 @@ mono_arch_emit_prolog (MonoCompile *cfg)
                        mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_INTERNAL_METHOD, 
                                     (gpointer)"mono_get_lmf_addr");
                        if ((FORCE_INDIR_CALL || cfg->method->dynamic) && !cfg->compile_aot) {
-                               ppc_load_func (code, ppc_r0, 0);
-                               ppc_mtlr (code, ppc_r0);
+                               ppc_load_func (code, PPC_CALL_REG, 0);
+                               ppc_mtlr (code, PPC_CALL_REG);
                                ppc_blrl (code);
                        } else {
                                ppc_bl (code, 0);
@@ -5408,8 +5408,8 @@ mono_arch_emit_exceptions (MonoCompile *cfg)
                        patch_info->data.name = "mono_arch_throw_corlib_exception";
                        patch_info->ip.i = code - cfg->native_code;
                        if (FORCE_INDIR_CALL || cfg->method->dynamic) {
-                               ppc_load_func (code, ppc_r0, 0);
-                               ppc_mtctr (code, ppc_r0);
+                               ppc_load_func (code, PPC_CALL_REG, 0);
+                               ppc_mtctr (code, PPC_CALL_REG);
                                ppc_bcctr (code, PPC_BR_ALWAYS, 0);
                        } else {
                                ppc_bl (code, 0);

diff --git a/mono/mini/mini-ppc.h b/mono/mini/mini-ppc.h
index de7d5bbe6cb6ebcf00793fb33ce09e0a6f664633..7131aad0e14519330b8fae30cc48fa1b3455f279 100644 (file)
--- a/mono/mini/mini-ppc.h
+++ b/mono/mini/mini-ppc.h
@@ -170,6 +170,8 @@ typedef struct MonoCompileArch {
 #define PPC_FIRST_FPARG_REG ppc_f1
 #endif
 
+#define PPC_CALL_REG ppc_r12
+
 #if defined(HAVE_WORKING_SIGALTSTACK) && !defined(__APPLE__)
 #define MONO_ARCH_SIGSEGV_ON_ALTSTACK 1
 #define MONO_ARCH_SIGNAL_STACK_SIZE (12 * 1024)

diff --git a/mono/mini/tramp-ppc.c b/mono/mini/tramp-ppc.c
index 0df8750e1c2db89624d0fb4421ae6505f643598e..1b2cc1dfb91f0b043c62cfcef28161ddd6f8880b 100644 (file)
--- a/mono/mini/tramp-ppc.c
+++ b/mono/mini/tramp-ppc.c
@@ -301,8 +301,8 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf
                ppc_mtlr (code, ppc_r12);
                ppc_blrl (code);
        }  else {
-               ppc_load_func (code, ppc_r0, mono_get_lmf_addr);
-               ppc_mtlr (code, ppc_r0);
+               ppc_load_func (code, PPC_CALL_REG, mono_get_lmf_addr);
+               ppc_mtlr (code, PPC_CALL_REG);
                ppc_blrl (code);
        }
        /* we build the MonoLMF structure on the stack - see mini-ppc.h
@@ -363,8 +363,8 @@ mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInf
                ppc_blrl (code);
        } else {
                tramp_handler = mono_get_trampoline_func (tramp_type);
-               ppc_load_func (code, ppc_r0, tramp_handler);
-               ppc_mtlr (code, ppc_r0);
+               ppc_load_func (code, PPC_CALL_REG, tramp_handler);
+               ppc_mtlr (code, PPC_CALL_REG);
                ppc_blrl (code);
        }