[DYNAREC] More improvement to TEST_DYNAREC

12 files changed, 65 insertions, 24 deletions

diff --git a/src/dynarec/arm64/dynarec_arm64_helper.c b/src/dynarec/arm64/dynarec_arm64_helper.c
index cbbf0c38..7aaf098e 100755
--- a/src/dynarec/arm64/dynarec_arm64_helper.c
+++ b/src/dynarec/arm64/dynarec_arm64_helper.c
@@ -418,6 +418,7 @@ void jump_to_epilog(dynarec_arm_t* dyn, uintptr_t ip, int reg, int ninst)
     } else {
         GETIP_(ip);
     }
+    NOTEST(x2);
     TABLE64(x2, (uintptr_t)arm64_epilog);
     SMEND();
     BR(x2);
@@ -432,6 +433,7 @@ void jump_to_next(dynarec_arm_t* dyn, uintptr_t ip, int reg, int ninst)
         if(reg!=xRIP) {
             MOVx_REG(xRIP, reg);
         }
+        NOTEST(x2);
         uintptr_t tbl = getJumpTable64();
         MAYUSE(tbl);
         TABLE64(x3, tbl);
@@ -444,6 +446,7 @@ void jump_to_next(dynarec_arm_t* dyn, uintptr_t ip, int reg, int ninst)
         UBFXx(x2, xRIP, JMPTABL_START0, JMPTABL_SHIFT0);
         LDRx_REG_LSL3(x2, x3, x2);
     } else {
+        NOTEST(x2);
         uintptr_t p = getJumpTableAddress64(ip);
         MAYUSE(p);
         TABLE64(x3, p);
@@ -479,6 +482,7 @@ void ret_to_epilog(dynarec_arm_t* dyn, int ninst)
         // not the correct return address, regular jump
     }
     uintptr_t tbl = getJumpTable64();
+    NOTEST(x2);
     MOV64x(x2, tbl);
     UBFXx(x3, xRIP, JMPTABL_START3, JMPTABL_SHIFT3);
     LDRx_REG_LSL3(x2, x2, x3);
@@ -516,6 +520,7 @@ void retn_to_epilog(dynarec_arm_t* dyn, int ninst, int n)
         // not the correct return address, regular jump
     }
     uintptr_t tbl = getJumpTable64();
+    NOTEST(x2);
     MOV64x(x2, tbl);
     UBFXx(x3, xRIP, JMPTABL_START3, JMPTABL_SHIFT3);
     LDRx_REG_LSL3(x2, x2, x3);
@@ -535,6 +540,7 @@ void iret_to_epilog(dynarec_arm_t* dyn, int ninst, int is64bits)
     MAYUSE(ninst);
     MESSAGE(LOG_DUMP, "IRet to epilog\n");
     // POP IP
+    NOTEST(x2);
     POP1(xRIP);
     // POP CS
     POP1(x2);
diff --git a/src/dynarec/arm64/dynarec_arm64_helper.h b/src/dynarec/arm64/dynarec_arm64_helper.h
index 5c908685..10d948b2 100755
--- a/src/dynarec/arm64/dynarec_arm64_helper.h
+++ b/src/dynarec/arm64/dynarec_arm64_helper.h
@@ -1305,13 +1305,13 @@ uintptr_t dynarec64_F30F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int n
 
 #define NOTEST(s1)                                          \
     if(box64_dynarec_test) {                                \
-        if(offsetof(x64emu_t, test.test)<(1<<12)) {         \
-            STRw_U12(xZR, xEmu, offsetof(x64emu_t, test.test));\
-        } else {                                            \
-            MOV32w(s1, offsetof(x64emu_t, test.test));      \
-            ADDx_REG(s1, xEmu, s1);                         \
-            STRw_U12(xZR, s1, 0);                           \
-        }                                                   \
+        STRw_U12(xZR, xEmu, offsetof(x64emu_t, test.test)); \
+        STRw_U12(xZR, xEmu, offsetof(x64emu_t, test.clean));\
+    }
+#define GOTEST(s1, s2)                                      \
+    if(box64_dynarec_test) {                                \
+        MOV32w(s2, 1);                                      \
+        STRw_U12(s2, xEmu, offsetof(x64emu_t, test.test));  \
     }
 
 #endif //__DYNAREC_ARM64_HELPER_H__
diff --git a/src/dynarec/dynarec_native_pass.c b/src/dynarec/dynarec_native_pass.c
index 0c9ddfbc..1e8ba3aa 100755
--- a/src/dynarec/dynarec_native_pass.c
+++ b/src/dynarec/dynarec_native_pass.c
@@ -78,6 +78,9 @@ uintptr_t native_pass(dynarec_native_t* dyn, uintptr_t addr)
             dyn->last_ip = 0;   // reset IP if some jump are comming here
         fpu_propagate_stack(dyn, ninst);
         NEW_INST;
+        if(!ninst) {
+            GOTEST(x1, x2);
+        }
         if(dyn->insts[ninst].pred_sz>1) {SMSTART();}
         fpu_reset_scratch(dyn);
         if((dyn->insts[ninst].x64.need_before&~X_PEND) && !dyn->insts[ninst].pred_sz) {
diff --git a/src/dynarec/rv64/dynarec_rv64_helper.h b/src/dynarec/rv64/dynarec_rv64_helper.h
index f7fb7a35..b0f71315 100644
--- a/src/dynarec/rv64/dynarec_rv64_helper.h
+++ b/src/dynarec/rv64/dynarec_rv64_helper.h
@@ -1144,13 +1144,13 @@ uintptr_t dynarec64_F30F(dynarec_rv64_t* dyn, uintptr_t addr, uintptr_t ip, int
 
 #define NOTEST(s1)                                          \
     if(box64_dynarec_test) {                                \
-        if(offsetof(x64emu_t, test.test)<2048) {            \
-            SW(xZR, xEmu, offsetof(x64emu_t, test.test));   \
-        } else {                                            \
-            MOV32w(s1, offsetof(x64emu_t, test.test));      \
-            ADD(s1, xEmu, s1);                              \
-            SW(xZR, s1, 0);                                 \
-        }                                                   \
+        SW(xZR, xEmu, offsetof(x64emu_t, test.test));       \
+        SW(xZR, xEmu, offsetof(x64emu_t, test.clean));      \
+    }
+#define GOTEST(s1, s2)                                      \
+    if(box64_dynarec_test) {                                \
+        MOV32w(s2, 1);                                      \
+        SW(s2, xEmu, offsetof(x64emu_t, test.test));        \
     }
 
 #endif //__DYNAREC_RV64_HELPER_H__
diff --git a/src/emu/modrm.h b/src/emu/modrm.h
index 3a4b47ac..21ba6d3c 100644
--- a/src/emu/modrm.h
+++ b/src/emu/modrm.h
@@ -23,6 +23,7 @@
 #define GETE4(D)            oped=TestEd4(test, &addr, rex, nextop, D)

 #define GETE8(D)            oped=TestEd8(test, &addr, rex, nextop, D)

 #define GETET(D)            oped=TestEdt(test, &addr, rex, nextop, D)

+#define GETE8xw(D)          oped=TestEd8xw(test, rex.w, &addr, rex, nextop, D)

 #define GETED32(D)          oped=TestEd32O(test, &addr, rex, nextop, D, 0)

 #define GETED_OFFS(D, O)    oped=TestEdO(test, &addr, rex, nextop, D, O)

 #define GETGD               opgd=GetGd(test->emu, &addr, rex, nextop)

@@ -46,6 +47,7 @@
 #define GETE4(D)            GETED(D)

 #define GETE8(D)            GETED(D)

 #define GETET(D)            GETED(D)

+#define GETE8xw(D)          GETED(D)

 #define GETED32(D)          oped=GetEd32O(emu, &addr, rex, nextop, D, 0)

 #define GETED_OFFS(D, O)    oped=GetEdO(emu, &addr, rex, nextop, D, O)

 #define GETGD               opgd=GetGd(emu, &addr, rex, nextop)

diff --git a/src/emu/x64emu_private.h b/src/emu/x64emu_private.h
index 3fb43df3..a398d34e 100755
--- a/src/emu/x64emu_private.h
+++ b/src/emu/x64emu_private.h
@@ -32,6 +32,7 @@ typedef struct x64test_s {
     uintptr_t   memaddr;
     int         memsize;
     int         test;
+    int         clean;
     uint8_t     mem[16];
 } x64test_t;
 
diff --git a/src/emu/x64run0f.c b/src/emu/x64run0f.c
index 745f57f4..57402351 100644
--- a/src/emu/x64run0f.c
+++ b/src/emu/x64run0f.c
@@ -150,7 +150,7 @@ uintptr_t Run0F(x64emu_t *emu, rex_t rex, uintptr_t addr, int *step)
             break;

         case 0x18:                       /* PREFETCHh Ed */

             nextop = F8;

-            GETED(0);

+            _GETED(0);

             if(MODREG) {

             } else

             switch((nextop>>3)&7) {

diff --git a/src/emu/x64run_private.c b/src/emu/x64run_private.c
index 664fb3c5..9f8457c2 100755
--- a/src/emu/x64run_private.c
+++ b/src/emu/x64run_private.c
@@ -1342,6 +1342,21 @@ reg64_t* TestEdt(x64test_t *test, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t
         return (reg64_t*)test->mem;
     }
 }
+reg64_t* TestEd8xw(x64test_t *test, int w, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta)
+{
+    uint8_t m = v&0xC7;    // filter Ed
+    if(m>=0xC0) {
+         return &test->emu->regs[(m&0x07)+(rex.b<<3)];
+    } else {
+        reg64_t* ret =  GetECommon(test->emu, addr, rex, m, delta);
+        test->memsize = 8<<w;
+        test->memaddr = (uintptr_t)ret;
+        *(uint64_t*)test->mem = ret->q[0];
+        if(w)
+            ((uint64_t*)test->mem)[1] = ret->q[1];
+        return (reg64_t*)test->mem;
+    }
+}
 
 uintptr_t GetEA(x64emu_t *emu, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta)
 {
diff --git a/src/emu/x64run_private.h b/src/emu/x64run_private.h
index b31a522d..d43ea331 100755
--- a/src/emu/x64run_private.h
+++ b/src/emu/x64run_private.h
@@ -50,6 +50,7 @@ reg64_t* GetEd(x64emu_t *emu, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t del
 reg64_t* TestEd(x64test_t *test, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta);
 reg64_t* TestEd4(x64test_t *test, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta);
 reg64_t* TestEd8(x64test_t *test, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta);
+reg64_t* TestEd8xw(x64test_t *test, int w, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta);
 reg64_t* TestEdt(x64test_t *test, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta);
 uintptr_t GetEA(x64emu_t *emu, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta);
 reg64_t* GetEdO(x64emu_t *emu, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta, uintptr_t offset);
diff --git a/src/emu/x64runf0.c b/src/emu/x64runf0.c
index 03f5125e..6d58670a 100644
--- a/src/emu/x64runf0.c
+++ b/src/emu/x64runf0.c
@@ -683,7 +683,7 @@ uintptr_t RunF0(x64emu_t *emu, rex_t rex, uintptr_t addr)
 

                 case 0xC7:                      /* CMPXCHG8B Gq */

                     nextop = F8;

-                    GETED(0);

+                    GETE8xw(0);

                     switch((nextop>>3)&7) {

                         case 1:

                             CHECK_FLAGS(emu);

diff --git a/src/emu/x64test.c b/src/emu/x64test.c
index 4b48a9ad..525b96c9 100644
--- a/src/emu/x64test.c
+++ b/src/emu/x64test.c
@@ -24,7 +24,12 @@
 
 void print_banner(x64emu_t* ref)
 {
-    printf_log(LOG_NONE, "Warning, difference between Interpreter and Dynarec in %p\n=======================================\n", (void*)ref->old_ip);
+    printf_log(LOG_NONE, "Warning, difference between Interpreter and Dynarec in %p (%02x %02x %02x %02x %02x %02x %02x %02x)\n"\
+        "=======================================\n", 
+        (void*)ref->old_ip, 
+        ((uint8_t*)ref->old_ip)[0], ((uint8_t*)ref->old_ip)[1], ((uint8_t*)ref->old_ip)[2], ((uint8_t*)ref->old_ip)[3],
+        ((uint8_t*)ref->old_ip)[4], ((uint8_t*)ref->old_ip)[5], ((uint8_t*)ref->old_ip)[6], ((uint8_t*)ref->old_ip)[7]
+    );
     printf_log(LOG_NONE, "DIFF: Dynarec |  Interpreter\n----------------------\n");
 }
 #define BANNER if(!banner) {banner=1; print_banner(ref);}
@@ -129,20 +134,27 @@ void x64test_check(x64emu_t* ref, uintptr_t ip)
 void x64test_init(x64emu_t* ref, uintptr_t ip)
 {
     x64test_t* test = &ref->test;
+    if(!test->test) {
+        test->clean = 0;
+        return;
+    }
     // check if test as a valid emu struct
     if(!test->emu) {
         test->emu = NewX64Emu(my_context, ip, (uintptr_t)ref->init_stack, ref->size_stack, 0);
         CopyEmu(test->emu, ref);
-    } else if(test->test) {
-        x64test_check(ref, ip);
-    }
-    // check if IP is same, else, sync
-    if(ip != test->emu->ip.q[0] || !test->test) {
-        CopyEmu(test->emu, ref);
+    } else {
+        // check if IP is same, else, sync
+        uintptr_t prev_ip = test->emu->ip.q[0];
+        if(test->clean)
+            x64test_check(ref, ip);
+        if(ip != prev_ip || !test->test) {
+            CopyEmu(test->emu, ref);
+        }
     }
     // Do a Dry single Step
     test->memsize = 0;
-    test->test = 1;
+    test->clean = 1;
     ref->old_ip = ip;
     RunTest(test);
+    // this will be anakyzed next step
 }
diff --git a/src/libtools/signals.c b/src/libtools/signals.c
index df715a0f..3e9bbce5 100755
--- a/src/libtools/signals.c
+++ b/src/libtools/signals.c
@@ -333,6 +333,7 @@ uint64_t RunFunctionHandler(int* exit, x64_ucontext_t* sigcontext, uintptr_t fnc
     #ifdef DYNAREC
     if(box64_dynarec_test)
         emu->test.test = 0;
+        emu->test.clean = 0;
     #endif
 
     if(emu->longjmp) {