[DYNAREC] Try to fix some issue with x87 stack and skipped code being incoherent

12 files changed, 183 insertions, 102 deletions

diff --git a/src/dynarec/arm64/dynarec_arm64_functions.c b/src/dynarec/arm64/dynarec_arm64_functions.c
index c747fc7e..9e3748ed 100644
--- a/src/dynarec/arm64/dynarec_arm64_functions.c
+++ b/src/dynarec/arm64/dynarec_arm64_functions.c
@@ -85,15 +85,19 @@ int fpu_get_reg_xmm(dynarec_arm_t* dyn, int t, int xmm)
     return i;
 }
 // Reset fpu regs counter
-void fpu_reset_reg(dynarec_arm_t* dyn)
+static void fpu_reset_reg_neoncache(neoncache_t* n)
 {
-    dyn->n.fpu_reg = 0;
+    n->fpu_reg = 0;
     for (int i=0; i<24; ++i) {
-        dyn->n.fpuused[i]=0;
-        dyn->n.neoncache[i].v = 0;
+        n->fpuused[i]=0;
+        n->neoncache[i].v = 0;
     }
 
 }
+void fpu_reset_reg(dynarec_arm_t* dyn)
+{
+    fpu_reset_reg_neoncache(&dyn->n);
+}
 
 int neoncache_no_i64(dynarec_arm_t* dyn, int ninst, int st, int a)
 {
@@ -589,3 +593,53 @@ void print_opcode(dynarec_native_t* dyn, int ninst, uint32_t opcode)
 {
     dynarec_log(LOG_NONE, "\t%08x\t%s\n", opcode, arm64_print(opcode, (uintptr_t)dyn->block));
 }
+
+static void x87_reset(neoncache_t* n)
+{
+    for (int i=0; i<8; ++i) {
+        n->x87cache[i] = -1;
+        n->freed[i] = -1;
+    }
+    n->x87stack = 0;
+    n->stack = 0;
+    n->stack_next = 0;
+    n->stack_pop = 0;
+    n->stack_push = 0;
+    n->combined1 = n->combined2 = 0;
+    n->swapped = 0;
+    n->barrier = 0;
+    for(int i=0; i<24; ++i)
+        if(n->neoncache[i].t == NEON_CACHE_ST_F
+         || n->neoncache[i].t == NEON_CACHE_ST_D
+         || n->neoncache[i].t == NEON_CACHE_ST_I64)
+            n->neoncache[i].v = 0;
+}
+
+static void mmx_reset(neoncache_t* n)
+{
+    n->mmxcount = 0;
+    for (int i=0; i<8; ++i)
+        n->mmxcache[i] = -1;
+}
+
+static void sse_reset(neoncache_t* n)
+{
+    for (int i=0; i<16; ++i)
+        n->ssecache[i].v = -1;
+}
+
+void fpu_reset(dynarec_arm_t* dyn)
+{
+    x87_reset(&dyn->n);
+    mmx_reset(&dyn->n);
+    sse_reset(&dyn->n);
+    fpu_reset_reg(dyn);
+}
+
+void fpu_reset_ninst(dynarec_arm_t* dyn, int ninst)
+{
+    x87_reset(&dyn->insts[ninst].n);
+    mmx_reset(&dyn->insts[ninst].n);
+    sse_reset(&dyn->insts[ninst].n);
+    fpu_reset_reg_neoncache(&dyn->insts[ninst].n);
+}
diff --git a/src/dynarec/arm64/dynarec_arm64_functions.h b/src/dynarec/arm64/dynarec_arm64_functions.h
index 507a191d..56039889 100644
--- a/src/dynarec/arm64/dynarec_arm64_functions.h
+++ b/src/dynarec/arm64/dynarec_arm64_functions.h
@@ -54,4 +54,8 @@ const char* getCacheName(int t, int n);
 
 void inst_name_pass3(dynarec_native_t* dyn, int ninst, const char* name, rex_t rex);
 void print_opcode(dynarec_native_t* dyn, int ninst, uint32_t opcode);
+
+// reset the cache
+void fpu_reset(dynarec_native_t* dyn);
+void fpu_reset_ninst(dynarec_native_t* dyn, int ninst);
 #endif //__DYNAREC_ARM_FUNCTIONS_H__
diff --git a/src/dynarec/arm64/dynarec_arm64_helper.c b/src/dynarec/arm64/dynarec_arm64_helper.c
index efeb883e..b6dff229 100644
--- a/src/dynarec/arm64/dynarec_arm64_helper.c
+++ b/src/dynarec/arm64/dynarec_arm64_helper.c
@@ -851,27 +851,6 @@ void grab_segdata(dynarec_arm_t* dyn, uintptr_t addr, int ninst, int reg, int se
 }
 
 // x87 stuffs
-static void x87_reset(dynarec_arm_t* dyn)
-{
-    for (int i=0; i<8; ++i) {
-        dyn->n.x87cache[i] = -1;
-        dyn->n.freed[i] = -1;
-    }
-    dyn->n.x87stack = 0;
-    dyn->n.stack = 0;
-    dyn->n.stack_next = 0;
-    dyn->n.stack_pop = 0;
-    dyn->n.stack_push = 0;
-    dyn->n.combined1 = dyn->n.combined2 = 0;
-    dyn->n.swapped = 0;
-    dyn->n.barrier = 0;
-    for(int i=0; i<24; ++i)
-        if(dyn->n.neoncache[i].t == NEON_CACHE_ST_F
-         || dyn->n.neoncache[i].t == NEON_CACHE_ST_D
-         || dyn->n.neoncache[i].t == NEON_CACHE_ST_I64)
-            dyn->n.neoncache[i].v = 0;
-}
-
 int x87_stackcount(dynarec_arm_t* dyn, int ninst, int scratch)
 {
     MAYUSE(scratch);
@@ -1518,12 +1497,6 @@ void x87_restoreround(dynarec_arm_t* dyn, int ninst, int s1)
 }
 
 // MMX helpers
-static void mmx_reset(dynarec_arm_t* dyn)
-{
-    dyn->n.mmxcount = 0;
-    for (int i=0; i<8; ++i)
-        dyn->n.mmxcache[i] = -1;
-}
 static int isx87Empty(dynarec_arm_t* dyn)
 {
     for (int i=0; i<8; ++i)
@@ -1590,11 +1563,6 @@ static void mmx_reflectcache(dynarec_arm_t* dyn, int ninst, int s1)
 
 
 // SSE / SSE2 helpers
-static void sse_reset(dynarec_arm_t* dyn)
-{
-    for (int i=0; i<16; ++i)
-        dyn->n.ssecache[i].v = -1;
-}
 // get neon register for a SSE reg, create the entry if needed
 int sse_get_reg(dynarec_arm_t* dyn, int ninst, int s1, int a, int forwrite)
 {
@@ -2162,14 +2130,6 @@ void fpu_unreflectcache(dynarec_arm_t* dyn, int ninst, int s1, int s2, int s3)
     x87_unreflectcache(dyn, ninst, s1, s2, s3);
 }
 
-void fpu_reset(dynarec_arm_t* dyn)
-{
-    x87_reset(dyn);
-    mmx_reset(dyn);
-    sse_reset(dyn);
-    fpu_reset_reg(dyn);
-}
-
 void emit_pf(dynarec_arm_t* dyn, int ninst, int s1, int s3, int s4)
 {
     MAYUSE(dyn); MAYUSE(ninst);
diff --git a/src/dynarec/arm64/dynarec_arm64_helper.h b/src/dynarec/arm64/dynarec_arm64_helper.h
index fa7c63b0..b779a337 100644
--- a/src/dynarec/arm64/dynarec_arm64_helper.h
+++ b/src/dynarec/arm64/dynarec_arm64_helper.h
@@ -792,26 +792,38 @@
     LDP_REGS(R12, R13);     \
     LDP_REGS(R14, R15)
 
+#if STEP == 0
+#define X87_PUSH_OR_FAIL(var, dyn, ninst, scratch, t)   var = x87_do_push(dyn, ninst, scratch, t)
+#define X87_PUSH_EMPTY_OR_FAIL(dyn, ninst, scratch)     x87_do_push_empty(dyn, ninst, scratch)
+#define X87_POP_OR_FAIL(dyn, ninst, scratch)            x87_do_pop(dyn, ninst, scratch)
+#else
 #define X87_PUSH_OR_FAIL(var, dyn, ninst, scratch, t) \
-    if (dyn->n.stack == +8) {                         \
+    if (dyn->n.x87stack == +8) {                      \
+        if(box64_dynarec_dump) dynarec_log(LOG_INFO, " Warning, suspicious x87 Push, stack=%d on inst %d\n", dyn->n.x87stack, ninst); \
         DEFAULT;                                      \
+        dyn->abort = 1;                               \
         return addr;                                  \
     }                                                 \
-    var = x87_do_push(dyn, ninst, scratch, t);
+    var = x87_do_push(dyn, ninst, scratch, t)
 
 #define X87_PUSH_EMPTY_OR_FAIL(dyn, ninst, scratch) \
-    if (dyn->n.stack == +8) {                       \
+    if (dyn->n.x87stack == +8) {                       \
+        if(box64_dynarec_dump) dynarec_log(LOG_INFO, " Warning, suspicious x87 Push, stack=%d on inst %d\n", dyn->n.x87stack, ninst); \
         DEFAULT;                                    \
+        dyn->abort = 1;                             \
         return addr;                                \
     }                                               \
-    x87_do_push_empty(dyn, ninst, scratch);
+    x87_do_push_empty(dyn, ninst, scratch)
 
 #define X87_POP_OR_FAIL(dyn, ninst, scratch) \
-    if (dyn->n.stack == -8) {                \
+    if (dyn->n.x87stack == -8) {                \
+        if(box64_dynarec_dump) dynarec_log(LOG_INFO, " Warning, suspicious x87 Pop, stack=%d on inst %d\n", dyn->n.x87stack, ninst); \
         DEFAULT;                             \
+        dyn->abort = 1;                      \
         return addr;                         \
     }                                        \
-    x87_do_pop(dyn, ninst, scratch);
+    x87_do_pop(dyn, ninst, scratch)
+#endif
 
 #define SET_DFNONE(S)    if(!dyn->f.dfnone) {STRw_U12(wZR, xEmu, offsetof(x64emu_t, df)); dyn->f.dfnone=1;}
 #define SET_DF(S, N)        \
@@ -1109,7 +1121,6 @@ void* arm64_next(x64emu_t* emu, uintptr_t addr);
 
 #define fpu_pushcache   STEPNAME(fpu_pushcache)
 #define fpu_popcache    STEPNAME(fpu_popcache)
-#define fpu_reset       STEPNAME(fpu_reset)
 #define fpu_reset_cache STEPNAME(fpu_reset_cache)
 #define fpu_propagate_stack STEPNAME(fpu_propagate_stack)
 #define fpu_purgecache  STEPNAME(fpu_purgecache)
@@ -1322,8 +1333,6 @@ void sse_purge07cache(dynarec_arm_t* dyn, int ninst, int s1);
 // Push current value to the cache
 void sse_reflect_reg(dynarec_arm_t* dyn, int ninst, int a);
 // common coproc helpers
-// reset the cache
-void fpu_reset(dynarec_arm_t* dyn);
 // reset the cache with n
 void fpu_reset_cache(dynarec_arm_t* dyn, int ninst, int reset_n);
 // propagate stack state
diff --git a/src/dynarec/arm64/dynarec_arm64_private.h b/src/dynarec/arm64/dynarec_arm64_private.h
index f7e7b008..10945534 100644
--- a/src/dynarec/arm64/dynarec_arm64_private.h
+++ b/src/dynarec/arm64/dynarec_arm64_private.h
@@ -120,6 +120,7 @@ typedef struct dynarec_arm_s {
     uint8_t             doublepush;
     uint8_t             doublepop;
     uint8_t             always_test;
+    uint8_t             abort;      // abort the creation of the block
 } dynarec_arm_t;
 
 void add_next(dynarec_arm_t *dyn, uintptr_t addr);
diff --git a/src/dynarec/dynarec_native.c b/src/dynarec/dynarec_native.c
index 46360231..600d23d1 100644
--- a/src/dynarec/dynarec_native.c
+++ b/src/dynarec/dynarec_native.c
@@ -483,6 +483,11 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr, int alternate, int is32bit
     helper.insts = (instruction_native_t*)dynaCalloc(helper.cap, sizeof(instruction_native_t));
     // pass 0, addresses, x64 jump addresses, overall size of the block
     uintptr_t end = native_pass0(&helper, addr, alternate, is32bits);
+    if(helper.abort) {
+        if(box64_dynarec_dump || box64_dynarec_log)dynarec_log(LOG_NONE, "Abort dynablock on pass0\n");
+        CancelBlock64(0);
+        return NULL;
+    }
     // basic checks
     if(!helper.size) {
         dynarec_log(LOG_INFO, "Warning, null-sized dynarec block (%p)\n", (void*)addr);
@@ -557,12 +562,31 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr, int alternate, int is32bit
     int pos = helper.size;
     while (pos>=0)
         pos = updateNeed(&helper, pos, 0);
+    // remove fpu stuff on non-executed code
+    for(int i=1; i<helper.size-1; ++i)
+        if(!helper.insts[i].pred_sz) {
+            int ii = i;
+            while(ii<helper.size && !helper.insts[ii].pred_sz)
+                fpu_reset_ninst(&helper, ii++);
+            i = ii;
+        }
+
 
     // pass 1, float optimizations, first pass for flags
     native_pass1(&helper, addr, alternate, is32bits);
+    if(helper.abort) {
+        if(box64_dynarec_dump || box64_dynarec_log)dynarec_log(LOG_NONE, "Abort dynablock on pass1\n");
+        CancelBlock64(0);
+        return NULL;
+    }
     
     // pass 2, instruction size
     native_pass2(&helper, addr, alternate, is32bits);
+    if(helper.abort) {
+        if(box64_dynarec_dump || box64_dynarec_log)dynarec_log(LOG_NONE, "Abort dynablock on pass2\n");
+        CancelBlock64(0);
+        return NULL;
+    }
     // keep size of instructions for signal handling
     size_t insts_rsize = (helper.insts_size+2)*sizeof(instsize_t);
     insts_rsize = (insts_rsize+7)&~7;   // round the size...
@@ -603,6 +627,11 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr, int alternate, int is32bit
     helper.table64size = 0; // reset table64 (but not the cap)
     helper.insts_size = 0;  // reset
     native_pass3(&helper, addr, alternate, is32bits);
+    if(helper.abort) {
+        if(box64_dynarec_dump || box64_dynarec_log)dynarec_log(LOG_NONE, "Abort dynablock on pass1\n");
+        CancelBlock64(0);
+        return NULL;
+    }
     // keep size of instructions for signal handling
     block->instsize = instsize;
     // ok, free the helper now
diff --git a/src/dynarec/dynarec_native_pass.c b/src/dynarec/dynarec_native_pass.c
index e9ef81a5..471e2c98 100644
--- a/src/dynarec/dynarec_native_pass.c
+++ b/src/dynarec/dynarec_native_pass.c
@@ -157,7 +157,8 @@ uintptr_t native_pass(dynarec_native_t* dyn, uintptr_t addr, int alternate, int
             }
 
         addr = dynarec64_00(dyn, addr, ip, ninst, rex, rep, &ok, &need_epilog);
-
+        if(dyn->abort)
+            return addr;
         INST_EPILOG;
 
         int next = ninst+1;
@@ -183,7 +184,7 @@ uintptr_t native_pass(dynarec_native_t* dyn, uintptr_t addr, int alternate, int
             // we use the 1st predecessor here
             int ii = ninst+1;
             if(ii<dyn->size && !dyn->insts[ii].pred_sz) {
-                while(ii<dyn->size && (!dyn->insts[ii].pred_sz || (dyn->insts[ii].pred_sz==1 && dyn->insts[ii].pred[0]==ii-1))) {
+                while(ii<dyn->size && !dyn->insts[ii].pred_sz) {
                     // may need to skip opcodes to advance
                     ++ninst;
                     NEW_INST;
diff --git a/src/dynarec/rv64/dynarec_rv64_functions.c b/src/dynarec/rv64/dynarec_rv64_functions.c
index b9995f7d..3b95c06e 100644
--- a/src/dynarec/rv64/dynarec_rv64_functions.c
+++ b/src/dynarec/rv64/dynarec_rv64_functions.c
@@ -81,14 +81,18 @@ int fpu_get_reg_xmm(dynarec_rv64_t* dyn, int t, int xmm)
     return EXTREG(i);
 }
 // Reset fpu regs counter
-void fpu_reset_reg(dynarec_rv64_t* dyn)
+void fpu_reset_reg_extcache(extcache_t* e)
 {
-    dyn->e.fpu_reg = 0;
+    e->fpu_reg = 0;
     for (int i=0; i<24; ++i) {
-        dyn->e.fpuused[i]=0;
-        dyn->e.extcache[i].v = 0;
+        e->fpuused[i]=0;
+        e->extcache[i].v = 0;
     }
 }
+void fpu_reset_reg(dynarec_rv64_t* dyn)
+{
+    fpu_reset_reg_extcache(&dyn->e);
+}
 
 int extcache_no_i64(dynarec_rv64_t* dyn, int ninst, int st, int a)
 {
@@ -613,3 +617,52 @@ void print_newinst(dynarec_native_t* dyn, int ninst)
         (box64_dynarec_dump>1)?"\e[m":""
         );
 }
+
+// x87 stuffs
+static void x87_reset(extcache_t* e)
+{
+    for (int i=0; i<8; ++i)
+        e->x87cache[i] = -1;
+    e->x87stack = 0;
+    e->stack = 0;
+    e->stack_next = 0;
+    e->stack_pop = 0;
+    e->stack_push = 0;
+    e->combined1 = e->combined2 = 0;
+    e->swapped = 0;
+    e->barrier = 0;
+    for(int i=0; i<24; ++i)
+        if (e->extcache[i].t == EXT_CACHE_ST_F
+            || e->extcache[i].t == EXT_CACHE_ST_D
+            || e->extcache[i].t == EXT_CACHE_ST_I64)
+            e->extcache[i].v = 0;
+}
+
+static void mmx_reset(extcache_t* e)
+{
+    e->mmxcount = 0;
+    for (int i=0; i<8; ++i)
+        e->mmxcache[i] = -1;
+}
+
+static void sse_reset(extcache_t* e)
+{
+    for (int i=0; i<16; ++i)
+        e->ssecache[i].v = -1;
+}
+
+void fpu_reset(dynarec_rv64_t* dyn)
+{
+    x87_reset(&dyn->e);
+    mmx_reset(&dyn->e);
+    sse_reset(&dyn->e);
+    fpu_reset_reg(dyn);
+}
+
+void fpu_reset_ninst(dynarec_rv64_t* dyn, int ninst)
+{
+    x87_reset(&dyn->insts[ninst].e);
+    mmx_reset(&dyn->insts[ninst].e);
+    sse_reset(&dyn->insts[ninst].e);
+    fpu_reset_reg_extcache(&dyn->insts[ninst].e);
+}
diff --git a/src/dynarec/rv64/dynarec_rv64_functions.h b/src/dynarec/rv64/dynarec_rv64_functions.h
index b265f694..01b5e9a4 100644
--- a/src/dynarec/rv64/dynarec_rv64_functions.h
+++ b/src/dynarec/rv64/dynarec_rv64_functions.h
@@ -55,4 +55,7 @@ void inst_name_pass3(dynarec_native_t* dyn, int ninst, const char* name, rex_t r
 void print_opcode(dynarec_native_t* dyn, int ninst, uint32_t opcode);
 void print_newinst(dynarec_native_t* dyn, int ninst);
 
+// reset the cache
+void fpu_reset(dynarec_native_t* dyn);
+void fpu_reset_ninst(dynarec_native_t* dyn, int ninst);
 #endif //__DYNAREC_RV64_FUNCTIONS_H__
diff --git a/src/dynarec/rv64/dynarec_rv64_helper.c b/src/dynarec/rv64/dynarec_rv64_helper.c
index bb0ef4a2..68b00042 100644
--- a/src/dynarec/rv64/dynarec_rv64_helper.c
+++ b/src/dynarec/rv64/dynarec_rv64_helper.c
@@ -828,26 +828,6 @@ void grab_segdata(dynarec_rv64_t* dyn, uintptr_t addr, int ninst, int reg, int s
     MESSAGE(LOG_DUMP, "----%s Offset\n", (segment==_FS)?"FS":"GS");
 }
 
-// x87 stuffs
-static void x87_reset(dynarec_rv64_t* dyn)
-{
-    for (int i=0; i<8; ++i)
-        dyn->e.x87cache[i] = -1;
-    dyn->e.x87stack = 0;
-    dyn->e.stack = 0;
-    dyn->e.stack_next = 0;
-    dyn->e.stack_pop = 0;
-    dyn->e.stack_push = 0;
-    dyn->e.combined1 = dyn->e.combined2 = 0;
-    dyn->e.swapped = 0;
-    dyn->e.barrier = 0;
-    for(int i=0; i<24; ++i)
-        if (dyn->e.extcache[i].t == EXT_CACHE_ST_F
-            || dyn->e.extcache[i].t == EXT_CACHE_ST_D
-            || dyn->e.extcache[i].t == EXT_CACHE_ST_I64)
-            dyn->e.extcache[i].v = 0;
-}
-
 void x87_stackcount(dynarec_rv64_t* dyn, int ninst, int scratch)
 {
     MAYUSE(scratch);
@@ -1362,12 +1342,6 @@ void x87_restoreround(dynarec_rv64_t* dyn, int ninst, int s1)
 }
 
 // MMX helpers
-static void mmx_reset(dynarec_rv64_t* dyn)
-{
-    dyn->e.mmxcount = 0;
-    for (int i=0; i<8; ++i)
-        dyn->e.mmxcache[i] = -1;
-}
 static int isx87Empty(dynarec_rv64_t* dyn)
 {
     for (int i=0; i<8; ++i)
@@ -1443,11 +1417,6 @@ static void mmx_reflectcache(dynarec_rv64_t* dyn, int ninst, int s1)
 }
 
 // SSE / SSE2 helpers
-static void sse_reset(dynarec_rv64_t* dyn)
-{
-    for (int i=0; i<16; ++i)
-        dyn->e.ssecache[i].v = -1;
-}
 // get ext register for a SSE reg, create the entry if needed
 int sse_get_reg(dynarec_rv64_t* dyn, int ninst, int s1, int a, int single)
 {
@@ -2144,14 +2113,6 @@ void fpu_unreflectcache(dynarec_rv64_t* dyn, int ninst, int s1, int s2, int s3)
     x87_unreflectcache(dyn, ninst, s1, s2, s3);
 }
 
-void fpu_reset(dynarec_rv64_t* dyn)
-{
-    x87_reset(dyn);
-    mmx_reset(dyn);
-    sse_reset(dyn);
-    fpu_reset_reg(dyn);
-}
-
 void emit_pf(dynarec_rv64_t* dyn, int ninst, int s1, int s3, int s4)
 {
     MAYUSE(dyn); MAYUSE(ninst);
diff --git a/src/dynarec/rv64/dynarec_rv64_helper.h b/src/dynarec/rv64/dynarec_rv64_helper.h
index e17eeafb..f6afa7ec 100644
--- a/src/dynarec/rv64/dynarec_rv64_helper.h
+++ b/src/dynarec/rv64/dynarec_rv64_helper.h
@@ -882,8 +882,14 @@
     SLLI(dst, dst, 11 - 5);             \
     OR(dst, dst, s1)
 
+#if STEP == 0
+#define X87_PUSH_OR_FAIL(var, dyn, ninst, scratch, t)   var = x87_do_push(dyn, ninst, scratch, t)
+#define X87_PUSH_EMPTY_OR_FAIL(dyn, ninst, scratch)     x87_do_push_empty(dyn, ninst, scratch)
+#define X87_POP_OR_FAIL(dyn, ninst, scratch)            x87_do_pop(dyn, ninst, scratch)
+#else
 #define X87_PUSH_OR_FAIL(var, dyn, ninst, scratch, t) \
     if (dyn->e.stack == +8) {                         \
+        if(box64_dynarec_dump) dynarec_log(LOG_INFO, " Warning, suspicious x87 Push, stack=%d on inst %d\n", dyn->n.x87stack, ninst); \
         DEFAULT;                                      \
         return addr;                                  \
     }                                                 \
@@ -891,6 +897,7 @@
 
 #define X87_PUSH_EMPTY_OR_FAIL(dyn, ninst, scratch) \
     if (dyn->e.stack == +8) {                       \
+        if(box64_dynarec_dump) dynarec_log(LOG_INFO, " Warning, suspicious x87 Push, stack=%d on inst %d\n", dyn->n.x87stack, ninst); \
         DEFAULT;                                    \
         return addr;                                \
     }                                               \
@@ -898,11 +905,12 @@
 
 #define X87_POP_OR_FAIL(dyn, ninst, scratch) \
     if (dyn->e.stack == -8) {                \
+        if(box64_dynarec_dump) dynarec_log(LOG_INFO, " Warning, suspicious x87 Pop, stack=%d on inst %d\n", dyn->n.x87stack, ninst); \
         DEFAULT;                             \
         return addr;                         \
     }                                        \
     x87_do_pop(dyn, ninst, scratch);
-
+#endif
 
 #ifndef MAYSETFLAGS
 #define MAYSETFLAGS()
@@ -1186,7 +1194,6 @@ void* rv64_next(x64emu_t* emu, uintptr_t addr);
 
 #define fpu_pushcache       STEPNAME(fpu_pushcache)
 #define fpu_popcache        STEPNAME(fpu_popcache)
-#define fpu_reset           STEPNAME(fpu_reset)
 #define fpu_reset_cache     STEPNAME(fpu_reset_cache)
 #define fpu_propagate_stack STEPNAME(fpu_propagate_stack)
 #define fpu_purgecache      STEPNAME(fpu_purgecache)
@@ -1390,8 +1397,6 @@ void sse_purge07cache(dynarec_rv64_t* dyn, int ninst, int s1);
 void sse_reflect_reg(dynarec_rv64_t* dyn, int ninst, int a);
 
 // common coproc helpers
-// reset the cache
-void fpu_reset(dynarec_rv64_t* dyn);
 // reset the cache with n
 void fpu_reset_cache(dynarec_rv64_t* dyn, int ninst, int reset_n);
 // propagate stack state
diff --git a/src/dynarec/rv64/dynarec_rv64_private.h b/src/dynarec/rv64/dynarec_rv64_private.h
index 6cd32413..6a870bf7 100644
--- a/src/dynarec/rv64/dynarec_rv64_private.h
+++ b/src/dynarec/rv64/dynarec_rv64_private.h
@@ -127,6 +127,7 @@ typedef struct dynarec_rv64_s {
     int32_t             forward_size;   // size at the forward point
     int                 forward_ninst;  // ninst at the forward point
     uint8_t             always_test;
+    uint8_t             abort;
 } dynarec_rv64_t;
 
 // convert idx (0..24) to reg index (10..31 0..1)