From 5767c23140f2c92b899d9caeaa8e08711cb63868 Mon Sep 17 00:00:00 2001

From: Richard Henderson <rth@twiddle.net>

Date: Sun, 25 Mar 2012 21:21:46 +0200

Subject: [PATCH] tcg-sparc: Clean up cruft stemming from attempts to use

 global registers.

Don't use -ffixed-gN.  Don't link statically.  Don't save/restore

AREG0 around calls.  Don't allocate space on the stack for AREG0 save.

Signed-off-by: Richard Henderson <rth@twiddle.net>

Signed-off-by: Michael Roth <mdroth@linux.vnet.ibm.com>

---

 configure              | 12 -----------

 tcg/sparc/tcg-target.c | 55 +++++++++++++++++---------------------------------

 tcg/sparc/tcg-target.h | 18 +++++++----------

 3 files changed, 26 insertions(+), 59 deletions(-)

diff --git a/configure b/configure

index 9139b5c..8ffddf4 100755

--- a/configure

+++ b/configure

@@ -868,19 +868,11 @@ case "$cpu" in

     sparc)

            LDFLAGS="-m32 $LDFLAGS"

            QEMU_CFLAGS="-m32 -mcpu=ultrasparc $QEMU_CFLAGS"

-           QEMU_CFLAGS="-ffixed-g2 -ffixed-g3 $QEMU_CFLAGS"

-           if test "$solaris" = "no" ; then

-             QEMU_CFLAGS="-ffixed-g1 -ffixed-g6 $QEMU_CFLAGS"

-           fi

            host_guest_base="yes"

            ;;

     sparc64)

            LDFLAGS="-m64 $LDFLAGS"

            QEMU_CFLAGS="-m64 -mcpu=ultrasparc $QEMU_CFLAGS"

-           QEMU_CFLAGS="-ffixed-g5 -ffixed-g6 -ffixed-g7 $QEMU_CFLAGS"

-           if test "$solaris" != "no" ; then

-             QEMU_CFLAGS="-ffixed-g1 $QEMU_CFLAGS"

-           fi

            host_guest_base="yes"

            ;;

     s390)

@@ -4055,10 +4047,6 @@ fi

 if test "$target_linux_user" = "yes" -o "$target_bsd_user" = "yes" ; then

   case "$ARCH" in

-  sparc)

-    # -static is used to avoid g1/g3 usage by the dynamic linker

-    ldflags="$linker_script -static $ldflags"

-    ;;

   alpha | s390x)

     # The default placement of the application is fine.

     ;;

diff --git a/tcg/sparc/tcg-target.c b/tcg/sparc/tcg-target.c

index 9ab5746..e625aa3 100644

--- a/tcg/sparc/tcg-target.c

+++ b/tcg/sparc/tcg-target.c

@@ -161,7 +161,6 @@ static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)

         tcg_regset_reset_reg(ct->u.regs, TCG_REG_O0);

         tcg_regset_reset_reg(ct->u.regs, TCG_REG_O1);

         tcg_regset_reset_reg(ct->u.regs, TCG_REG_O2);

-        tcg_regset_reset_reg(ct->u.regs, TCG_REG_O3);

         break;

     case 'I':

         ct->ct |= TCG_CT_CONST_S11;

@@ -681,11 +680,22 @@ static void tcg_out_setcond2_i32(TCGContext *s, TCGCond cond, TCGArg ret,

 /* Generate global QEMU prologue and epilogue code */

 static void tcg_target_qemu_prologue(TCGContext *s)

 {

-    tcg_set_frame(s, TCG_REG_I6, TCG_TARGET_CALL_STACK_OFFSET,

-                  CPU_TEMP_BUF_NLONGS * (int)sizeof(long));

+    int tmp_buf_size, frame_size;

+

+    /* The TCG temp buffer is at the top of the frame, immediately

+       below the frame pointer.  */

+    tmp_buf_size = CPU_TEMP_BUF_NLONGS * (int)sizeof(long);

+    tcg_set_frame(s, TCG_REG_I6, TCG_TARGET_STACK_BIAS - tmp_buf_size,

+                  tmp_buf_size);

+

+    /* TCG_TARGET_CALL_STACK_OFFSET includes the stack bias, but is

+       otherwise the minimal frame usable by callees.  */

+    frame_size = TCG_TARGET_CALL_STACK_OFFSET - TCG_TARGET_STACK_BIAS;

+    frame_size += TCG_STATIC_CALL_ARGS_SIZE + tmp_buf_size;

+    frame_size += TCG_TARGET_STACK_ALIGN - 1;

+    frame_size &= -TCG_TARGET_STACK_ALIGN;

     tcg_out32(s, SAVE | INSN_RD(TCG_REG_O6) | INSN_RS1(TCG_REG_O6) |

-              INSN_IMM13(-(TCG_TARGET_STACK_MINFRAME +

-                           CPU_TEMP_BUF_NLONGS * (int)sizeof(long))));

+              INSN_IMM13(-frame_size));

 #ifdef CONFIG_USE_GUEST_BASE

     if (GUEST_BASE != 0) {

@@ -698,6 +708,8 @@ static void tcg_target_qemu_prologue(TCGContext *s)

               INSN_RS2(TCG_REG_G0));

     /* delay slot */

     tcg_out_nop(s);

+

+    /* No epilogue required.  We issue ret + restore directly in the TB.  */

 }

 #if defined(CONFIG_SOFTMMU)

@@ -880,12 +892,6 @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, int sizeop)

     tcg_out_mov(s, TCG_TYPE_REG, tcg_target_call_iarg_regs[n++],

                 args[addrlo_idx]);

-    /* Store AREG0 in stack to avoid ugly glibc bugs that mangle

-       global registers */

-    tcg_out_st(s, TCG_TYPE_REG, TCG_AREG0, TCG_REG_CALL_STACK,

-               TCG_TARGET_CALL_STACK_OFFSET - TCG_STATIC_CALL_ARGS_SIZE -

-               sizeof(long));

-

     /* qemu_ld_helper[s_bits](arg0, arg1) */

     tcg_out32(s, CALL | ((((tcg_target_ulong)qemu_ld_helpers[s_bits]

                            - (tcg_target_ulong)s->code_ptr) >> 2)

@@ -893,11 +899,6 @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, int sizeop)

     /* delay slot */

     tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[n], memi);

-    /* Reload AREG0.  */

-    tcg_out_ld(s, TCG_TYPE_REG, TCG_AREG0, TCG_REG_CALL_STACK,

-               TCG_TARGET_CALL_STACK_OFFSET - TCG_STATIC_CALL_ARGS_SIZE -

-               sizeof(long));

-

     n = tcg_target_call_oarg_regs[0];

     /* datalo = sign_extend(arg0) */

     switch (sizeop) {

@@ -1011,12 +1012,6 @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, int sizeop)

     }

     tcg_out_mov(s, TCG_TYPE_REG, tcg_target_call_iarg_regs[n++], datalo);

-    /* Store AREG0 in stack to avoid ugly glibc bugs that mangle

-       global registers */

-    tcg_out_st(s, TCG_TYPE_REG, TCG_AREG0, TCG_REG_CALL_STACK,

-               TCG_TARGET_CALL_STACK_OFFSET - TCG_STATIC_CALL_ARGS_SIZE -

-               sizeof(long));

-

     /* qemu_st_helper[s_bits](arg0, arg1, arg2) */

     tcg_out32(s, CALL | ((((tcg_target_ulong)qemu_st_helpers[sizeop]

                            - (tcg_target_ulong)s->code_ptr) >> 2)

@@ -1024,11 +1019,6 @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, int sizeop)

     /* delay slot */

     tcg_out_movi(s, TCG_TYPE_REG, tcg_target_call_iarg_regs[n], memi);

-    /* Reload AREG0.  */

-    tcg_out_ld(s, TCG_TYPE_REG, TCG_AREG0, TCG_REG_CALL_STACK,

-               TCG_TARGET_CALL_STACK_OFFSET - TCG_STATIC_CALL_ARGS_SIZE -

-               sizeof(long));

-

     *label_ptr |= INSN_OFF19((unsigned long)s->code_ptr -

                              (unsigned long)label_ptr);

 #else

@@ -1091,15 +1081,8 @@ static inline void tcg_out_op(TCGContext *s, TCGOpcode opc, const TCGArg *args,

             tcg_out32(s, JMPL | INSN_RD(TCG_REG_O7) | INSN_RS1(TCG_REG_I5) |

                       INSN_RS2(TCG_REG_G0));

         }

-        /* Store AREG0 in stack to avoid ugly glibc bugs that mangle

-           global registers */

-        // delay slot

-        tcg_out_st(s, TCG_TYPE_REG, TCG_AREG0, TCG_REG_CALL_STACK,

-                   TCG_TARGET_CALL_STACK_OFFSET - TCG_STATIC_CALL_ARGS_SIZE -

-                   sizeof(long));

-        tcg_out_ld(s, TCG_TYPE_REG, TCG_AREG0, TCG_REG_CALL_STACK,

-                   TCG_TARGET_CALL_STACK_OFFSET - TCG_STATIC_CALL_ARGS_SIZE -

-                   sizeof(long));

+        /* delay slot */

+        tcg_out_nop(s);

         break;

     case INDEX_op_jmp:

     case INDEX_op_br:

diff --git a/tcg/sparc/tcg-target.h b/tcg/sparc/tcg-target.h

index ee154d0..6314ffb 100644

--- a/tcg/sparc/tcg-target.h

+++ b/tcg/sparc/tcg-target.h

@@ -66,20 +66,16 @@ typedef enum {

 #define TCG_CT_CONST_S13 0x200

 /* used for function call generation */

-#define TCG_REG_CALL_STACK TCG_REG_I6

+#define TCG_REG_CALL_STACK TCG_REG_O6

 #if TCG_TARGET_REG_BITS == 64

-// Reserve space for AREG0

-#define TCG_TARGET_STACK_MINFRAME (176 + 4 * (int)sizeof(long) + \

-                                   TCG_STATIC_CALL_ARGS_SIZE)

-#define TCG_TARGET_CALL_STACK_OFFSET (2047 - 16)

-#define TCG_TARGET_STACK_ALIGN 16

+#define TCG_TARGET_STACK_BIAS           2047

+#define TCG_TARGET_STACK_ALIGN          16

+#define TCG_TARGET_CALL_STACK_OFFSET    (128 + 6*8 + TCG_TARGET_STACK_BIAS)

 #else

-// AREG0 + one word for alignment

-#define TCG_TARGET_STACK_MINFRAME (92 + (2 + 1) * (int)sizeof(long) + \

-                                   TCG_STATIC_CALL_ARGS_SIZE)

-#define TCG_TARGET_CALL_STACK_OFFSET TCG_TARGET_STACK_MINFRAME

-#define TCG_TARGET_STACK_ALIGN 8

+#define TCG_TARGET_STACK_BIAS           0

+#define TCG_TARGET_STACK_ALIGN          8

+#define TCG_TARGET_CALL_STACK_OFFSET    (64 + 4 + 6*4)

 #endif

 #if TCG_TARGET_REG_BITS == 64