Skip to contentSkip to conversation

target-i386: MMReg struct cleanup

PATCH Superseded Eduardo Habkost 3 participants 10 messages Nov 30, 2015 – Dec 1, 2015

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover target-i386: MMReg struct cleanup

This is an attempt to cleanup the MMXReg/XMMReg structs and make their names, fields and usage consistent.

The last 2 patches use a bit of macro magic to generate the union definitions and ensure type safety when using the field helper macros, and I am sending them as RFCs.

Eduardo Habkost (7):
target-i386/ops_sse.h: Use MMX_Q macro
target-i386: Use a _q array on MMXReg too
target-i386: Rename struct XMMReg to ZMMReg
target-i386: Rename XMM_[BWLSDQ] helpers to ZMM_*
target-i386: Define MMXReg._d field
[RFC] target-i386: Define MMREG_UNION macro [RFC] target-i386: Add suffixes to MMReg struct fields

 target-i386/cpu.h            |  76 +++++----
 target-i386/fpu_helper.c     |   8 +-
 target-i386/gdbstub.c        |   8 +-
 target-i386/helper.c         |   8 +-
 target-i386/kvm.c            |  40 ++---
 target-i386/machine.c        |  42 ++---
 target-i386/ops_sse.h        | 374 +++++++++++++++++++++----------------------
 target-i386/ops_sse_header.h |  80 ++++-----
 target-i386/translate.c      | 188 +++++++++++-----------
 9 files changed, 410 insertions(+), 414 deletions(-)
Signature · 1 line
2.1.0
#1 lore raw

PATCH 1/7 target-i386/ops_sse.h: Use MMX_Q macro

We have a MMX_Q macro in addition to MMX_{B,W,L}. Use it.

---
 target-i386/ops_sse.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
target-i386/ops_sse.h +1 -1
index 1780d1d..52ec0b0 100644
@@ -26,7 +26,7 @@
 #define B(n) MMX_B(n)
 #define W(n) MMX_W(n)
 #define L(n) MMX_L(n)
-#define Q(n) q
+#define Q(n) MMX_Q(n)
 #define SUFFIX _mmx
 #else
 #define Reg XMMReg
Signature · 1 line
2.1.0
#2 lore raw

PATCH 2/7 target-i386: Use a _q array on MMXReg too

In reply to Eduardo Habkost

Make MMXReg use the same field names used on XMMReg, so we can try to reuse macros and other code later.

---
 target-i386/cpu.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
target-i386/cpu.h +2 -2
index 84edfd0..154891e 100644
@@ -739,7 +739,7 @@ typedef union {
     uint16_t _w[4];
     uint32_t _l[2];
     float32 _s[2];
-    uint64_t q;
+    uint64_t _q[1];
 } MMXReg;
 
 typedef struct BNDReg {
@@ -777,7 +777,7 @@ typedef struct BNDCSReg {
 #define MMX_L(n) _l[n]
 #define MMX_S(n) _s[n]
 #endif
-#define MMX_Q(n) q
+#define MMX_Q(n) _q[n]
 
 typedef union {
     floatx80 d __attribute__((aligned(16)));
Signature · 1 line
2.1.0
#3 lore raw

PATCH 3/7 target-i386: Rename struct XMMReg to ZMMReg

In reply to Eduardo Habkost

The struct represents a 512-bit register, so name it accordingly.

This is just a global search+replace, no other changes are being introduced.

---
 target-i386/cpu.h            |  6 ++--
 target-i386/machine.c        | 40 ++++++++++-----------
 target-i386/ops_sse.h        | 82 ++++++++++++++++++++++----------------------
 target-i386/ops_sse_header.h | 80 +++++++++++++++++++++---------------------
 target-i386/translate.c      | 22 ++++++------
 5 files changed, 115 insertions(+), 115 deletions(-)
target-i386/cpu.h +3 -3
index 154891e..7c3e917 100644
@@ -732,7 +732,7 @@ typedef union {
     uint64_t _q[8];
     float32 _s[16];
     float64 _d[8];
-} XMMReg; /* really zmm */
+} ZMMReg;
 
 typedef union {
     uint8_t _b[8];
@@ -865,8 +865,8 @@ typedef struct CPUX86State {
     float_status mmx_status; /* for 3DNow! float ops */
     float_status sse_status;
     uint32_t mxcsr;
-    XMMReg xmm_regs[CPU_NB_REGS == 8 ? 8 : 32];
-    XMMReg xmm_t0;
+    ZMMReg xmm_regs[CPU_NB_REGS == 8 ? 8 : 32];
+    ZMMReg xmm_t0;
     MMXReg mmx_t0;
 
     uint64_t opmask_regs[NB_OPMASK_REGS];
target-i386/machine.c +20 -20
index a18e16e..d2e62ac 100644
@@ -36,15 +36,15 @@ static const VMStateDescription vmstate_xmm_reg = {
     .version_id = 1,
     .minimum_version_id = 1,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT64(XMM_Q(0), XMMReg),
-        VMSTATE_UINT64(XMM_Q(1), XMMReg),
+        VMSTATE_UINT64(XMM_Q(0), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(1), ZMMReg),
         VMSTATE_END_OF_LIST()
     }
 };
 
 #define VMSTATE_XMM_REGS(_field, _state, _start)                         \
     VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0,     \
-                             vmstate_xmm_reg, XMMReg)
+                             vmstate_xmm_reg, ZMMReg)
 
 /* YMMH format is the same as XMM, but for bits 128-255 */
 static const VMStateDescription vmstate_ymmh_reg = {
@@ -52,32 +52,32 @@ static const VMStateDescription vmstate_ymmh_reg = {
     .version_id = 1,
     .minimum_version_id = 1,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT64(XMM_Q(2), XMMReg),
-        VMSTATE_UINT64(XMM_Q(3), XMMReg),
+        VMSTATE_UINT64(XMM_Q(2), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(3), ZMMReg),
         VMSTATE_END_OF_LIST()
     }
 };
 
 #define VMSTATE_YMMH_REGS_VARS(_field, _state, _start, _v)               \
     VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, _v,    \
-                             vmstate_ymmh_reg, XMMReg)
+                             vmstate_ymmh_reg, ZMMReg)
 
 static const VMStateDescription vmstate_zmmh_reg = {
     .name = "zmmh_reg",
     .version_id = 1,
     .minimum_version_id = 1,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT64(XMM_Q(4), XMMReg),
-        VMSTATE_UINT64(XMM_Q(5), XMMReg),
-        VMSTATE_UINT64(XMM_Q(6), XMMReg),
-        VMSTATE_UINT64(XMM_Q(7), XMMReg),
+        VMSTATE_UINT64(XMM_Q(4), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(5), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(6), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(7), ZMMReg),
         VMSTATE_END_OF_LIST()
     }
 };
 
 #define VMSTATE_ZMMH_REGS_VARS(_field, _state, _start)                   \
     VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0,     \
-                             vmstate_zmmh_reg, XMMReg)
+                             vmstate_zmmh_reg, ZMMReg)
 
 #ifdef TARGET_X86_64
 static const VMStateDescription vmstate_hi16_zmm_reg = {
@@ -85,21 +85,21 @@ static const VMStateDescription vmstate_hi16_zmm_reg = {
     .version_id = 1,
     .minimum_version_id = 1,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT64(XMM_Q(0), XMMReg),
-        VMSTATE_UINT64(XMM_Q(1), XMMReg),
-        VMSTATE_UINT64(XMM_Q(2), XMMReg),
-        VMSTATE_UINT64(XMM_Q(3), XMMReg),
-        VMSTATE_UINT64(XMM_Q(4), XMMReg),
-        VMSTATE_UINT64(XMM_Q(5), XMMReg),
-        VMSTATE_UINT64(XMM_Q(6), XMMReg),
-        VMSTATE_UINT64(XMM_Q(7), XMMReg),
+        VMSTATE_UINT64(XMM_Q(0), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(1), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(2), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(3), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(4), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(5), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(6), ZMMReg),
+        VMSTATE_UINT64(XMM_Q(7), ZMMReg),
         VMSTATE_END_OF_LIST()
     }
 };
 
 #define VMSTATE_Hi16_ZMM_REGS_VARS(_field, _state, _start)               \
     VMSTATE_STRUCT_SUB_ARRAY(_field, _state, _start, CPU_NB_REGS, 0,     \
-                             vmstate_hi16_zmm_reg, XMMReg)
+                             vmstate_hi16_zmm_reg, ZMMReg)
 #endif
 
 static const VMStateDescription vmstate_bnd_regs = {
target-i386/ops_sse.h +41 -41

280 lines not on this page · raw message

target-i386/ops_sse_header.h +40 -40

110 lines not on this page · raw message

target-i386/translate.c +11 -11
index a3dd167..264a39b 100644
@@ -2602,28 +2602,28 @@ static inline void gen_ldo_env_A0(DisasContext *s, int offset)
 {
     int mem_index = s->mem_index;
     tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_A0, mem_index, MO_LEQ);
-    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(0)));
+    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(ZMMReg, XMM_Q(0)));
     tcg_gen_addi_tl(cpu_tmp0, cpu_A0, 8);
     tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_tmp0, mem_index, MO_LEQ);
-    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(1)));
+    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(ZMMReg, XMM_Q(1)));
 }
 
 static inline void gen_sto_env_A0(DisasContext *s, int offset)
 {
     int mem_index = s->mem_index;
-    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(0)));
+    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(ZMMReg, XMM_Q(0)));
     tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_A0, mem_index, MO_LEQ);
     tcg_gen_addi_tl(cpu_tmp0, cpu_A0, 8);
-    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(1)));
+    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(ZMMReg, XMM_Q(1)));
     tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_tmp0, mem_index, MO_LEQ);
 }
 
 static inline void gen_op_movo(int d_offset, int s_offset)
 {
-    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset + offsetof(XMMReg, XMM_Q(0)));
-    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset + offsetof(XMMReg, XMM_Q(0)));
-    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset + offsetof(XMMReg, XMM_Q(1)));
-    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset + offsetof(XMMReg, XMM_Q(1)));
+    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset + offsetof(ZMMReg, XMM_Q(0)));
+    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset + offsetof(ZMMReg, XMM_Q(0)));
+    tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset + offsetof(ZMMReg, XMM_Q(1)));
+    tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset + offsetof(ZMMReg, XMM_Q(1)));
 }
 
 static inline void gen_op_movq(int d_offset, int s_offset)
@@ -3640,20 +3640,20 @@ static void gen_sse(CPUX86State *env, DisasContext *s, int b,
                     case 0x23: case 0x33: /* pmovsxwd, pmovzxwd */
                     case 0x25: case 0x35: /* pmovsxdq, pmovzxdq */
                         gen_ldq_env_A0(s, op2_offset +
-                                        offsetof(XMMReg, XMM_Q(0)));
+                                        offsetof(ZMMReg, XMM_Q(0)));
                         break;
                     case 0x21: case 0x31: /* pmovsxbd, pmovzxbd */
                     case 0x24: case 0x34: /* pmovsxwq, pmovzxwq */
                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
                                             s->mem_index, MO_LEUL);
                         tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, op2_offset +
-                                        offsetof(XMMReg, XMM_L(0)));
+                                        offsetof(ZMMReg, XMM_L(0)));
                         break;
                     case 0x22: case 0x32: /* pmovsxbq, pmovzxbq */
                         tcg_gen_qemu_ld_tl(cpu_tmp0, cpu_A0,
                                            s->mem_index, MO_LEUW);
                         tcg_gen_st16_tl(cpu_tmp0, cpu_env, op2_offset +
-                                        offsetof(XMMReg, XMM_W(0)));
+                                        offsetof(ZMMReg, XMM_W(0)));
                         break;
                     case 0x2a:            /* movntqda */
                         gen_ldo_env_A0(s, op1_offset);
Signature · 1 line
2.1.0
#4 lore raw

PATCH 4/7 target-i386: Rename XMM_[BWLSDQ] helpers to ZMM_*

In reply to Eduardo Habkost

They are helpers for the ZMMReg fields, so name them accordingly.

This is just a global search+replace, no other changes are being introduced.

---
 target-i386/cpu.h        |  24 ++--
 target-i386/fpu_helper.c |   8 +-
 target-i386/gdbstub.c    |   8 +-
 target-i386/helper.c     |   8 +-
 target-i386/kvm.c        |  40 +++----
 target-i386/machine.c    |  34 +++---
 target-i386/ops_sse.h    | 290 +++++++++++++++++++++++------------------------
 target-i386/translate.c  | 188 +++++++++++++++---------------
 8 files changed, 300 insertions(+), 300 deletions(-)
target-i386/cpu.h +12 -12
index 7c3e917..614197f 100644
@@ -753,24 +753,24 @@ typedef struct BNDCSReg {
 } BNDCSReg;
 
 #ifdef HOST_WORDS_BIGENDIAN
-#define XMM_B(n) _b[63 - (n)]
-#define XMM_W(n) _w[31 - (n)]
-#define XMM_L(n) _l[15 - (n)]
-#define XMM_S(n) _s[15 - (n)]
-#define XMM_Q(n) _q[7 - (n)]
-#define XMM_D(n) _d[7 - (n)]
+#define ZMM_B(n) _b[63 - (n)]
+#define ZMM_W(n) _w[31 - (n)]
+#define ZMM_L(n) _l[15 - (n)]
+#define ZMM_S(n) _s[15 - (n)]
+#define ZMM_Q(n) _q[7 - (n)]
+#define ZMM_D(n) _d[7 - (n)]
 
 #define MMX_B(n) _b[7 - (n)]
 #define MMX_W(n) _w[3 - (n)]
 #define MMX_L(n) _l[1 - (n)]
 #define MMX_S(n) _s[1 - (n)]
 #else
-#define XMM_B(n) _b[n]
-#define XMM_W(n) _w[n]
-#define XMM_L(n) _l[n]
-#define XMM_S(n) _s[n]
-#define XMM_Q(n) _q[n]
-#define XMM_D(n) _d[n]
+#define ZMM_B(n) _b[n]
+#define ZMM_W(n) _w[n]
+#define ZMM_L(n) _l[n]
+#define ZMM_S(n) _s[n]
+#define ZMM_Q(n) _q[n]
+#define ZMM_D(n) _d[n]
 
 #define MMX_B(n) _b[n]
 #define MMX_W(n) _w[n]
target-i386/fpu_helper.c +4 -4
index d421a47..31afa44 100644
@@ -1169,8 +1169,8 @@ static void do_fxsave(CPUX86State *env, target_ulong ptr, int data64,
             || (env->hflags & HF_CPL_MASK)
             || !(env->hflags & HF_LMA_MASK)) {
             for (i = 0; i < nb_xmm_regs; i++) {
-                cpu_stq_data_ra(env, addr, env->xmm_regs[i].XMM_Q(0), retaddr);
-                cpu_stq_data_ra(env, addr + 8, env->xmm_regs[i].XMM_Q(1), retaddr);
+                cpu_stq_data_ra(env, addr, env->xmm_regs[i].ZMM_Q(0), retaddr);
+                cpu_stq_data_ra(env, addr + 8, env->xmm_regs[i].ZMM_Q(1), retaddr);
                 addr += 16;
             }
         }
@@ -1226,8 +1226,8 @@ static void do_fxrstor(CPUX86State *env, target_ulong ptr, int data64,
             || (env->hflags & HF_CPL_MASK)
             || !(env->hflags & HF_LMA_MASK)) {
             for (i = 0; i < nb_xmm_regs; i++) {
-                env->xmm_regs[i].XMM_Q(0) = cpu_ldq_data_ra(env, addr, retaddr);
-                env->xmm_regs[i].XMM_Q(1) = cpu_ldq_data_ra(env, addr + 8, retaddr);
+                env->xmm_regs[i].ZMM_Q(0) = cpu_ldq_data_ra(env, addr, retaddr);
+                env->xmm_regs[i].ZMM_Q(1) = cpu_ldq_data_ra(env, addr + 8, retaddr);
                 addr += 16;
             }
         }
target-i386/gdbstub.c +4 -4
index ff99cfb..6a9bf3c 100644
@@ -61,8 +61,8 @@ int x86_cpu_gdb_read_register(CPUState *cs, uint8_t *mem_buf, int n)
         n -= IDX_XMM_REGS;
         if (n < CPU_NB_REGS32 ||
             (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK)) {
-            stq_p(mem_buf, env->xmm_regs[n].XMM_Q(0));
-            stq_p(mem_buf + 8, env->xmm_regs[n].XMM_Q(1));
+            stq_p(mem_buf, env->xmm_regs[n].ZMM_Q(0));
+            stq_p(mem_buf + 8, env->xmm_regs[n].ZMM_Q(1));
             return 16;
         }
     } else {
@@ -170,8 +170,8 @@ int x86_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
         n -= IDX_XMM_REGS;
         if (n < CPU_NB_REGS32 ||
             (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK)) {
-            env->xmm_regs[n].XMM_Q(0) = ldq_p(mem_buf);
-            env->xmm_regs[n].XMM_Q(1) = ldq_p(mem_buf + 8);
+            env->xmm_regs[n].ZMM_Q(0) = ldq_p(mem_buf);
+            env->xmm_regs[n].ZMM_Q(1) = ldq_p(mem_buf + 8);
             return 16;
         }
     } else {
target-i386/helper.c +4 -4
index d18be95..3f32509 100644
@@ -535,10 +535,10 @@ void x86_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
         for(i=0;i<nb;i++) {
             cpu_fprintf(f, "XMM%02d=%08x%08x%08x%08x",
                         i,
-                        env->xmm_regs[i].XMM_L(3),
-                        env->xmm_regs[i].XMM_L(2),
-                        env->xmm_regs[i].XMM_L(1),
-                        env->xmm_regs[i].XMM_L(0));
+                        env->xmm_regs[i].ZMM_L(3),
+                        env->xmm_regs[i].ZMM_L(2),
+                        env->xmm_regs[i].ZMM_L(1),
+                        env->xmm_regs[i].ZMM_L(0));
             if ((i & 1) == 1)
                 cpu_fprintf(f, "\n");
             else
target-i386/kvm.c +20 -20
index 6dc9846..f44d831 100644
@@ -1195,8 +1195,8 @@ static int kvm_put_fpu(X86CPU *cpu)
     }
     memcpy(fpu.fpr, env->fpregs, sizeof env->fpregs);
     for (i = 0; i < CPU_NB_REGS; i++) {
-        stq_p(&fpu.xmm[i][0], env->xmm_regs[i].XMM_Q(0));
-        stq_p(&fpu.xmm[i][8], env->xmm_regs[i].XMM_Q(1));
+        stq_p(&fpu.xmm[i][0], env->xmm_regs[i].ZMM_Q(0));
+        stq_p(&fpu.xmm[i][8], env->xmm_regs[i].ZMM_Q(1));
     }
     fpu.mxcsr = env->mxcsr;
 
@@ -1257,14 +1257,14 @@ static int kvm_put_xsave(X86CPU *cpu)
     ymmh = (uint8_t *)&xsave->region[XSAVE_YMMH_SPACE];
     zmmh = (uint8_t *)&xsave->region[XSAVE_ZMM_Hi256];
     for (i = 0; i < CPU_NB_REGS; i++, xmm += 16, ymmh += 16, zmmh += 32) {
-        stq_p(xmm,     env->xmm_regs[i].XMM_Q(0));
-        stq_p(xmm+8,   env->xmm_regs[i].XMM_Q(1));
-        stq_p(ymmh,    env->xmm_regs[i].XMM_Q(2));
-        stq_p(ymmh+8,  env->xmm_regs[i].XMM_Q(3));
-        stq_p(zmmh,    env->xmm_regs[i].XMM_Q(4));
-        stq_p(zmmh+8,  env->xmm_regs[i].XMM_Q(5));
-        stq_p(zmmh+16, env->xmm_regs[i].XMM_Q(6));
-        stq_p(zmmh+24, env->xmm_regs[i].XMM_Q(7));
+        stq_p(xmm,     env->xmm_regs[i].ZMM_Q(0));
+        stq_p(xmm+8,   env->xmm_regs[i].ZMM_Q(1));
+        stq_p(ymmh,    env->xmm_regs[i].ZMM_Q(2));
+        stq_p(ymmh+8,  env->xmm_regs[i].ZMM_Q(3));
+        stq_p(zmmh,    env->xmm_regs[i].ZMM_Q(4));
+        stq_p(zmmh+8,  env->xmm_regs[i].ZMM_Q(5));
+        stq_p(zmmh+16, env->xmm_regs[i].ZMM_Q(6));
+        stq_p(zmmh+24, env->xmm_regs[i].ZMM_Q(7));
     }
 
 #ifdef TARGET_X86_64
@@ -1593,8 +1593,8 @@ static int kvm_get_fpu(X86CPU *cpu)
     }
     memcpy(env->fpregs, fpu.fpr, sizeof env->fpregs);
     for (i = 0; i < CPU_NB_REGS; i++) {
-        env->xmm_regs[i].XMM_Q(0) = ldq_p(&fpu.xmm[i][0]);
-        env->xmm_regs[i].XMM_Q(1) = ldq_p(&fpu.xmm[i][8]);
+        env->xmm_regs[i].ZMM_Q(0) = ldq_p(&fpu.xmm[i][0]);
+        env->xmm_regs[i].ZMM_Q(1) = ldq_p(&fpu.xmm[i][8]);
     }
     env->mxcsr = fpu.mxcsr;
 
@@ -1645,14 +1645,14 @@ static int kvm_get_xsave(X86CPU *cpu)
     ymmh = (const uint8_t *)&xsave->region[XSAVE_YMMH_SPACE];
     zmmh = (const uint8_t *)&xsave->region[XSAVE_ZMM_Hi256];
     for (i = 0; i < CPU_NB_REGS; i++, xmm += 16, ymmh += 16, zmmh += 32) {
-        env->xmm_regs[i].XMM_Q(0) = ldq_p(xmm);
-        env->xmm_regs[i].XMM_Q(1) = ldq_p(xmm+8);
-        env->xmm_regs[i].XMM_Q(2) = ldq_p(ymmh);
-        env->xmm_regs[i].XMM_Q(3) = ldq_p(ymmh+8);
-        env->xmm_regs[i].XMM_Q(4) = ldq_p(zmmh);
-        env->xmm_regs[i].XMM_Q(5) = ldq_p(zmmh+8);
-        env->xmm_regs[i].XMM_Q(6) = ldq_p(zmmh+16);
-        env->xmm_regs[i].XMM_Q(7) = ldq_p(zmmh+24);
+        env->xmm_regs[i].ZMM_Q(0) = ldq_p(xmm);
+        env->xmm_regs[i].ZMM_Q(1) = ldq_p(xmm+8);
+        env->xmm_regs[i].ZMM_Q(2) = ldq_p(ymmh);
+        env->xmm_regs[i].ZMM_Q(3) = ldq_p(ymmh+8);
+        env->xmm_regs[i].ZMM_Q(4) = ldq_p(zmmh);
+        env->xmm_regs[i].ZMM_Q(5) = ldq_p(zmmh+8);
+        env->xmm_regs[i].ZMM_Q(6) = ldq_p(zmmh+16);
+        env->xmm_regs[i].ZMM_Q(7) = ldq_p(zmmh+24);
     }
 
 #ifdef TARGET_X86_64
target-i386/machine.c +17 -17
index d2e62ac..5788778 100644
@@ -36,8 +36,8 @@ static const VMStateDescription vmstate_xmm_reg = {
     .version_id = 1,
     .minimum_version_id = 1,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT64(XMM_Q(0), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(1), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(0), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(1), ZMMReg),
         VMSTATE_END_OF_LIST()
     }
 };
@@ -52,8 +52,8 @@ static const VMStateDescription vmstate_ymmh_reg = {
     .version_id = 1,
     .minimum_version_id = 1,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT64(XMM_Q(2), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(3), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(2), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(3), ZMMReg),
         VMSTATE_END_OF_LIST()
     }
 };
@@ -67,10 +67,10 @@ static const VMStateDescription vmstate_zmmh_reg = {
     .version_id = 1,
     .minimum_version_id = 1,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT64(XMM_Q(4), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(5), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(6), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(7), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(4), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(5), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(6), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(7), ZMMReg),
         VMSTATE_END_OF_LIST()
     }
 };
@@ -85,14 +85,14 @@ static const VMStateDescription vmstate_hi16_zmm_reg = {
     .version_id = 1,
     .minimum_version_id = 1,
     .fields = (VMStateField[]) {
-        VMSTATE_UINT64(XMM_Q(0), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(1), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(2), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(3), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(4), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(5), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(6), ZMMReg),
-        VMSTATE_UINT64(XMM_Q(7), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(0), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(1), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(2), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(3), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(4), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(5), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(6), ZMMReg),
+        VMSTATE_UINT64(ZMM_Q(7), ZMMReg),
         VMSTATE_END_OF_LIST()
     }
 };
@@ -723,7 +723,7 @@ static bool avx512_needed(void *opaque)
     }
 
     for (i = 0; i < CPU_NB_REGS; i++) {
-#define ENV_XMM(reg, field) (env->xmm_regs[reg].XMM_Q(field))
+#define ENV_XMM(reg, field) (env->xmm_regs[reg].ZMM_Q(field))
         if (ENV_XMM(i, 4) || ENV_XMM(i, 6) ||
             ENV_XMM(i, 5) || ENV_XMM(i, 7)) {
             return true;
target-i386/ops_sse.h +145 -145

630 lines not on this page · raw message

target-i386/translate.c +94 -94

466 lines not on this page · raw message

Signature · 1 line
2.1.0
#5 lore raw

PATCH 5/7 target-i386: Define MMXReg._d field

In reply to Eduardo Habkost

Add a new field and reorder MMXReg fields, to make MMXReg and ZMMReg field lists look the same (except for the array sizes).

---
 target-i386/cpu.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
target-i386/cpu.h +2 -1
index 614197f..7519023 100644
@@ -738,8 +738,9 @@ typedef union {
     uint8_t _b[8];
     uint16_t _w[4];
     uint32_t _l[2];
-    float32 _s[2];
     uint64_t _q[1];
+    float32 _s[2];
+    float64 _d[1];
 } MMXReg;
 
 typedef struct BNDReg {
Signature · 1 line
2.1.0
#6 lore raw

RFC PATCH 6/7 target-i386: Define MMREG_UNION macro

In reply to Eduardo Habkost

This will simplify the definitions of ZMMReg and MMXReg.

---
 target-i386/cpu.h | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)
target-i386/cpu.h +11 -16
index 7519023..b189748 100644
@@ -725,23 +725,18 @@ typedef struct SegmentCache {
     uint32_t flags;
 } SegmentCache;
 
-typedef union {
-    uint8_t _b[64];
-    uint16_t _w[32];
-    uint32_t _l[16];
-    uint64_t _q[8];
-    float32 _s[16];
-    float64 _d[8];
-} ZMMReg;
+#define MMREG_UNION(q)      \
+    union {                 \
+        uint8_t _b[(q)*8];  \
+        uint16_t _w[(q)*4]; \
+        uint32_t _l[(q)*2]; \
+        uint64_t _q[(q)];   \
+        float32 _s[(q)*2];  \
+        float64 _d[(q)];    \
+    }
 
-typedef union {
-    uint8_t _b[8];
-    uint16_t _w[4];
-    uint32_t _l[2];
-    uint64_t _q[1];
-    float32 _s[2];
-    float64 _d[1];
-} MMXReg;
+typedef MMREG_UNION(8) ZMMReg;
+typedef MMREG_UNION(1) MMXReg;
 
 typedef struct BNDReg {
     uint64_t lb;
Signature · 1 line
2.1.0
#7 lore raw

Re: [Qemu-devel] [PATCH 6/7] [RFC] target-i386: Define MMREG_UNION macro

Quoted 33 lines · Eduardo Habkost

This will simplify the definitions of ZMMReg and MMXReg.

---
 target-i386/cpu.h | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)
target-i386/cpu.h +9 -8
index 7519023..b189748 100644
@@ -725,23 +725,18 @@ typedef struct SegmentCache {
     uint32_t flags;
 } SegmentCache;
 
-typedef union {
-    uint8_t _b[64];
-    uint16_t _w[32];
-    uint32_t _l[16];
-    uint64_t _q[8];
-    float32 _s[16];
-    float64 _d[8];
-} ZMMReg;
+#define MMREG_UNION(q)      \
+    union {                 \
+        uint8_t _b[(q)*8];  \
+        uint16_t _w[(q)*4]; \
+        uint32_t _l[(q)*2]; \
+        uint64_t _q[(q)];   \
+        float32 _s[(q)*2];  \
+        float64 _d[(q)];    \
+    }
 

target-i386/cpu.h typedef struct SegmentCache { · line 739

Quoted 10 lines
target-i386/cpu.h +2 -8
-typedef union {
-    uint8_t _b[8];
-    uint16_t _w[4];
-    uint32_t _l[2];
-    uint64_t _q[1];
-    float32 _s[2];
-    float64 _d[1];
-} MMXReg;
+typedef MMREG_UNION(8) ZMMReg;
+typedef MMREG_UNION(1) MMXReg;

Since you are at it, perhaps the argument to MMREG_UNION can be in bits.
Otherwise really no comment, it's a nice improvement in type-safety.

Paolo

Quoted 3 lines
target-i386/cpu.h +0 -0
 typedef struct BNDReg {
     uint64_t lb;
 
#8 lore raw

RFC PATCH 7/7 target-i386: Add suffixes to MMReg struct fields

In reply to Eduardo Habkost

This will ensure we never use the MMX_* and ZMM_* macros with the wrong struct type.

---
 target-i386/cpu.h | 66 +++++++++++++++++++++++++++----------------------------
 1 file changed, 33 insertions(+), 33 deletions(-)
target-i386/cpu.h +33 -33
index b189748..6eeac16 100644
@@ -725,18 +725,18 @@ typedef struct SegmentCache {
     uint32_t flags;
 } SegmentCache;
 
-#define MMREG_UNION(q)      \
-    union {                 \
-        uint8_t _b[(q)*8];  \
-        uint16_t _w[(q)*4]; \
-        uint32_t _l[(q)*2]; \
-        uint64_t _q[(q)];   \
-        float32 _s[(q)*2];  \
-        float64 _d[(q)];    \
+#define MMREG_UNION(n, q)       \
+    union n {                   \
+        uint8_t _b_##n[(q)*8];  \
+        uint16_t _w_##n[(q)*4]; \
+        uint32_t _l_##n[(q)*2]; \
+        uint64_t _q_##n[(q)];   \
+        float32 _s_##n[(q)*2];  \
+        float64 _d_##n[(q)];    \
     }
 
-typedef MMREG_UNION(8) ZMMReg;
-typedef MMREG_UNION(1) MMXReg;
+typedef MMREG_UNION(ZMMReg, 8) ZMMReg;
+typedef MMREG_UNION(MMXReg, 1) MMXReg;
 
 typedef struct BNDReg {
     uint64_t lb;
@@ -749,31 +749,31 @@ typedef struct BNDCSReg {
 } BNDCSReg;
 
 #ifdef HOST_WORDS_BIGENDIAN
-#define ZMM_B(n) _b[63 - (n)]
-#define ZMM_W(n) _w[31 - (n)]
-#define ZMM_L(n) _l[15 - (n)]
-#define ZMM_S(n) _s[15 - (n)]
-#define ZMM_Q(n) _q[7 - (n)]
-#define ZMM_D(n) _d[7 - (n)]
-
-#define MMX_B(n) _b[7 - (n)]
-#define MMX_W(n) _w[3 - (n)]
-#define MMX_L(n) _l[1 - (n)]
-#define MMX_S(n) _s[1 - (n)]
+#define ZMM_B(n) _b_ZMMReg[63 - (n)]
+#define ZMM_W(n) _w_ZMMReg[31 - (n)]
+#define ZMM_L(n) _l_ZMMReg[15 - (n)]
+#define ZMM_S(n) _s_ZMMReg[15 - (n)]
+#define ZMM_Q(n) _q_ZMMReg[7 - (n)]
+#define ZMM_D(n) _d_ZMMReg[7 - (n)]
+
+#define MMX_B(n) _b_MMXReg[7 - (n)]
+#define MMX_W(n) _w_MMXReg[3 - (n)]
+#define MMX_L(n) _l_MMXReg[1 - (n)]
+#define MMX_S(n) _s_MMXReg[1 - (n)]
 #else
-#define ZMM_B(n) _b[n]
-#define ZMM_W(n) _w[n]
-#define ZMM_L(n) _l[n]
-#define ZMM_S(n) _s[n]
-#define ZMM_Q(n) _q[n]
-#define ZMM_D(n) _d[n]
-
-#define MMX_B(n) _b[n]
-#define MMX_W(n) _w[n]
-#define MMX_L(n) _l[n]
-#define MMX_S(n) _s[n]
+#define ZMM_B(n) _b_ZMMReg[n]
+#define ZMM_W(n) _w_ZMMReg[n]
+#define ZMM_L(n) _l_ZMMReg[n]
+#define ZMM_S(n) _s_ZMMReg[n]
+#define ZMM_Q(n) _q_ZMMReg[n]
+#define ZMM_D(n) _d_ZMMReg[n]
+
+#define MMX_B(n) _b_MMXReg[n]
+#define MMX_W(n) _w_MMXReg[n]
+#define MMX_L(n) _l_MMXReg[n]
+#define MMX_S(n) _s_MMXReg[n]
 #endif
-#define MMX_Q(n) _q[n]
+#define MMX_Q(n) _q_MMXReg[n]
 
 typedef union {
     floatx80 d __attribute__((aligned(16)));
Signature · 1 line
2.1.0
#9 lore raw
In reply to Eduardo Habkost
Quoted 6 lines · Eduardo Habkost

This is an attempt to cleanup the MMXReg/XMMReg structs and make their names, fields and usage consistent.

The last 2 patches use a bit of macro magic to generate the union definitions and ensure type safety when using the field helper macros, and I am sending them as RFCs.

It all looks ok, as far as it goes.

Though I wonder if it wouldn't be better to reorg everything to work akin to the aarch64 method -- process everything in 64-bit chunks, via TCG registers, rather than via pointers to structures.

That would much easier let mmx and sse (and avx2 and avx512) use the same set of helpers, with much less need for all this macro-ization in the first place.

r~