[DYNAREC] Pass0 now alocate memory and do more stuff from pass1

10 files changed, 101 insertions, 107 deletions

diff --git a/src/dynarec/dynarec_arm64.c b/src/dynarec/dynarec_arm64.c
index 3df317b3..22ea6ad1 100755
--- a/src/dynarec/dynarec_arm64.c
+++ b/src/dynarec/dynarec_arm64.c
@@ -344,25 +344,28 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr) {
     dynarec_arm_t helper = {0};
     helper.start = addr;
     uintptr_t start = addr;
+    helper.cap = 64; // needs epilog handling
+    helper.insts = (instruction_arm64_t*)calloc(helper.cap, sizeof(instruction_arm64_t));
+    // pass 0, addresses, x86 jump addresses, overall size of the block
     uintptr_t end = arm_pass0(&helper, addr);
     if(!helper.size) {
-        dynarec_log(LOG_DEBUG, "Warning, null-sized dynarec block (%p)\n", (void*)addr);
+        dynarec_log(LOG_INFO, "Warning, null-sized dynarec block (%p)\n", (void*)addr);
+        free(helper.next);
+        free(helper.insts);
         block->done = 1;
         return (void*)block;
     }
     if(!isprotectedDB(addr, 1)) {
-        dynarec_log(LOG_DEBUG, "Warning, write on purge on pass0 (%p)\n", (void*)addr);
+        dynarec_log(LOG_INFO, "Warning, write on current page on pass0, aborting dynablock creation (%p)\n", (void*)addr);
+        free(helper.next);
+        free(helper.insts);
         block->done = 1;
-        return (void*)block;
+        return NULL;
     }
-    helper.cap = helper.size+3; // needs epilog handling
-    helper.insts = (instruction_arm64_t*)calloc(helper.cap, sizeof(instruction_arm64_t));
     // already protect the block and compute hash signature
     if((addr&~0xfff)!=(end&~0xfff)) // need to protect some other pages too
         protectDB(addr, end-addr);  //end is 1byte after actual end
     uint32_t hash = X31_hash_code((void*)addr, end-addr);
-    // pass 1, addresses, x64 jump addresses, flags
-    arm_pass1(&helper, addr);
     // calculate barriers
     for(int i=0; i<helper.size; ++i)
         if(helper.insts[i].x64.jmp) {
@@ -381,6 +384,8 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr) {
                 helper.insts[i].x64.jmp_insts = k;
             }
         }
+    // pass 1, flags
+    arm_pass1(&helper, addr);
     for(int i=0; i<helper.size; ++i)
         if(helper.insts[i].x64.set_flags && !helper.insts[i].x64.need_flags) {
             helper.insts[i].x64.need_flags = needed_flags(&helper, i+1, helper.insts[i].x64.set_flags, 0);
@@ -394,7 +399,7 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr) {
     size_t sz = helper.arm_size + helper.table64size*sizeof(uint64_t);
     void* p = (void*)AllocDynarecMap(block, sz);
     if(p==NULL) {
-        dynarec_log(LOG_DEBUG, "AllocDynarecMap(%p, %zu) failed, cancelling block\n", block, sz);
+        dynarec_log(LOG_INFO, "AllocDynarecMap(%p, %zu) failed, cancelling block\n", block, sz);
         free(helper.insts);
         free(helper.next);
         free(helper.table64);
diff --git a/src/dynarec/dynarec_arm64_00.c b/src/dynarec/dynarec_arm64_00.c
index dd3262f7..b3a91486 100755
--- a/src/dynarec/dynarec_arm64_00.c
+++ b/src/dynarec/dynarec_arm64_00.c
@@ -639,17 +639,15 @@ uintptr_t dynarec64_00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
             BARRIER(2); \
             JUMP(addr+i8);\
             GETFLAGS;   \
-            if(dyn->insts) {    \
-                if(dyn->insts[ninst].x64.jmp_insts==-1) {   \
-                    /* out of the block */                  \
-                    i32 = dyn->insts[ninst+1].address-(dyn->arm_size); \
-                    Bcond(NO, i32);     \
-                    jump_to_next(dyn, addr+i8, 0, ninst); \
-                } else {    \
-                    /* inside the block */  \
-                    i32 = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);    \
-                    Bcond(YES, i32);    \
-                }   \
+            if(dyn->insts[ninst].x64.jmp_insts==-1) {   \
+                /* out of the block */                  \
+                i32 = dyn->insts[ninst+1].address-(dyn->arm_size); \
+                Bcond(NO, i32);     \
+                jump_to_next(dyn, addr+i8, 0, ninst); \
+            } else {    \
+                /* inside the block */  \
+                i32 = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);    \
+                Bcond(YES, i32);    \
             }
 
         GOCOND(0x70, "J", "ib");
@@ -1970,17 +1968,15 @@ uintptr_t dynarec64_00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
         #define GO(Z)                                                   \
             BARRIER(2);                                                 \
             JUMP(addr+i8);                                              \
-            if(dyn->insts) {                                            \
-                if(dyn->insts[ninst].x64.jmp_insts==-1) {               \
-                    /* out of the block */                              \
-                    i32 = dyn->insts[ninst+1].address-(dyn->arm_size);  \
-                    if(Z) {CBNZx(xRCX, i32);} else {CBZx(xRCX, i32);};  \
-                    jump_to_next(dyn, addr+i8, 0, ninst);               \
-                } else {                                                \
-                    /* inside the block */                              \
-                    i32 = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);    \
-                    if(Z) {CBZx(xRCX, i32);} else {CBNZx(xRCX, i32);};  \
-                }   \
+            if(dyn->insts[ninst].x64.jmp_insts==-1) {               \
+                /* out of the block */                              \
+                i32 = dyn->insts[ninst+1].address-(dyn->arm_size);  \
+                if(Z) {CBNZx(xRCX, i32);} else {CBZx(xRCX, i32);};  \
+                jump_to_next(dyn, addr+i8, 0, ninst);               \
+            } else {                                                \
+                /* inside the block */                              \
+                i32 = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);    \
+                if(Z) {CBZx(xRCX, i32);} else {CBNZx(xRCX, i32);};  \
             }
         case 0xE0:
             INST_NAME("LOOPNZ");
@@ -2019,12 +2015,7 @@ uintptr_t dynarec64_00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
                 printf_log(LOG_INFO, "Warning, CALL to 0x0 at %p (%p)\n", (void*)addr, (void*)(addr-1));
                 #endif
             }
-            #if STEP == 0
-            if(isNativeCall(dyn, addr+i32, NULL, NULL))
-                tmp = 3;
-            else 
-                tmp = 0;
-            #elif STEP < 2
+            #if STEP < 2
             if(isNativeCall(dyn, addr+i32, &dyn->insts[ninst].natcall, &dyn->insts[ninst].retn))
                 tmp = dyn->insts[ninst].pass2choice = 3;
             else 
@@ -2042,7 +2033,7 @@ uintptr_t dynarec64_00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
                     MESSAGE(LOG_DUMP, "Native Call to %s (retn=%d)\n", GetNativeName(GetNativeFnc(dyn->insts[ninst].natcall-1)), dyn->insts[ninst].retn);
                     // calling a native function
                     sse_purge07cache(dyn, ninst, x3);
-                    if(box64_log<2 && dyn->insts && (tmp=isSimpleWrapper(*(wrapper_t*)(dyn->insts[ninst].natcall+2)))) {
+                    if(box64_log<2 && dyn->insts[ninst].natcall && (tmp=isSimpleWrapper(*(wrapper_t*)(dyn->insts[ninst].natcall+2)))) {
                         //GETIP(ip+3+8+8); // read the 0xCC
                         call_n(dyn, ninst, *(void**)(dyn->insts[ninst].natcall+2+8), tmp);
                         POP1(xRIP);   // pop the return address
@@ -2104,18 +2095,16 @@ uintptr_t dynarec64_00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
                 i32 = F8S;
             }
             JUMP(addr+i32);
-            if(dyn->insts) {
-                PASS2IF(dyn->insts[ninst].x64.jmp_insts==-1, 1) {
-                    // out of the block
-                    jump_to_next(dyn, addr+i32, 0, ninst);
+            PASS2IF(dyn->insts[ninst].x64.jmp_insts==-1, 1) {
+                // out of the block
+                jump_to_next(dyn, addr+i32, 0, ninst);
+            } else {
+                // inside the block
+                tmp = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);
+                if(tmp==4) {
+                    NOP;
                 } else {
-                    // inside the block
-                    tmp = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);
-                    if(tmp==4) {
-                        NOP;
-                    } else {
-                        B(tmp);
-                    }
+                    B(tmp);
                 }
             }
             *need_epilog = 0;
@@ -2384,8 +2373,7 @@ uintptr_t dynarec64_00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
                     break;
                 case 2: // CALL Ed
                     INST_NAME("CALL Ed");
-                    PASS2IF(dyn->insts && 
-                           ((ninst && dyn->insts[ninst-1].x64.set_flags)
+                    PASS2IF(((ninst && dyn->insts[ninst-1].x64.set_flags)
                         || ((ninst>1) && dyn->insts[ninst-2].x64.set_flags)), 1)
                     {
                         READFLAGS(X_PEND);          // that's suspicious
diff --git a/src/dynarec/dynarec_arm64_0f.c b/src/dynarec/dynarec_arm64_0f.c
index d8621a4a..2704c1b3 100755
--- a/src/dynarec/dynarec_arm64_0f.c
+++ b/src/dynarec/dynarec_arm64_0f.c
@@ -992,18 +992,16 @@ uintptr_t dynarec64_0F(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
             BARRIER(2);     \

             JUMP(addr+i32_);\

             GETFLAGS;   \

-            if(dyn->insts) {    \

-                if(dyn->insts[ninst].x64.jmp_insts==-1) {   \

-                    /* out of the block */                  \

-                    i32 = dyn->insts[ninst+1].address-(dyn->arm_size); \

-                    Bcond(NO, i32);     \

-                    jump_to_next(dyn, addr+i32_, 0, ninst); \

-                } else {    \

-                    /* inside the block */  \

-                    i32 = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);    \

-                    Bcond(YES, i32);    \

-                }   \

-            }

+            if(dyn->insts[ninst].x64.jmp_insts==-1) {   \

+                /* out of the block */                  \

+                i32 = dyn->insts[ninst+1].address-(dyn->arm_size); \

+                Bcond(NO, i32);     \

+                jump_to_next(dyn, addr+i32_, 0, ninst); \

+            } else {    \

+                /* inside the block */  \

+                i32 = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);    \

+                Bcond(YES, i32);    \

+            }   \

 

         GOCOND(0x80, "J", "Id");

         #undef GO

diff --git a/src/dynarec/dynarec_arm64_64.c b/src/dynarec/dynarec_arm64_64.c
index 98fc3895..207a7245 100644
--- a/src/dynarec/dynarec_arm64_64.c
+++ b/src/dynarec/dynarec_arm64_64.c
@@ -801,8 +801,7 @@ uintptr_t dynarec64_64(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
                     break;
                 case 2: // CALL Ed
                     INST_NAME("CALL Ed");
-                    PASS2IF(dyn->insts && 
-                           ((ninst && dyn->insts[ninst-1].x64.set_flags)
+                    PASS2IF(((ninst && dyn->insts[ninst-1].x64.set_flags)
                         || ((ninst>1) && dyn->insts[ninst-2].x64.set_flags)), 1)
                     {
                         READFLAGS(X_PEND);          // that's suspicious
diff --git a/src/dynarec/dynarec_arm64_67.c b/src/dynarec/dynarec_arm64_67.c
index 616cd715..4e0e0a26 100755
--- a/src/dynarec/dynarec_arm64_67.c
+++ b/src/dynarec/dynarec_arm64_67.c
@@ -227,17 +227,15 @@ uintptr_t dynarec64_67(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
         #define GO(NO, YES)   \

             BARRIER(2); \

             JUMP(addr+i8);\

-            if(dyn->insts) {    \

-                if(dyn->insts[ninst].x64.jmp_insts==-1) {   \

-                    /* out of the block */                  \

-                    i32 = dyn->insts[ninst+1].address-(dyn->arm_size); \

-                    Bcond(NO, i32);     \

-                    jump_to_next(dyn, addr+i8, 0, ninst); \

-                } else {    \

-                    /* inside the block */  \

-                    i32 = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);    \

-                    Bcond(YES, i32);    \

-                }   \

+            if(dyn->insts[ninst].x64.jmp_insts==-1) {   \

+                /* out of the block */                  \

+                i32 = dyn->insts[ninst+1].address-(dyn->arm_size); \

+                Bcond(NO, i32);     \

+                jump_to_next(dyn, addr+i8, 0, ninst); \

+            } else {    \

+                /* inside the block */  \

+                i32 = dyn->insts[dyn->insts[ninst].x64.jmp_insts].address-(dyn->arm_size);    \

+                Bcond(YES, i32);    \

             }

         case 0xE0:

             INST_NAME("LOOPNZ (32bits)");

diff --git a/src/dynarec/dynarec_arm64_helper.h b/src/dynarec/dynarec_arm64_helper.h
index 1ec25bc7..b16c2b8f 100755
--- a/src/dynarec/dynarec_arm64_helper.h
+++ b/src/dynarec/dynarec_arm64_helper.h
@@ -312,18 +312,18 @@
 // R0 will not be pushed/popd if ret is -2. Flags are not save/restored
 #define CALL_S(F, ret) call_c(dyn, ninst, F, x7, ret, 0, 0)
 
-#define MARK    if(dyn->insts) {dyn->insts[ninst].mark = dyn->arm_size;}
-#define GETMARK ((dyn->insts)?dyn->insts[ninst].mark:(dyn->arm_size+4))
-#define MARK2   if(dyn->insts) {dyn->insts[ninst].mark2 = dyn->arm_size;}
-#define GETMARK2 ((dyn->insts)?dyn->insts[ninst].mark2:(dyn->arm_size+4))
-#define MARK3   if(dyn->insts) {dyn->insts[ninst].mark3 = dyn->arm_size;}
-#define GETMARK3 ((dyn->insts)?dyn->insts[ninst].mark3:(dyn->arm_size+4))
-#define MARKF   if(dyn->insts) {dyn->insts[ninst].markf = dyn->arm_size;}
-#define GETMARKF ((dyn->insts)?dyn->insts[ninst].markf:(dyn->arm_size+4))
-#define MARKSEG if(dyn->insts) {dyn->insts[ninst].markseg = dyn->arm_size;}
-#define GETMARKSEG ((dyn->insts)?dyn->insts[ninst].markseg:(dyn->arm_size+4))
-#define MARKLOCK if(dyn->insts) {dyn->insts[ninst].marklock = dyn->arm_size;}
-#define GETMARKLOCK ((dyn->insts)?dyn->insts[ninst].marklock:(dyn->arm_size+4))
+#define MARK    dyn->insts[ninst].mark = dyn->arm_size
+#define GETMARK dyn->insts[ninst].mark
+#define MARK2   dyn->insts[ninst].mark2 = dyn->arm_size
+#define GETMARK2 dyn->insts[ninst].mark2
+#define MARK3   dyn->insts[ninst].mark3 = dyn->arm_size
+#define GETMARK3 dyn->insts[ninst].mark3
+#define MARKF   dyn->insts[ninst].markf = dyn->arm_size
+#define GETMARKF dyn->insts[ninst].markf
+#define MARKSEG dyn->insts[ninst].markseg = dyn->arm_size
+#define GETMARKSEG dyn->insts[ninst].markseg
+#define MARKLOCK dyn->insts[ninst].marklock = dyn->arm_size
+#define GETMARKLOCK dyn->insts[ninst].marklock
 
 // Branch to MARK if cond (use j64)
 #define B_MARK(cond)                \
@@ -430,11 +430,11 @@
     j64 = GETMARKLOCK-(dyn->arm_size);  \
     CBNZx(reg, j64)
 
-#define IFX(A)  if(dyn->insts && (dyn->insts[ninst].x64.need_flags&(A)))
-#define IFX_PENDOR0  if(dyn->insts && (dyn->insts[ninst].x64.need_flags&(X_PEND) || !dyn->insts[ninst].x64.need_flags))
-#define IFXX(A) if(dyn->insts && (dyn->insts[ninst].x64.need_flags==(A)))
-#define IFX2X(A, B) if(dyn->insts && (dyn->insts[ninst].x64.need_flags==(A) || dyn->insts[ninst].x64.need_flags==(B) || dyn->insts[ninst].x64.need_flags==((A)|(B))))
-#define IFXN(A, B)  if(dyn->insts && (dyn->insts[ninst].x64.need_flags&(A) && !(dyn->insts[ninst].x64.need_flags&(B))))
+#define IFX(A)  if((dyn->insts[ninst].x64.need_flags&(A)))
+#define IFX_PENDOR0  if((dyn->insts[ninst].x64.need_flags&(X_PEND) || !dyn->insts[ninst].x64.need_flags))
+#define IFXX(A) if((dyn->insts[ninst].x64.need_flags==(A)))
+#define IFX2X(A, B) if((dyn->insts[ninst].x64.need_flags==(A) || dyn->insts[ninst].x64.need_flags==(B) || dyn->insts[ninst].x64.need_flags==((A)|(B))))
+#define IFXN(A, B)  if((dyn->insts[ninst].x64.need_flags&(A) && !(dyn->insts[ninst].x64.need_flags&(B))))
 
 // Generate FCOM with s1 and s2 scratch regs (the VCMP is already done)
 #define FCOM(s1, s2, s3)                                                    \
@@ -589,12 +589,12 @@
 #ifndef BARRIER_NEXT
 #define BARRIER_NEXT(A)
 #endif
-#define UFLAG_OP1(A) if(dyn->insts && dyn->insts[ninst].x64.need_flags) {STRxw_U12(A, xEmu, offsetof(x64emu_t, op1));}
-#define UFLAG_OP2(A) if(dyn->insts && dyn->insts[ninst].x64.need_flags) {STRxw_U12(A, xEmu, offsetof(x64emu_t, op2));}
-#define UFLAG_OP12(A1, A2) if(dyn->insts && dyn->insts[ninst].x64.need_flags) {STRxw_U12(A1, xEmu, offsetof(x64emu_t, op1));STRxw_U12(A2, 0, offsetof(x64emu_t, op2));}
-#define UFLAG_RES(A) if(dyn->insts && dyn->insts[ninst].x64.need_flags) {STRxw_U12(A, xEmu, offsetof(x64emu_t, res));}
-#define UFLAG_DF(r, A) if(dyn->insts && dyn->insts[ninst].x64.need_flags) {SET_DF(r, A)}
-#define UFLAG_IF if(dyn->insts && dyn->insts[ninst].x64.need_flags)
+#define UFLAG_OP1(A) if(dyn->insts[ninst].x64.need_flags) {STRxw_U12(A, xEmu, offsetof(x64emu_t, op1));}
+#define UFLAG_OP2(A) if(dyn->insts[ninst].x64.need_flags) {STRxw_U12(A, xEmu, offsetof(x64emu_t, op2));}
+#define UFLAG_OP12(A1, A2) if(dyn->insts[ninst].x64.need_flags) {STRxw_U12(A1, xEmu, offsetof(x64emu_t, op1));STRxw_U12(A2, 0, offsetof(x64emu_t, op2));}
+#define UFLAG_RES(A) if(dyn->insts[ninst].x64.need_flags) {STRxw_U12(A, xEmu, offsetof(x64emu_t, res));}
+#define UFLAG_DF(r, A) if(dyn->insts[ninst].x64.need_flags) {SET_DF(r, A)}
+#define UFLAG_IF if(dyn->insts[ninst].x64.need_flags)
 #ifndef DEFAULT
 #define DEFAULT      *ok = -1; BARRIER(2)
 #endif
diff --git a/src/dynarec/dynarec_arm64_pass.c b/src/dynarec/dynarec_arm64_pass.c
index bbc028fa..f8b98ce8 100755
--- a/src/dynarec/dynarec_arm64_pass.c
+++ b/src/dynarec/dynarec_arm64_pass.c
@@ -3,6 +3,7 @@
 #include <stddef.h>
 #include <pthread.h>
 #include <errno.h>
+#include <string.h>
 
 #include "debug.h"
 #include "box64context.h"
@@ -45,7 +46,7 @@ uintptr_t arm_pass(dynarec_arm_t* dyn, uintptr_t addr)
     INIT;
     while(ok) {
         ip = addr;
-        if(dyn->insts && (dyn->insts[ninst].x64.barrier==1)) {
+        if((dyn->insts[ninst].x64.barrier==1)) {
             dyn->last_ip = 0;
             NEW_BARRIER_INST;
         }
@@ -90,7 +91,7 @@ uintptr_t arm_pass(dynarec_arm_t* dyn, uintptr_t addr)
 
         INST_EPILOG;
 
-        if(dyn->insts && dyn->insts[ninst+1].x64.barrier) {
+        if(dyn->insts[ninst+1].x64.barrier) {
             fpu_purgecache(dyn, ninst, x1, x2, x3);
             if(dyn->insts[ninst+1].x64.barrier!=2) {
                 dyn->state_flags = 0;
diff --git a/src/dynarec/dynarec_arm64_pass0.h b/src/dynarec/dynarec_arm64_pass0.h
index 9e086209..cee80a14 100755
--- a/src/dynarec/dynarec_arm64_pass0.h
+++ b/src/dynarec/dynarec_arm64_pass0.h
@@ -5,8 +5,16 @@
 #define SETFLAGS(A, B)  
 #define READFLAGS(A)    
 #define EMIT(A)     
-#define JUMP(A)         add_next(dyn, (uintptr_t)A)
-#define NEW_INST        ++dyn->size
+#define JUMP(A)         add_next(dyn, (uintptr_t)A); dyn->insts[ninst].x64.jmp = A
+#define BARRIER(A)      dyn->insts[ninst].x64.barrier = A
+#define BARRIER_NEXT(A) if(ninst<dyn->size) dyn->insts[ninst+1].x64.barrier = A
+#define NEW_INST \
+        ++dyn->size;                            \
+        if(dyn->size+3>=dyn->cap) {             \
+                dyn->insts = (instruction_arm64_t*)realloc(dyn->insts, sizeof(instruction_arm64_t)*dyn->cap*2);     \
+                memset(&dyn->insts[dyn->cap], 0, sizeof(instruction_arm64_t)*dyn->cap);   \
+                dyn->cap *= 2;                  \
+        }
 #define INST_EPILOG         
 #define INST_NAME(name) 
 #define DEFAULT                         \
diff --git a/src/dynarec/dynarec_arm64_pass1.h b/src/dynarec/dynarec_arm64_pass1.h
index b9800b68..20534879 100755
--- a/src/dynarec/dynarec_arm64_pass1.h
+++ b/src/dynarec/dynarec_arm64_pass1.h
@@ -6,12 +6,9 @@
 #define EMIT(A)     
 #define READFLAGS(A)    dyn->insts[ninst].x64.use_flags = A
 #define SETFLAGS(A,B)   {dyn->insts[ninst].x64.set_flags = A; dyn->insts[ninst].x64.state_flags = B;}
-#define JUMP(A)         dyn->insts[ninst].x64.jmp = A
-#define BARRIER(A)      dyn->insts[ninst].x64.barrier = A
-#define BARRIER_NEXT(A) if(ninst<dyn->size) dyn->insts[ninst+1].x64.barrier = A
 
 #define NEW_INST \
     dyn->insts[ninst].x64.addr = ip; \
     if(ninst) dyn->insts[ninst-1].x64.size = dyn->insts[ninst].x64.addr - dyn->insts[ninst-1].x64.addr;
-#define INST_EPILOG 
+#define INST_EPILOG
 #define INST_NAME(name)  
diff --git a/src/dynarec/dynarec_arm64_private.h b/src/dynarec/dynarec_arm64_private.h
index b57a6841..e048a312 100755
--- a/src/dynarec/dynarec_arm64_private.h
+++ b/src/dynarec/dynarec_arm64_private.h
@@ -5,7 +5,7 @@
 
 typedef struct x64emu_s x64emu_t;
 
-typedef struct instruction_arm_s {
+typedef struct instruction_arm64_s {
     instruction_x64_t   x64;
     uintptr_t           address;    // (start) address of the arm emited instruction
     uintptr_t           epilog;     // epilog of current instruction (can be start of next, of barrier stuff)