diff mbox series

[RFC,v4,20/75] target/i386: introduce generic load-store operand

Message ID 20190821172951.15333-21-jan.bobek@gmail.com (mailing list archive)
State New, archived
Headers show
Series rewrite MMX/SSE*/AVX/AVX2 vector instruction translation | expand

Commit Message

Jan Bobek Aug. 21, 2019, 5:28 p.m. UTC
This operand attempts to capture the "indirect" or "memory" operand in
a generic way. It significatly reduces the amount code that needs to
be written in order to read operands from memory to temporary storage
and write them back.

Signed-off-by: Jan Bobek <jan.bobek@gmail.com>
---
 target/i386/translate.c | 57 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
diff mbox series

Patch

diff --git a/target/i386/translate.c b/target/i386/translate.c
index 68c6b7d16b..1be6176934 100644
--- a/target/i386/translate.c
+++ b/target/i386/translate.c
@@ -4670,6 +4670,63 @@  static bool check_cpuid(CPUX86State *env, DisasContext *s, CheckCpuidFeat feat)
                                  env, s, modrm, is_write, arg));        \
     }
 
+/*
+ * Generic load-store operand
+ */
+#define insnop_ldst(opTarg, opTptr)             \
+    insnop_ldst_ ## opTarg ## opTptr
+
+#define INSNOP_LDST(opTarg, opTptr)                                     \
+    static void insnop_ldst(opTarg, opTptr)(CPUX86State *env,           \
+                                            DisasContext *s,            \
+                                            bool is_write,              \
+                                            insnop_arg_t(opTarg) arg,   \
+                                            insnop_arg_t(opTptr) ptr)
+
+#define DEF_INSNOP_LDST(opT, opTarg, opTptr)                            \
+    typedef insnop_arg_t(opTarg) insnop_arg_t(opT);                     \
+    typedef struct {                                                    \
+        insnop_ctxt_t(opTarg) arg_ctxt;                                 \
+        insnop_ctxt_t(opTptr) ptr_ctxt;                                 \
+        insnop_arg_t(opTptr) ptr;                                       \
+    } insnop_ctxt_t(opT);                                               \
+                                                                        \
+    /* forward declaration */                                           \
+    INSNOP_LDST(opTarg, opTptr);                                        \
+                                                                        \
+    INSNOP_INIT(opT)                                                    \
+    {                                                                   \
+        return insnop_init(opTarg)(&ctxt->arg_ctxt,                     \
+                                   env, s, modrm, is_write)             \
+            && insnop_init(opTptr)(&ctxt->ptr_ctxt,                     \
+                                   env, s, modrm, is_write);            \
+    }                                                                   \
+    INSNOP_PREPARE(opT)                                                 \
+    {                                                                   \
+        const insnop_arg_t(opTarg) arg =                                \
+            insnop_prepare(opTarg)(&ctxt->arg_ctxt,                     \
+                                   env, s, modrm, is_write);            \
+        ctxt->ptr =                                                     \
+            insnop_prepare(opTptr)(&ctxt->ptr_ctxt,                     \
+                                   env, s, modrm, is_write);            \
+        if (!is_write) {                                                \
+            insnop_ldst(opTarg, opTptr)(env, s, is_write,               \
+                                        arg, ctxt->ptr);                \
+        }                                                               \
+        return arg;                                                     \
+    }                                                                   \
+    INSNOP_FINALIZE(opT)                                                \
+    {                                                                   \
+        if (is_write) {                                                 \
+            insnop_ldst(opTarg, opTptr)(env, s, is_write,               \
+                                        arg, ctxt->ptr);                \
+        }                                                               \
+        insnop_finalize(opTptr)(&ctxt->ptr_ctxt,                        \
+                                env, s, modrm, is_write, ctxt->ptr);    \
+        insnop_finalize(opTarg)(&ctxt->arg_ctxt,                        \
+                                env, s, modrm, is_write, arg);          \
+    }
+
 static void gen_sse_ng(CPUX86State *env, DisasContext *s, int b)
 {
     enum {