[DYNAREC] Cleaned up the TEST_INTERPRETER a bit

13 files changed, 104 insertions, 94 deletions

diff --git a/src/emu/modrm.h b/src/emu/modrm.h
index e3fc1e98..3a4b47ac 100644
--- a/src/emu/modrm.h
+++ b/src/emu/modrm.h
@@ -20,6 +20,9 @@
 

 #ifdef TEST_INTERPRETER

 #define GETED(D)            oped=TestEd(test, &addr, rex, nextop, D)

+#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 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)

@@ -40,6 +43,9 @@
 #define GETGM               opgm=GetGm(test->emu, &addr, rex, nextop)

 #else

 #define GETED(D)            oped=GetEd(emu, &addr, rex, nextop, D)

+#define GETE4(D)            GETED(D)

+#define GETE8(D)            GETED(D)

+#define GETET(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)

@@ -71,6 +77,8 @@
 #define GM  opgm

 #define FAKEED(D)           GetEd(emu, &addr, rex, nextop, D)

 #define FAKEED32(D)         GetEd32O(emu, &addr, rex, nextop, D, 0)

+#define GETEA(D)            GetEA(emu, &addr, rex, nextop, D)

+#define _GETED(D)           oped=GetEd(emu, &addr, rex, nextop, D)

 

 #define MODREG  ((nextop&0xC0)==0xC0)

 

diff --git a/src/emu/x64run.c b/src/emu/x64run.c
index 3eeec71f..0f982a77 100755
--- a/src/emu/x64run.c
+++ b/src/emu/x64run.c
@@ -575,15 +575,11 @@ x64emurun:
         case 0x8D:                      /* LEA Gd,M */
             nextop = F8;
             GETGD;
-            #ifdef TEST_INTERPRETER
-            oped=GetEd(emu, &addr, rex, nextop, 0);
-            #else
-            GETED(0);
-            #endif
+            tmp64u = GETEA(0);
             if(rex.w)
-                GD->q[0] = (uint64_t)ED;
+                GD->q[0] = tmp64u;
             else
-                GD->q[0] = ((uintptr_t)ED)&0xffffffff;
+                GD->q[0] = tmp64u&0xffffffff;
             break;
 
         case 0x8F:                      /* POP Ed */
diff --git a/src/emu/x64run66.c b/src/emu/x64run66.c
index 4a73cf60..c2d53742 100644
--- a/src/emu/x64run66.c
+++ b/src/emu/x64run66.c
@@ -277,15 +277,11 @@ uintptr_t Run66(x64emu_t *emu, rex_t rex, int rep, uintptr_t addr)
     case 0x8D:                              /* LEA Gw,M */

         nextop = F8;

         GETGD;

-        #ifdef TEST_INTERPRETER

-        oped=GetEd(emu, &addr, rex, nextop, 0);

-        #else

-        GETED(0);

-        #endif

+        tmp64u = GETEA(0);

         if(rex.w)

-            GD->q[0] = (uint64_t)ED;

+            GD->q[0] = tmp64u;

         else

-            GD->word[0] = (uint16_t)(uintptr_t)ED;

+            GD->word[0] = (uint16_t)tmp64u;

         break;

 

         case 0x90:                      /* NOP or XCHG R8d, AX*/

diff --git a/src/emu/x64run_private.c b/src/emu/x64run_private.c
index 3e519cd2..664fb3c5 100755
--- a/src/emu/x64run_private.c
+++ b/src/emu/x64run_private.c
@@ -1303,6 +1303,53 @@ reg64_t* TestEd(x64test_t *test, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t
         return (reg64_t*)test->mem;
     }
 }
+reg64_t* TestEd4(x64test_t *test, 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 = 4;
+        test->memaddr = (uintptr_t)ret;
+        *(uint32_t*)test->mem = ret->dword[0];
+        return (reg64_t*)test->mem;
+    }
+}
+reg64_t* TestEd8(x64test_t *test, 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;
+        test->memaddr = (uintptr_t)ret;
+        *(uint64_t*)test->mem = ret->q[0];
+        return (reg64_t*)test->mem;
+    }
+}
+reg64_t* TestEdt(x64test_t *test, 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 = 4;
+        test->memaddr = (uintptr_t)ret;
+        memcpy(test->mem, ret, 10);
+        return (reg64_t*)test->mem;
+    }
+}
+
+uintptr_t GetEA(x64emu_t *emu, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta)
+{
+    uint8_t m = v&0xC7;    // filter Ed
+    if(m>=0xC0) {
+         return (uintptr_t)&emu->regs[(m&0x07)+(rex.b<<3)];
+    } else return (uintptr_t)GetECommon(emu, addr, rex, m, 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/x64run_private.h b/src/emu/x64run_private.h
index df0f177c..b31a522d 100755
--- a/src/emu/x64run_private.h
+++ b/src/emu/x64run_private.h
@@ -48,6 +48,10 @@ reg64_t* GetEbO(x64emu_t *emu, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t de
 reg64_t* TestEbO(x64test_t *test, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta, uintptr_t offset);
 reg64_t* GetEd(x64emu_t *emu, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta);
 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* 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);
 reg64_t* TestEdO(x64test_t *test, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta, uintptr_t offset);
 reg64_t* GetEd32O(x64emu_t *emu, uintptr_t* addr, rex_t rex, uint8_t v, uint8_t delta, uintptr_t offset);
diff --git a/src/emu/x64rund8.c b/src/emu/x64rund8.c
index 374658b2..c44ca5be 100644
--- a/src/emu/x64rund8.c
+++ b/src/emu/x64rund8.c
@@ -122,36 +122,36 @@ uintptr_t RunD8(x64emu_t *emu, rex_t rex, uintptr_t addr)
         default:

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

             case 0:         /* FADD ST0, float */

-                GETED(0);

+                GETE4(0);

                 ST0.d += *(float*)ED;

                 break;

             case 1:         /* FMUL ST0, float */

-                GETED(0);

+                GETE4(0);

                 ST0.d *= *(float*)ED;

                 break;

             case 2:      /* FCOM ST0, float */

-                GETED(0);

+                GETE4(0);

                 fpu_fcom(emu, *(float*)ED);

                 break;

             case 3:     /* FCOMP */

-                GETED(0);

+                GETE4(0);

                 fpu_fcom(emu, *(float*)ED);

                 fpu_do_pop(emu);

                 break;

             case 4:         /* FSUB ST0, float */

-                GETED(0);

+                GETE4(0);

                 ST0.d -= *(float*)ED;

                 break;

             case 5:         /* FSUBR ST0, float */

-                GETED(0);

+                GETE4(0);

                 ST0.d = *(float*)ED - ST0.d;

                 break;

             case 6:         /* FDIV ST0, float */

-                GETED(0);

+                GETE4(0);

                 ST0.d /= *(float*)ED;

                 break;

             case 7:         /* FDIVR ST0, float */

-                GETED(0);

+                GETE4(0);

                 ST0.d = *(float*)ED / ST0.d;

                 break;

             default:

diff --git a/src/emu/x64rund9.c b/src/emu/x64rund9.c
index 6c1ad490..1b097f9a 100644
--- a/src/emu/x64rund9.c
+++ b/src/emu/x64rund9.c
@@ -235,27 +235,24 @@ uintptr_t RunD9(x64emu_t *emu, rex_t rex, uintptr_t addr)
         case 0xEF:

             return 0;

         default:

-        #ifdef TEST_INTERPRETER

-        rex.w = 0;  // hack, 32bit access only here

-        #endif

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

             case 0:     /* FLD ST0, Ed float */

-                GETED(0);

+                GETE4(0);

                 fpu_do_push(emu);

                 ST0.d = *(float*)ED;

                 break;

             case 2:     /* FST Ed, ST0 */

-                GETED(0);

+                GETE4(0);

                 *(float*)ED = ST0.d;

                 break;

             case 3:     /* FSTP Ed, ST0 */

-                GETED(0);

+                GETE4(0);

                 *(float*)ED = ST0.d;

                 fpu_do_pop(emu);

                 break;

             case 4:     /* FLDENV m */

                 // warning, incomplete

-                GETED(0);

+                _GETED(0);

                 fpu_loadenv(emu, (char*)ED, 0);

                 break;

             case 5:     /* FLDCW Ew */

@@ -265,7 +262,7 @@ uintptr_t RunD9(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 break;

             case 6:     /* FNSTENV m */

                 // warning, incomplete

-                GETED(0);

+                _GETED(0);

                 #ifndef TEST_INTERPRETER

                 fpu_savenv(emu, (char*)ED, 0);

                 #endif

diff --git a/src/emu/x64runda.c b/src/emu/x64runda.c
index a2f07cca..bb678a8c 100644
--- a/src/emu/x64runda.c
+++ b/src/emu/x64runda.c
@@ -103,41 +103,38 @@ uintptr_t RunDA(x64emu_t *emu, rex_t rex, uintptr_t addr)
     case 0xFD:

         return 0;

     default:

-        #ifdef TEST_INTERPRETER

-        rex.w = 0;  // hack, 32bit access only here

-        #endif

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

             case 0:     /* FIADD ST0, Ed int */

-                GETED(0);

+                GETE4(0);

                 ST0.d += ED->sdword[0];

                 break;

             case 1:     /* FIMUL ST0, Ed int */

-                GETED(0);

+                GETE4(0);

                 ST0.d *= ED->sdword[0];

                 break;

             case 2:     /* FICOM ST0, Ed int */

-                GETED(0);

+                GETE4(0);

                 fpu_fcom(emu, ED->sdword[0]);

                 break;

             case 3:     /* FICOMP ST0, Ed int */

-                GETED(0);

+                GETE4(0);

                 fpu_fcom(emu, ED->sdword[0]);

                 fpu_do_pop(emu);

                 break;

             case 4:     /* FISUB ST0, Ed int */

-                GETED(0);

+                GETE4(0);

                 ST0.d -= ED->sdword[0];

                 break;

             case 5:     /* FISUBR ST0, Ed int */

-                GETED(0);

+                GETE4(0);

                 ST0.d = (double)ED->sdword[0] - ST0.d;

                 break;

             case 6:     /* FIDIV ST0, Ed int */

-                GETED(0);

+                GETE4(0);

                 ST0.d /= ED->sdword[0];

                 break;

             case 7:     /* FIDIVR ST0, Ed int */

-                GETED(0);

+                GETE4(0);

                 ST0.d = (double)ED->sdword[0] / ST0.d;

                 break;

         }

diff --git a/src/emu/x64rundb.c b/src/emu/x64rundb.c
index e3c05216..c406e367 100644
--- a/src/emu/x64rundb.c
+++ b/src/emu/x64rundb.c
@@ -132,17 +132,14 @@ uintptr_t RunDB(x64emu_t *emu, rex_t rex, uintptr_t addr)
     case 0xE7:

         return 0;

     default:

-        #ifdef TEST_INTERPRETER

-        rex.w = 0;  // hack, 32bit access only here

-        #endif

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

             case 0: /* FILD ST0, Ed */

-                GETED(0);

+                GETE4(0);

                 fpu_do_push(emu);

                 ST0.d = ED->sdword[0];

                 break;

             case 1: /* FISTTP Ed, ST0 */

-                GETED(0);

+                GETE4(0);

                 if(isgreater(ST0.d, (double)(int32_t)0x7fffffff) || isless(ST0.d, (double)(int32_t)0x80000000) || !isfinite(ST0.d))

                     ED->sdword[0] = 0x80000000;

                 else

@@ -150,7 +147,7 @@ uintptr_t RunDB(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 fpu_do_pop(emu);

                 break;

             case 2: /* FIST Ed, ST0 */

-                GETED(0);

+                GETE4(0);

                 if(isgreater(ST0.d, (double)(int32_t)0x7fffffff) || isless(ST0.d, (double)(int32_t)0x80000000) || !isfinite(ST0.d))

                     ED->sdword[0] = 0x80000000;

                 else {

@@ -159,7 +156,7 @@ uintptr_t RunDB(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 }

                 break;

             case 3: /* FISTP Ed, ST0 */

-                GETED(0);

+                GETE4(0);

                 if(isgreater(ST0.d, (double)(int32_t)0x7fffffff) || isless(ST0.d, (double)(int32_t)0x80000000) || !isfinite(ST0.d))

                     ED->sdword[0] = 0x80000000;

                 else {

@@ -169,21 +166,14 @@ uintptr_t RunDB(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 fpu_do_pop(emu);

                 break;

             case 5: /* FLD ST0, Et */

-                GETED(0);

-                #ifdef TEST_INTERPRETER

-                test->memsize = 10;

-                memcpy(ED, (void*)test->memaddr, 10);

-                #endif

+                GETET(0);

                 fpu_do_push(emu);

                 memcpy(&STld(0).ld, ED, 10);

                 LD2D(&STld(0), &ST(0).d);

                 STld(0).uref = ST0.q;

                 break;

             case 7: /* FSTP tbyte */

-                GETED(0);

-                #ifdef TEST_INTERPRETER

-                test->memsize = 10;

-                #endif

+                GETET(0);

                 if(ST0.q!=STld(0).uref)

                     D2LD(&ST0.d, ED);

                 else

diff --git a/src/emu/x64rundc.c b/src/emu/x64rundc.c
index 3b54f94c..08931135 100644
--- a/src/emu/x64rundc.c
+++ b/src/emu/x64rundc.c
@@ -118,10 +118,7 @@ uintptr_t RunDC(x64emu_t *emu, rex_t rex, uintptr_t addr)
             ST(nextop&7).d /=  ST0.d;
             break;
         default:
-            #ifdef TEST_INTERPRETER
-            rex.w = 1;  // hack, 64bit access only here
-            #endif
-            GETED(0);
+            GETE8(0);
             switch((nextop>>3)&7) {
             case 0:         /* FADD ST0, double */
                 ST0.d += *(double*)ED;
diff --git a/src/emu/x64rundd.c b/src/emu/x64rundd.c
index 651d04c9..f33450a7 100644
--- a/src/emu/x64rundd.c
+++ b/src/emu/x64rundd.c
@@ -117,31 +117,28 @@ uintptr_t RunDD(x64emu_t *emu, rex_t rex, uintptr_t addr)
         return 0;

 

     default:

-        #ifdef TEST_INTERPRETER

-        rex.w = 1;  // hack, mostly 64bit access only here

-        #endif

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

             case 0: /* FLD double */

-                GETED(0);

+                GETE8(0);

                 fpu_do_push(emu);

                 ST0.d = *(double*)ED;

                 break;

             case 1: /* FISTTP ED qword */

-                GETED(0);

+                GETE8(0);

                 *(int64_t*)ED = ST0.d;

                 fpu_do_pop(emu);

                 break;

             case 2: /* FST double */

-                GETED(0);

+                GETE8(0);

                 *(double*)ED = ST0.d;

                 break;

             case 3: /* FSTP double */

-                GETED(0);

+                GETE8(0);

                 *(double*)ED = ST0.d;

                 fpu_do_pop(emu);

                 break;

             case 4: /* FRSTOR m108byte */

-                GETED(0);

+                _GETED(0);

                 fpu_loadenv(emu, (char*)ED, 0);

                 // get the STx

                 {

@@ -154,7 +151,7 @@ uintptr_t RunDD(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 }

                 break;

             case 6: /* FNSAVE m108byte */

-                GETED(0);

+                _GETED(0);

                 // ENV first...

                 // warning, incomplete

                 #ifndef TEST_INTERPRETER

@@ -172,10 +169,7 @@ uintptr_t RunDD(x64emu_t *emu, rex_t rex, uintptr_t addr)
                 reset_fpu(emu);

                 break;

             case 7: /* FNSTSW m2byte */

-                GETED(0);

-                #ifdef TEST_INTERPRETER

-                test->memsize = 2;

-                #endif

+                GETEW(0);

                 emu->sw.f.F87_TOP = emu->top&7;

                 *(uint16_t*)ED = emu->sw.x16;

                 break;

diff --git a/src/emu/x64runde.c b/src/emu/x64runde.c
index 317c0d95..4ec5828a 100644
--- a/src/emu/x64runde.c
+++ b/src/emu/x64runde.c
@@ -134,9 +134,6 @@ uintptr_t RunDE(x64emu_t *emu, rex_t rex, uintptr_t addr)
         return 0;
     
     default:
-        #ifdef TEST_INTERPRETER
-        rex.w = 0;  // hack, 32bit access only here
-        #endif
         switch((nextop>>3)&7) {
             case 0:     /* FIADD ST0, Ew int */
                 GETEW(0);
diff --git a/src/emu/x64rundf.c b/src/emu/x64rundf.c
index beec70db..03244715 100644
--- a/src/emu/x64rundf.c
+++ b/src/emu/x64rundf.c
@@ -150,19 +150,12 @@ uintptr_t RunDF(x64emu_t *emu, rex_t rex, uintptr_t addr)
             fpu_do_pop(emu);

             break;

         case 4: /* FBLD ST0, tbytes */

-            GETED(0);

-            #ifdef TEST_INTERPRETER

-            test->memsize = 10;

-            memcpy(ED, (void*)test->memaddr, 10);

-            #endif

+            GETET(0);

             fpu_do_push(emu);

             fpu_fbld(emu, (uint8_t*)ED);

             break;

         case 5: /* FILD ST0, Gq */

-            #ifdef TEST_INTERPRETER

-            rex.w = 1;  // hack, 64bit access

-            #endif

-            GETED(0);

+            GETE8(0);

             tmp64s = ED->sq[0];

             fpu_do_push(emu);

             ST0.d = tmp64s;

@@ -170,18 +163,12 @@ uintptr_t RunDF(x64emu_t *emu, rex_t rex, uintptr_t addr)
             STll(0).sref = ST0.sq;

             break;

         case 6: /* FBSTP tbytes, ST0 */

-            GETED(0);

-            #ifdef TEST_INTERPRETER

-            test->memsize = 10;

-            #endif

+            GETET(0);

             fpu_fbst(emu, (uint8_t*)ED);

             fpu_do_pop(emu);

             break;

         case 7: /* FISTP i64 */

-            #ifdef TEST_INTERPRETER

-            rex.w = 1;  // hack, 64bits access

-            #endif

-            GETED(0);

+            GETE8(0);

             if(STll(0).sref==ST(0).sq)

                 ED->sq[0] = STll(0).sq;

             else {