[Qemu-devel] [PATCH 1/6] TCG/i386: use iargs or oargs instead of register names

[Blue Swirl]

Don't use register names directly but iargs or oargs tables. Later it will be
easier to shift the registers used.

Signed-off-by: Blue Swirl <address@hidden>
---
 tcg/i386/tcg-target.c |   75 +++++++++++++++++++++++++++++-------------------
 1 files changed, 45 insertions(+), 30 deletions(-)

diff --git a/tcg/i386/tcg-target.c b/tcg/i386/tcg-target.c
index dc81572..c74bd1a 100644
--- a/tcg/i386/tcg-target.c
+++ b/tcg/i386/tcg-target.c
@@ -186,12 +186,12 @@ static int
target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
         ct->ct |= TCG_CT_REG;
         if (TCG_TARGET_REG_BITS == 64) {
             tcg_regset_set32(ct->u.regs, 0, 0xffff);
-            tcg_regset_reset_reg(ct->u.regs, TCG_REG_RSI);
-            tcg_regset_reset_reg(ct->u.regs, TCG_REG_RDI);
+            tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[0]);
+            tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[1]);
         } else {
             tcg_regset_set32(ct->u.regs, 0, 0xff);
-            tcg_regset_reset_reg(ct->u.regs, TCG_REG_EAX);
-            tcg_regset_reset_reg(ct->u.regs, TCG_REG_EDX);
+            tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[0]);
+            tcg_regset_reset_reg(ct->u.regs, tcg_target_call_iarg_regs[1]);
         }
         break;

@@ -1196,35 +1196,38 @@ static void tcg_out_qemu_ld(TCGContext *s,
const TCGArg *args,

     switch(opc) {
     case 0 | 4:
-        tcg_out_ext8s(s, data_reg, TCG_REG_EAX, P_REXW);
+        tcg_out_ext8s(s, data_reg, tcg_target_call_oarg_regs[0], P_REXW);
         break;
     case 1 | 4:
-        tcg_out_ext16s(s, data_reg, TCG_REG_EAX, P_REXW);
+        tcg_out_ext16s(s, data_reg, tcg_target_call_oarg_regs[0], P_REXW);
         break;
     case 0:
-        tcg_out_ext8u(s, data_reg, TCG_REG_EAX);
+        tcg_out_ext8u(s, data_reg, tcg_target_call_oarg_regs[0]);
         break;
     case 1:
-        tcg_out_ext16u(s, data_reg, TCG_REG_EAX);
+        tcg_out_ext16u(s, data_reg, tcg_target_call_oarg_regs[0]);
         break;
     case 2:
-        tcg_out_mov(s, TCG_TYPE_I32, data_reg, TCG_REG_EAX);
+        tcg_out_mov(s, TCG_TYPE_I32, data_reg, tcg_target_call_oarg_regs[0]);
         break;
 #if TCG_TARGET_REG_BITS == 64
     case 2 | 4:
-        tcg_out_ext32s(s, data_reg, TCG_REG_EAX);
+        tcg_out_ext32s(s, data_reg, tcg_target_call_oarg_regs[0]);
         break;
 #endif
     case 3:
         if (TCG_TARGET_REG_BITS == 64) {
-            tcg_out_mov(s, TCG_TYPE_I64, data_reg, TCG_REG_RAX);
+            tcg_out_mov(s, TCG_TYPE_I64, data_reg,
+                        tcg_target_call_oarg_regs[0]);
         } else if (data_reg == TCG_REG_EDX) {
             /* xchg %edx, %eax */
             tcg_out_opc(s, OPC_XCHG_ax_r32 + TCG_REG_EDX, 0, 0, 0);
             tcg_out_mov(s, TCG_TYPE_I32, data_reg2, TCG_REG_EAX);
         } else {
-            tcg_out_mov(s, TCG_TYPE_I32, data_reg, TCG_REG_EAX);
-            tcg_out_mov(s, TCG_TYPE_I32, data_reg2, TCG_REG_EDX);
+            tcg_out_mov(s, TCG_TYPE_I32, data_reg,
+                        tcg_target_call_oarg_regs[0]);
+            tcg_out_mov(s, TCG_TYPE_I32, data_reg2,
+                        tcg_target_call_oarg_regs[1]);
         }
         break;
     default:
@@ -1246,9 +1249,12 @@ static void tcg_out_qemu_ld(TCGContext *s,
const TCGArg *args,
                use the ADDR32 prefix.  For now, do nothing.  */

             if (offset != GUEST_BASE) {
-                tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_RDI, GUEST_BASE);
-                tgen_arithr(s, ARITH_ADD + P_REXW, TCG_REG_RDI, base);
-                base = TCG_REG_RDI, offset = 0;
+                tcg_out_movi(s, TCG_TYPE_I64, tcg_target_call_iarg_regs[0],
+                             GUEST_BASE);
+                tgen_arithr(s, ARITH_ADD + P_REXW,
+                            tcg_target_call_iarg_regs[0], base);
+                base = tcg_target_call_iarg_regs[0];
+                offset = 0;
             }
         }

@@ -1361,37 +1367,43 @@ static void tcg_out_qemu_st(TCGContext *s,
const TCGArg *args,
     /* XXX: move that code at the end of the TB */
     if (TCG_TARGET_REG_BITS == 64) {
         tcg_out_mov(s, (opc == 3 ? TCG_TYPE_I64 : TCG_TYPE_I32),
-                    TCG_REG_RSI, data_reg);
-        tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_RDX, mem_index);
+                    tcg_target_call_iarg_regs[1], data_reg);
+        tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2],
+                     mem_index);
         stack_adjust = 0;
     } else if (TARGET_LONG_BITS == 32) {
-        tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_EDX, data_reg);
+        tcg_out_mov(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[1], data_reg);
         if (opc == 3) {
-            tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_ECX, data_reg2);
+            tcg_out_mov(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2],
+                        data_reg2);
             tcg_out_pushi(s, mem_index);
             stack_adjust = 4;
         } else {
-            tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_ECX, mem_index);
+            tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2],
+                         mem_index);
             stack_adjust = 0;
         }
     } else {
         if (opc == 3) {
-            tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_EDX, args[addrlo_idx + 1]);
+            tcg_out_mov(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[1],
+                        args[addrlo_idx + 1]);
             tcg_out_pushi(s, mem_index);
             tcg_out_push(s, data_reg2);
             tcg_out_push(s, data_reg);
             stack_adjust = 12;
         } else {
-            tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_EDX, args[addrlo_idx + 1]);
+            tcg_out_mov(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[1],
+                        args[addrlo_idx + 1]);
             switch(opc) {
             case 0:
-                tcg_out_ext8u(s, TCG_REG_ECX, data_reg);
+                tcg_out_ext8u(s, tcg_target_call_iarg_regs[2], data_reg);
                 break;
             case 1:
-                tcg_out_ext16u(s, TCG_REG_ECX, data_reg);
+                tcg_out_ext16u(s, tcg_target_call_iarg_regs[2], data_reg);
                 break;
             case 2:
-                tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_ECX, data_reg);
+                tcg_out_mov(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[2],
+                            data_reg);
                 break;
             }
             tcg_out_pushi(s, mem_index);
@@ -1423,9 +1435,12 @@ static void tcg_out_qemu_st(TCGContext *s,
const TCGArg *args,
                use the ADDR32 prefix.  For now, do nothing.  */

             if (offset != GUEST_BASE) {
-                tcg_out_movi(s, TCG_TYPE_I64, TCG_REG_RDI, GUEST_BASE);
-                tgen_arithr(s, ARITH_ADD + P_REXW, TCG_REG_RDI, base);
-                base = TCG_REG_RDI, offset = 0;
+                tcg_out_movi(s, TCG_TYPE_I64, tcg_target_call_iarg_regs[0],
+                             GUEST_BASE);
+                tgen_arithr(s, ARITH_ADD + P_REXW,
+                            tcg_target_call_iarg_regs[0], base);
+                base = tcg_target_call_iarg_regs[0];
+                offset = 0;
             }
         }

@@ -1451,7 +1466,7 @@ static inline void tcg_out_op(TCGContext *s,
TCGOpcode opc,

     switch(opc) {
     case INDEX_op_exit_tb:
-        tcg_out_movi(s, TCG_TYPE_PTR, TCG_REG_EAX, args[0]);
+        tcg_out_movi(s, TCG_TYPE_PTR, tcg_target_call_oarg_regs[0], args[0]);
         tcg_out_jmp(s, (tcg_target_long) tb_ret_addr);
         break;
     case INDEX_op_goto_tb:
-- 
1.6.2.4

0001-TCG-i386-use-iargs-or-oargs-instead-of-register-name.patch
Description: Text Data