[LONGAARCH] Renamed arch to LA64, as LA464 is code name for 3a5000, so that way it's more generic (and sorry about that late minute change)

28 files changed, 195 insertions, 195 deletions

diff --git a/src/dynarec/dynarec_arch.h b/src/dynarec/dynarec_arch.h
index e09bbdd2..9ee01282 100644
--- a/src/dynarec/dynarec_arch.h
+++ b/src/dynarec/dynarec_arch.h
@@ -17,18 +17,18 @@
 #include "arm64/dynarec_arm64_functions.h"

 // Limit here is defined by LD litteral, that is 19bits

 #define MAXBLOCK_SIZE ((1<<19)-200)

-#elif defined(LA464)

+#elif defined(LA64)

 

-#define instruction_native_t        instruction_la464_t

-#define dynarec_native_t            dynarec_la464_t

+#define instruction_native_t        instruction_la64_t

+#define dynarec_native_t            dynarec_la64_t

 

 #define ADDITIONNAL_DEFINITION()

 

 #define OTHER_CACHE()

 

-#include "la464/la464_printer.h"

-#include "la464/dynarec_la464_private.h"

-#include "la464/dynarec_la464_functions.h"

+#include "la64/la64_printer.h"

+#include "la64/dynarec_la64_private.h"

+#include "la64/dynarec_la64_functions.h"

 // TODO

 #define MAXBLOCK_SIZE ((1<<19)-200)

 #elif defined(RV64)

diff --git a/src/dynarec/dynarec_helper.h b/src/dynarec/dynarec_helper.h
index 2f4b82fa..c20c9d74 100644
--- a/src/dynarec/dynarec_helper.h
+++ b/src/dynarec/dynarec_helper.h
@@ -3,8 +3,8 @@
 

 #ifdef ARM64

 #include "arm64/dynarec_arm64_helper.h"

-#elif defined(LA464)

-#include "la464/dynarec_la464_helper.h"

+#elif defined(LA64)

+#include "la64/dynarec_la64_helper.h"

 #elif defined(RV64)

 #include "rv64/dynarec_rv64_helper.h"

 #else

diff --git a/src/dynarec/dynarec_next.h b/src/dynarec/dynarec_next.h
index dc37aadb..9c3411d1 100644
--- a/src/dynarec/dynarec_next.h
+++ b/src/dynarec/dynarec_next.h
@@ -8,13 +8,13 @@ void arm64_epilog(void) EXPORTDYN;
 #define native_next         arm64_next
 #define native_prolog       arm64_prolog
 #define native_epilog       arm64_epilog
-#elif defined(LA464)
-void la464_next(void) EXPORTDYN;
-void la464_prolog(x64emu_t* emu, void* addr) EXPORTDYN;
-void la464_epilog(void) EXPORTDYN;
-#define native_next         la464_next
-#define native_prolog       la464_prolog
-#define native_epilog       la464_epilog
+#elif defined(LA64)
+void la64_next(void) EXPORTDYN;
+void la64_prolog(x64emu_t* emu, void* addr) EXPORTDYN;
+void la64_epilog(void) EXPORTDYN;
+#define native_next         la64_next
+#define native_prolog       la64_prolog
+#define native_epilog       la64_epilog
 #elif defined(RV64)
 void rv64_next(void) EXPORTDYN;
 void rv64_prolog(x64emu_t* emu, void* addr) EXPORTDYN;
diff --git a/src/dynarec/la464/la464_printer.h b/src/dynarec/la464/la464_printer.h
deleted file mode 100644
index e3ad8b2c..00000000
--- a/src/dynarec/la464/la464_printer.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef _LA464_PRINTER_H_
-#define _LA464_PRINTER_H_
-
-const char* la464_print(uint32_t opcode, uint64_t addr);
-
-#endif //_LA464_PRINTER_H_
diff --git a/src/dynarec/la464/dynarec_la464_00.c b/src/dynarec/la64/dynarec_la64_00.c
index 28178cb9..e464e07c 100644
--- a/src/dynarec/la464/dynarec_la464_00.c
+++ b/src/dynarec/la64/dynarec_la64_00.c
@@ -19,15 +19,15 @@
 #include "dynarec_native.h"
 #include "custommem.h"
 
-#include "la464_printer.h"
-#include "dynarec_la464_private.h"
-#include "dynarec_la464_functions.h"
-#include "dynarec_la464_helper.h"
+#include "la64_printer.h"
+#include "dynarec_la64_private.h"
+#include "dynarec_la64_functions.h"
+#include "dynarec_la64_helper.h"
 
 int isSimpleWrapper(wrapper_t fun);
 int isRetX87Wrapper(wrapper_t fun);
 
-uintptr_t dynarec64_00(dynarec_la464_t* dyn, uintptr_t addr, uintptr_t ip, int ninst, rex_t rex, int rep, int* ok, int* need_epilog)
+uintptr_t dynarec64_00(dynarec_la64_t* dyn, uintptr_t addr, uintptr_t ip, int ninst, rex_t rex, int rep, int* ok, int* need_epilog)
 {
     uint8_t nextop, opcode;
     uint8_t gd, ed;
@@ -62,7 +62,7 @@ uintptr_t dynarec64_00(dynarec_la464_t* dyn, uintptr_t addr, uintptr_t ip, int n
         case 0x56:
         case 0x57:
             INST_NAME("PUSH reg");
-            gd = TO_LA464((opcode & 0x07) + (rex.b << 3));
+            gd = TO_LA64((opcode & 0x07) + (rex.b << 3));
             PUSH1z(gd);
             break;
         case 0x58:
@@ -74,7 +74,7 @@ uintptr_t dynarec64_00(dynarec_la464_t* dyn, uintptr_t addr, uintptr_t ip, int n
         case 0x5E:
         case 0x5F:
             INST_NAME("POP reg");
-            gd = TO_LA464((opcode & 0x07) + (rex.b << 3));
+            gd = TO_LA64((opcode & 0x07) + (rex.b << 3));
             POP1z(gd);
             break;
         case 0x89:
@@ -82,7 +82,7 @@ uintptr_t dynarec64_00(dynarec_la464_t* dyn, uintptr_t addr, uintptr_t ip, int n
             nextop = F8;
             GETGD;
             if (MODREG) { // reg <= reg
-                MVxw(TO_LA464((nextop & 7) + (rex.b << 3)), gd);
+                MVxw(TO_LA64((nextop & 7) + (rex.b << 3)), gd);
             } else { // mem <= reg
                 addr = geted(dyn, addr, ninst, nextop, &ed, x2, x1, &fixedaddress, rex, &lock, 1, 0);
                 if (rex.w) {
diff --git a/src/dynarec/la464/dynarec_la464_functions.c b/src/dynarec/la64/dynarec_la64_functions.c
index 2467948f..c73f91e4 100644
--- a/src/dynarec/la464/dynarec_la464_functions.c
+++ b/src/dynarec/la64/dynarec_la64_functions.c
@@ -20,14 +20,14 @@
 #include "emu/x87emu_private.h"
 #include "x64trace.h"
 #include "signals.h"
-#include "dynarec_la464.h"
-#include "dynarec_la464_private.h"
-#include "dynarec_la464_functions.h"
+#include "dynarec_la64.h"
+#include "dynarec_la64_private.h"
+#include "dynarec_la64_functions.h"
 #include "custommem.h"
 #include "bridge.h"
 
 // Reset scratch regs counter
-void fpu_reset_scratch(dynarec_la464_t* dyn)
+void fpu_reset_scratch(dynarec_la64_t* dyn)
 {
     // TODO
 }
@@ -108,51 +108,51 @@ uint32_t insert_half(uint32_t val, uint16_t h, void* address){
     return val;
 }
 
-uint8_t la464_lock_xchg_b(void* addr, uint8_t val)
+uint8_t la64_lock_xchg_b(void* addr, uint8_t val)
 {
     uint32_t ret;
     uint32_t* aligned = (uint32_t*)(((uintptr_t)addr)&~3);
     do {
         ret = *aligned;
-    } while(la464_lock_cas_d(aligned, ret, insert_byte(ret, val, addr)));
+    } while(la64_lock_cas_d(aligned, ret, insert_byte(ret, val, addr)));
     return extract_byte(ret, addr);
 }
 
-uint16_t la464_lock_xchg_h(void* addr, uint16_t val)
+uint16_t la64_lock_xchg_h(void* addr, uint16_t val)
 {
     uint32_t ret;
     uint32_t* aligned = (uint32_t*)(((uintptr_t)addr)&~3);
     do {
         ret = *aligned;
-    } while(la464_lock_cas_d(aligned, ret, insert_half(ret, val, addr)));
+    } while(la64_lock_cas_d(aligned, ret, insert_half(ret, val, addr)));
     return extract_half(ret, addr);
 }
 
-int la464_lock_cas_b(void* addr, uint8_t ref, uint8_t val)
+int la64_lock_cas_b(void* addr, uint8_t ref, uint8_t val)
 {
     uint32_t* aligned = (uint32_t*)(((uintptr_t)addr)&~3);
     uint32_t tmp = *aligned;
-    return la464_lock_cas_d(aligned, ref, insert_byte(tmp, val, addr));
+    return la64_lock_cas_d(aligned, ref, insert_byte(tmp, val, addr));
 }
 
-int la464_lock_cas_h(void* addr, uint16_t ref, uint16_t val)
+int la64_lock_cas_h(void* addr, uint16_t ref, uint16_t val)
 {
     uint32_t* aligned = (uint32_t*)(((uintptr_t)addr)&~3);
     uint32_t tmp = *aligned;
-    return la464_lock_cas_d(aligned, ref, insert_half(tmp, val, addr));
+    return la64_lock_cas_d(aligned, ref, insert_half(tmp, val, addr));
 }
 
 void print_opcode(dynarec_native_t* dyn, int ninst, uint32_t opcode)
 {
-    dynarec_log(LOG_NONE, "\t%08x\t%s\n", opcode, la464_print(opcode, (uintptr_t)dyn->block));
+    dynarec_log(LOG_NONE, "\t%08x\t%s\n", opcode, la64_print(opcode, (uintptr_t)dyn->block));
 }
 
-void fpu_reset(dynarec_la464_t* dyn)
+void fpu_reset(dynarec_la64_t* dyn)
 {
     // TODO
 }
 
-void fpu_reset_ninst(dynarec_la464_t* dyn, int ninst)
+void fpu_reset_ninst(dynarec_la64_t* dyn, int ninst)
 {
     // TODO
 }
\ No newline at end of file
diff --git a/src/dynarec/la464/dynarec_la464_functions.h b/src/dynarec/la64/dynarec_la64_functions.h
index 6e504f9b..5f7b5036 100644
--- a/src/dynarec/la464/dynarec_la464_functions.h
+++ b/src/dynarec/la64/dynarec_la64_functions.h
@@ -1,5 +1,5 @@
-#ifndef __DYNAREC_LA464_FUNCTIONS_H__
-#define __DYNAREC_LA464_FUNCTIONS_H__
+#ifndef __DYNAREC_LA64_FUNCTIONS_H__
+#define __DYNAREC_LA64_FUNCTIONS_H__
 
 #include "../dynarec_native_functions.h"
 
@@ -7,7 +7,7 @@ typedef struct x64emu_s x64emu_t;
 typedef struct dynarec_rv64_s dynarec_rv64_t;
 
 // Reset scratch regs counter
-void fpu_reset_scratch(dynarec_la464_t* dyn);
+void fpu_reset_scratch(dynarec_la64_t* dyn);
 
 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);
@@ -16,4 +16,4 @@ void print_opcode(dynarec_native_t* dyn, int ninst, uint32_t opcode);
 void fpu_reset(dynarec_native_t* dyn);
 void fpu_reset_ninst(dynarec_native_t* dyn, int ninst);
 
-#endif //__DYNAREC_LA464_FUNCTIONS_H__
+#endif //__DYNAREC_LA64_FUNCTIONS_H__
diff --git a/src/dynarec/la464/dynarec_la464_helper.c b/src/dynarec/la64/dynarec_la64_helper.c
index 43ba7499..71e3c1ed 100644
--- a/src/dynarec/la464/dynarec_la464_helper.c
+++ b/src/dynarec/la64/dynarec_la64_helper.c
@@ -20,15 +20,15 @@
 #include "../dynablock_private.h"
 #include "custommem.h"
 
-#include "la464_printer.h"
-#include "dynarec_la464_private.h"
-#include "dynarec_la464_functions.h"
-#include "dynarec_la464_helper.h"
+#include "la64_printer.h"
+#include "dynarec_la64_private.h"
+#include "dynarec_la64_functions.h"
+#include "dynarec_la64_helper.h"
 
-static uintptr_t geted_32(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, int* l, int i12);
+static uintptr_t geted_32(dynarec_la64_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, int* l, int i12);
 
 /* setup r2 to address pointed by ED, also fixaddress is an optionnal delta in the range [-absmax, +absmax], with delta&mask==0 to be added to ed for LDR/STR */
-uintptr_t geted(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, rex_t rex, int* l, int i12, int delta)
+uintptr_t geted(dynarec_la64_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, rex_t rex, int* l, int i12, int delta)
 {
     MAYUSE(dyn);
     MAYUSE(ninst);
@@ -57,12 +57,12 @@ uintptr_t geted(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop,
                 if (sib_reg != 4) {
                     if (tmp && ((tmp < -2048) || (tmp > maxval) || !i12)) {
                         MOV64x(scratch, tmp);
-                        ADDSL(ret, scratch, TO_LA464(sib_reg), sib >> 6, ret);
+                        ADDSL(ret, scratch, TO_LA64(sib_reg), sib >> 6, ret);
                     } else {
                         if (sib >> 6) {
-                            SLLI_D(ret, TO_LA464(sib_reg), (sib >> 6));
+                            SLLI_D(ret, TO_LA64(sib_reg), (sib >> 6));
                         } else {
-                            ret = TO_LA464(sib_reg);
+                            ret = TO_LA64(sib_reg);
                         }
                         *fixaddress = tmp;
                     }
@@ -77,9 +77,9 @@ uintptr_t geted(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop,
                 }
             } else {
                 if (sib_reg != 4) {
-                    ADDSL(ret, TO_LA464(sib_reg2), TO_LA464(sib_reg), sib >> 6, scratch);
+                    ADDSL(ret, TO_LA64(sib_reg2), TO_LA64(sib_reg), sib >> 6, scratch);
                 } else {
-                    ret = TO_LA464(sib_reg2);
+                    ret = TO_LA64(sib_reg2);
                 }
             }
         } else if ((nextop & 7) == 5) {
@@ -115,7 +115,7 @@ uintptr_t geted(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop,
                     break;
             }
         } else {
-            ret = TO_LA464((nextop & 7) + (rex.b << 3));
+            ret = TO_LA64((nextop & 7) + (rex.b << 3));
         }
     } else {
         int64_t i64;
@@ -134,37 +134,37 @@ uintptr_t geted(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop,
             *fixaddress = i64;
             if ((nextop & 7) == 4) {
                 if (sib_reg != 4) {
-                    ADDSL(ret, TO_LA464(sib_reg2), TO_LA464(sib_reg), sib >> 6, scratch);
+                    ADDSL(ret, TO_LA64(sib_reg2), TO_LA64(sib_reg), sib >> 6, scratch);
                 } else {
-                    ret = TO_LA464(sib_reg2);
+                    ret = TO_LA64(sib_reg2);
                 }
             } else {
-                ret = TO_LA464((nextop & 0x07) + (rex.b << 3));
+                ret = TO_LA64((nextop & 0x07) + (rex.b << 3));
             }
         } else {
             if (i64 >= -2048 && i64 <= 2047) {
                 if ((nextop & 7) == 4) {
                     if (sib_reg != 4) {
-                        ADDSL(scratch, TO_LA464(sib_reg2), TO_LA464(sib_reg), sib >> 6, scratch);
+                        ADDSL(scratch, TO_LA64(sib_reg2), TO_LA64(sib_reg), sib >> 6, scratch);
                     } else {
-                        scratch = TO_LA464(sib_reg2);
+                        scratch = TO_LA64(sib_reg2);
                     }
                 } else {
-                    scratch = TO_LA464((nextop & 0x07) + (rex.b << 3));
+                    scratch = TO_LA64((nextop & 0x07) + (rex.b << 3));
                 }
                 ADDI_D(ret, scratch, i64);
             } else {
                 MOV64x(scratch, i64);
                 if ((nextop & 7) == 4) {
                     if (sib_reg != 4) {
-                        ADD_D(scratch, scratch, TO_LA464(sib_reg2));
-                        ADDSL(ret, scratch, TO_LA464(sib_reg), sib >> 6, ret);
+                        ADD_D(scratch, scratch, TO_LA64(sib_reg2));
+                        ADDSL(ret, scratch, TO_LA64(sib_reg), sib >> 6, ret);
                     } else {
-                        PASS3(int tmp = TO_LA464(sib_reg2));
+                        PASS3(int tmp = TO_LA64(sib_reg2));
                         ADD_D(ret, tmp, scratch);
                     }
                 } else {
-                    PASS3(int tmp = TO_LA464((nextop & 0x07) + (rex.b << 3)));
+                    PASS3(int tmp = TO_LA64((nextop & 0x07) + (rex.b << 3)));
                     ADD_D(ret, tmp, scratch);
                 }
             }
@@ -174,7 +174,7 @@ uintptr_t geted(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop,
     return addr;
 }
 
-static uintptr_t geted_32(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, int* l, int i12)
+static uintptr_t geted_32(dynarec_la64_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, int* l, int i12)
 {
     MAYUSE(dyn);
     MAYUSE(ninst);
@@ -200,16 +200,16 @@ static uintptr_t geted_32(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8
                     if (tmp && ((tmp < -2048) || (tmp > maxval) || !i12)) {
                         MOV32w(scratch, tmp);
                         if ((sib >> 6)) {
-                            SLLI_D(ret, TO_LA464(sib_reg), sib >> 6);
+                            SLLI_D(ret, TO_LA64(sib_reg), sib >> 6);
                             ADD_W(ret, ret, scratch);
                         } else {
-                            ADD_W(ret, TO_LA464(sib_reg), scratch);
+                            ADD_W(ret, TO_LA64(sib_reg), scratch);
                         }
                     } else {
                         if (sib >> 6) {
-                            SLLI_D(ret, TO_LA464(sib_reg), (sib >> 6));
+                            SLLI_D(ret, TO_LA64(sib_reg), (sib >> 6));
                         } else {
-                            ret = TO_LA464(sib_reg);
+                            ret = TO_LA64(sib_reg);
                         }
                         *fixaddress = tmp;
                     }
@@ -225,13 +225,13 @@ static uintptr_t geted_32(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8
             } else {
                 if (sib_reg != 4) {
                     if ((sib >> 6)) {
-                        SLLI_D(ret, TO_LA464(sib_reg), (sib >> 6));
-                        ADD_W(ret, ret, TO_LA464(sib_reg2));
+                        SLLI_D(ret, TO_LA64(sib_reg), (sib >> 6));
+                        ADD_W(ret, ret, TO_LA64(sib_reg2));
                     } else {
-                        ADD_W(ret, TO_LA464(sib_reg2), TO_LA464(sib_reg));
+                        ADD_W(ret, TO_LA64(sib_reg2), TO_LA64(sib_reg));
                     }
                 } else {
-                    ret = TO_LA464(sib_reg2);
+                    ret = TO_LA64(sib_reg2);
                 }
             }
         } else if ((nextop & 7) == 5) {
@@ -244,7 +244,7 @@ static uintptr_t geted_32(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8
                     break;
             }
         } else {
-            ret = TO_LA464((nextop & 7));
+            ret = TO_LA64((nextop & 7));
             if (ret == hint) {
                 MOV32w(x2, 0xffffffff);
                 AND(hint, ret, x2); // to clear upper part
@@ -268,51 +268,51 @@ static uintptr_t geted_32(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8
             if ((nextop & 7) == 4) {
                 if (sib_reg != 4) {
                     if (sib >> 6) {
-                        SLLI_D(ret, TO_LA464(sib_reg), (sib >> 6));
-                        ADD_W(ret, ret, TO_LA464(sib_reg2));
+                        SLLI_D(ret, TO_LA64(sib_reg), (sib >> 6));
+                        ADD_W(ret, ret, TO_LA64(sib_reg2));
                     } else {
-                        ADD_W(ret, TO_LA464(sib_reg2), TO_LA464(sib_reg));
+                        ADD_W(ret, TO_LA64(sib_reg2), TO_LA64(sib_reg));
                     }
                 } else {
-                    ret = TO_LA464(sib_reg2);
+                    ret = TO_LA64(sib_reg2);
                 }
             } else {
-                ret = TO_LA464((nextop & 0x07));
+                ret = TO_LA64((nextop & 0x07));
             }
         } else {
             if (i32 >= -2048 && i32 <= 2047) {
                 if ((nextop & 7) == 4) {
                     if (sib_reg != 4) {
                         if (sib >> 6) {
-                            SLLI_D(scratch, TO_LA464(sib_reg), sib >> 6);
-                            ADD_W(scratch, scratch, TO_LA464(sib_reg2));
+                            SLLI_D(scratch, TO_LA64(sib_reg), sib >> 6);
+                            ADD_W(scratch, scratch, TO_LA64(sib_reg2));
                         } else {
-                            ADD_W(scratch, TO_LA464(sib_reg2), TO_LA464(sib_reg));
+                            ADD_W(scratch, TO_LA64(sib_reg2), TO_LA64(sib_reg));
                         }
                     } else {
-                        scratch = TO_LA464(sib_reg2);
+                        scratch = TO_LA64(sib_reg2);
                     }
                 } else {
-                    scratch = TO_LA464((nextop & 0x07));
+                    scratch = TO_LA64((nextop & 0x07));
                 }
                 ADDI_W(ret, scratch, i32);
             } else {
                 MOV32w(scratch, i32);
                 if ((nextop & 7) == 4) {
                     if (sib_reg != 4) {
-                        ADD_W(scratch, scratch, TO_LA464(sib_reg2));
+                        ADD_W(scratch, scratch, TO_LA64(sib_reg2));
                         if (sib >> 6) {
-                            SLLI_D(ret, TO_LA464(sib_reg), (sib >> 6));
+                            SLLI_D(ret, TO_LA64(sib_reg), (sib >> 6));
                             ADD_W(ret, ret, scratch);
                         } else {
-                            ADD_W(ret, scratch, TO_LA464(sib_reg));
+                            ADD_W(ret, scratch, TO_LA64(sib_reg));
                         }
                     } else {
-                        PASS3(int tmp = TO_LA464(sib_reg2));
+                        PASS3(int tmp = TO_LA64(sib_reg2));
                         ADD_W(ret, tmp, scratch);
                     }
                 } else {
-                    PASS3(int tmp = TO_LA464((nextop & 0x07)));
+                    PASS3(int tmp = TO_LA64((nextop & 0x07)));
                     ADD_W(ret, tmp, scratch);
                 }
             }
@@ -322,7 +322,7 @@ static uintptr_t geted_32(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8
     return addr;
 }
 
-void jump_to_epilog(dynarec_la464_t* dyn, uintptr_t ip, int reg, int ninst)
+void jump_to_epilog(dynarec_la64_t* dyn, uintptr_t ip, int reg, int ninst)
 {
     MAYUSE(dyn);
     MAYUSE(ip);
@@ -336,12 +336,12 @@ void jump_to_epilog(dynarec_la464_t* dyn, uintptr_t ip, int reg, int ninst)
     } else {
         GETIP_(ip);
     }
-    TABLE64(x2, (uintptr_t)la464_epilog);
+    TABLE64(x2, (uintptr_t)la64_epilog);
     SMEND();
     BR(x2);
 }
 
-void jump_to_next(dynarec_la464_t* dyn, uintptr_t ip, int reg, int ninst, int is32bits)
+void jump_to_next(dynarec_la64_t* dyn, uintptr_t ip, int reg, int ninst, int is32bits)
 {
     MAYUSE(dyn);
     MAYUSE(ninst);
@@ -399,33 +399,33 @@ void jump_to_next(dynarec_la464_t* dyn, uintptr_t ip, int reg, int ninst, int is
     JIRL(xRA, x2, 0x0); // save LR...
 }
 
-void call_c(dynarec_la464_t* dyn, int ninst, void* fnc, int reg, int ret, int saveflags, int savereg)
+void call_c(dynarec_la64_t* dyn, int ninst, void* fnc, int reg, int ret, int saveflags, int savereg)
 {
     // TODO
 }
 
-void fpu_purgecache(dynarec_la464_t* dyn, int ninst, int next, int s1, int s2, int s3)
+void fpu_purgecache(dynarec_la64_t* dyn, int ninst, int next, int s1, int s2, int s3)
 {
     // TODO
 }
 
-void fpu_reflectcache(dynarec_la464_t* dyn, int ninst, int s1, int s2, int s3)
+void fpu_reflectcache(dynarec_la64_t* dyn, int ninst, int s1, int s2, int s3)
 {
     // TODO
 }
 
-void fpu_unreflectcache(dynarec_la464_t* dyn, int ninst, int s1, int s2, int s3)
+void fpu_unreflectcache(dynarec_la64_t* dyn, int ninst, int s1, int s2, int s3)
 {
     // TODO
 }
 
-void fpu_reset_cache(dynarec_la464_t* dyn, int ninst, int reset_n)
+void fpu_reset_cache(dynarec_la64_t* dyn, int ninst, int reset_n)
 {
     // TODO
 }
 
 // propagate ST stack state, especial stack pop that are deferred
-void fpu_propagate_stack(dynarec_la464_t* dyn, int ninst)
+void fpu_propagate_stack(dynarec_la64_t* dyn, int ninst)
 {
     // TODO
 }
diff --git a/src/dynarec/la464/dynarec_la464_helper.h b/src/dynarec/la64/dynarec_la64_helper.h
index 4563a2ab..deec5656 100644
--- a/src/dynarec/la464/dynarec_la464_helper.h
+++ b/src/dynarec/la64/dynarec_la64_helper.h
@@ -1,21 +1,21 @@
-#ifndef __DYNAREC_LA464_HELPER_H__
-#define __DYNAREC_LA464_HELPER_H__
+#ifndef __DYNAREC_LA64_HELPER_H__
+#define __DYNAREC_LA64_HELPER_H__
 
 // undef to get Close to SSE Float->int conversions
 // #define PRECISE_CVT
 
 #if STEP == 0
-#include "dynarec_la464_pass0.h"
+#include "dynarec_la64_pass0.h"
 #elif STEP == 1
-#include "dynarec_la464_pass1.h"
+#include "dynarec_la64_pass1.h"
 #elif STEP == 2
-#include "dynarec_la464_pass2.h"
+#include "dynarec_la64_pass2.h"
 #elif STEP == 3
-#include "dynarec_la464_pass3.h"
+#include "dynarec_la64_pass3.h"
 #endif
 
 #include "debug.h"
-#include "la464_emitter.h"
+#include "la64_emitter.h"
 #include "../emu/x64primop.h"
 
 #define F8      *(uint8_t*)(addr++)
@@ -84,7 +84,7 @@
 // GETGD    get x64 register in gd
 #define GETGD                                                        \
     do {                                                             \
-        gd = TO_LA464(((nextop & 0x38) >> 3) + (rex.r << 3)); \
+        gd = TO_LA64(((nextop & 0x38) >> 3) + (rex.r << 3)); \
     } while (0);
 
 // CALL will use x7 for the call address. Return value can be put in ret (unless ret is -1)
@@ -172,8 +172,8 @@
 
 #define MODREG ((nextop & 0xC0) == 0xC0)
 
-void la464_epilog(void);
-void* la464_next(x64emu_t* emu, uintptr_t addr);
+void la64_epilog(void);
+void* la64_next(x64emu_t* emu, uintptr_t addr);
 
 #ifndef STEPNAME
 #define STEPNAME3(N, M) N##M
@@ -198,26 +198,26 @@ void* la464_next(x64emu_t* emu, uintptr_t addr);
 #define fpu_unreflectcache  STEPNAME(fpu_unreflectcache)
 
 /* setup r2 to address pointed by */
-uintptr_t geted(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, rex_t rex, int* l, int i12, int delta);
+uintptr_t geted(dynarec_la64_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, rex_t rex, int* l, int i12, int delta);
 
 /* setup r2 to address pointed by */
-uintptr_t geted32(dynarec_la464_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, rex_t rex, int* l, int i12, int delta);
+uintptr_t geted32(dynarec_la64_t* dyn, uintptr_t addr, int ninst, uint8_t nextop, uint8_t* ed, uint8_t hint, uint8_t scratch, int64_t* fixaddress, rex_t rex, int* l, int i12, int delta);
 
 // generic x64 helper
-void jump_to_epilog(dynarec_la464_t* dyn, uintptr_t ip, int reg, int ninst);
-void jump_to_next(dynarec_la464_t* dyn, uintptr_t ip, int reg, int ninst, int is32bits);
-void call_c(dynarec_la464_t* dyn, int ninst, void* fnc, int reg, int ret, int saveflags, int save_reg);
+void jump_to_epilog(dynarec_la64_t* dyn, uintptr_t ip, int reg, int ninst);
+void jump_to_next(dynarec_la64_t* dyn, uintptr_t ip, int reg, int ninst, int is32bits);
+void call_c(dynarec_la64_t* dyn, int ninst, void* fnc, int reg, int ret, int saveflags, int save_reg);
 
 // reset the cache with n
-void fpu_reset_cache(dynarec_la464_t* dyn, int ninst, int reset_n);
+void fpu_reset_cache(dynarec_la64_t* dyn, int ninst, int reset_n);
 // propagate stack state
-void fpu_propagate_stack(dynarec_la464_t* dyn, int ninst);
+void fpu_propagate_stack(dynarec_la64_t* dyn, int ninst);
 // purge the FPU cache (needs 3 scratch registers)
-void fpu_purgecache(dynarec_la464_t* dyn, int ninst, int next, int s1, int s2, int s3);
-void fpu_reflectcache(dynarec_la464_t* dyn, int ninst, int s1, int s2, int s3);
-void fpu_unreflectcache(dynarec_la464_t* dyn, int ninst, int s1, int s2, int s3);
+void fpu_purgecache(dynarec_la64_t* dyn, int ninst, int next, int s1, int s2, int s3);
+void fpu_reflectcache(dynarec_la64_t* dyn, int ninst, int s1, int s2, int s3);
+void fpu_unreflectcache(dynarec_la64_t* dyn, int ninst, int s1, int s2, int s3);
 
-uintptr_t dynarec64_00(dynarec_la464_t* dyn, uintptr_t addr, uintptr_t ip, int ninst, rex_t rex, int rep, int* ok, int* need_epilog);
+uintptr_t dynarec64_00(dynarec_la64_t* dyn, uintptr_t addr, uintptr_t ip, int ninst, rex_t rex, int rep, int* ok, int* need_epilog);
 
 #if STEP < 3
 #define PASS3(A)
@@ -243,4 +243,4 @@ uintptr_t dynarec64_00(dynarec_la464_t* dyn, uintptr_t addr, uintptr_t ip, int n
         ST_W(s2, xEmu, offsetof(x64emu_t, test.test)); \
     }
 
-#endif //__DYNAREC_LA464_HELPER_H__
\ No newline at end of file
+#endif //__DYNAREC_LA64_HELPER_H__
\ No newline at end of file
diff --git a/src/dynarec/la464/dynarec_la464_jmpnext.c b/src/dynarec/la64/dynarec_la64_jumpnext.c
index 5a798e02..793eb729 100644
--- a/src/dynarec/la464/dynarec_la464_jmpnext.c
+++ b/src/dynarec/la64/dynarec_la64_jumpnext.c
@@ -1,6 +1,6 @@
 #include <stdint.h>
 
-#include "la464_emitter.h"
+#include "la64_emitter.h"
 
 #define EMIT(A) *block = (A); ++block;
 void CreateJmpNext(void* addr, void* next)
diff --git a/src/dynarec/la464/dynarec_la464_pass0.h b/src/dynarec/la64/dynarec_la64_pass0.h
index 3f6a68ce..3f6a68ce 100644
--- a/src/dynarec/la464/dynarec_la464_pass0.h
+++ b/src/dynarec/la64/dynarec_la64_pass0.h
diff --git a/src/dynarec/la464/dynarec_la464_pass1.h b/src/dynarec/la64/dynarec_la64_pass1.h
index 7d616b22..7d616b22 100644
--- a/src/dynarec/la464/dynarec_la464_pass1.h
+++ b/src/dynarec/la64/dynarec_la64_pass1.h
diff --git a/src/dynarec/la464/dynarec_la464_pass2.h b/src/dynarec/la64/dynarec_la64_pass2.h
index df7d7809..df7d7809 100644
--- a/src/dynarec/la464/dynarec_la464_pass2.h
+++ b/src/dynarec/la64/dynarec_la64_pass2.h
diff --git a/src/dynarec/la464/dynarec_la464_pass3.h b/src/dynarec/la64/dynarec_la64_pass3.h
index ecaf8a77..ecaf8a77 100644
--- a/src/dynarec/la464/dynarec_la464_pass3.h
+++ b/src/dynarec/la64/dynarec_la64_pass3.h
diff --git a/src/dynarec/la464/dynarec_la464_private.h b/src/dynarec/la64/dynarec_la64_private.h
index 89b248b0..36127ba9 100644
--- a/src/dynarec/la464/dynarec_la464_private.h
+++ b/src/dynarec/la64/dynarec_la64_private.h
@@ -1,5 +1,5 @@
-#ifndef __DYNAREC_LA464_PRIVATE_H_
-#define __DYNAREC_LA464_PRIVATE_H_
+#ifndef __DYNAREC_LA64_PRIVATE_H_
+#define __DYNAREC_LA64_PRIVATE_H_
 
 #include "../dynarec_private.h"
 
@@ -14,7 +14,7 @@ typedef struct flagcache_s {
     int                 dfnone;     // if deferred flags is already set to df_none
 } flagcache_t;
 
-typedef struct instruction_la464_s {
+typedef struct instruction_la64_s {
     instruction_x64_t   x64;
     uintptr_t           address;    // (start) address of the arm emitted instruction
     uintptr_t           epilog;     // epilog of current instruction (can be start of next, or barrier stuff)
@@ -34,10 +34,10 @@ typedef struct instruction_la464_s {
     uint8_t             last_write;
     flagcache_t         f_exit;     // flags status at end of instruction
     flagcache_t         f_entry;    // flags status before the instruction begin
-} instruction_la464_t;
+} instruction_la64_t;
 
-typedef struct dynarec_la464_s {
-    instruction_la464_t* insts;
+typedef struct dynarec_la64_s {
+    instruction_la64_t* insts;
     int32_t              size;
     int32_t              cap;
     uintptr_t            start;      // start of the block
@@ -70,16 +70,16 @@ typedef struct dynarec_la464_s {
     uint8_t              smwrite;    // for strongmem model emulation
     uint8_t              always_test;
     uint8_t              abort;
-} dynarec_la464_t;
+} dynarec_la64_t;
 
-void add_next(dynarec_la464_t *dyn, uintptr_t addr);
-uintptr_t get_closest_next(dynarec_la464_t *dyn, uintptr_t addr);
-void add_jump(dynarec_la464_t *dyn, int ninst);
-int get_first_jump(dynarec_la464_t *dyn, int next);
-int is_nops(dynarec_la464_t *dyn, uintptr_t addr, int n);
-int is_instructions(dynarec_la464_t *dyn, uintptr_t addr, int n);
+void add_next(dynarec_la64_t *dyn, uintptr_t addr);
+uintptr_t get_closest_next(dynarec_la64_t *dyn, uintptr_t addr);
+void add_jump(dynarec_la64_t *dyn, int ninst);
+int get_first_jump(dynarec_la64_t *dyn, int next);
+int is_nops(dynarec_la64_t *dyn, uintptr_t addr, int n);
+int is_instructions(dynarec_la64_t *dyn, uintptr_t addr, int n);
 
-int Table64(dynarec_la464_t *dyn, uint64_t val, int pass);  // add a value to table64 (if needed) and gives back the imm19 to use in LDR_literal
+int Table64(dynarec_la64_t *dyn, uint64_t val, int pass);  // add a value to table64 (if needed) and gives back the imm19 to use in LDR_literal
 
 void CreateJmpNext(void* addr, void* next);
 
diff --git a/src/dynarec/la464/la464_emitter.h b/src/dynarec/la64/la64_emitter.h
index 43cd81c1..7ba34204 100644
--- a/src/dynarec/la464/la464_emitter.h
+++ b/src/dynarec/la64/la64_emitter.h
@@ -1,10 +1,10 @@
-#ifndef __LA464_EMITTER_H__
-#define __LA464_EMITTER_H__
+#ifndef __LA64_EMITTER_H__
+#define __LA64_EMITTER_H__
 /*
-    LA464 Emitter
+    LA64 Emitter
 */
 
-// LA464 ABI
+// LA64 ABI
 /*
 Name     Alias     Meaning                         saver
 ---------------------------------------------------------
@@ -25,7 +25,7 @@ f8-f23   ft0-ft15  Temp registers                  Caller
 f24-f31  fs0-fs7   Static registers                Callee
 */
 /*
- LA464 GPR mapping
+ LA64 GPR mapping
  There is no 15 registers free, so split the regs in 2 part
  AX..DI : r12-r19
  R8..R15: r23-r30
@@ -51,10 +51,10 @@ f24-f31  fs0-fs7   Static registers                Callee
 #define xR15    30
 #define xFlags  31
 #define xRIP    20
-// function to move from x86 regs number to LA464 reg number
-#define TO_LA464(A) ((A)>7)?((A)+15):((A)+12)
-// function to move from LA464 regs number to x86 reg number
-#define FROM_LA464(A) ((A)>22)?((A)-15):((A)-12)
+// function to move from x86 regs number to LA64 reg number
+#define TO_LA64(A) ((A)>7)?((A)+15):((A)+12)
+// function to move from LA64 regs number to x86 reg number
+#define FROM_LA64(A) ((A)>22)?((A)-15):((A)-12)
 // 32bits version
 #define wEAX    xRAX
 #define wECX    xRCX
@@ -89,10 +89,10 @@ f24-f31  fs0-fs7   Static registers                Callee
 #define w6      x6
 // emu is r0
 #define xEmu    4
-// LA464 RA
+// LA64 RA
 #define xRA     1
 #define ra      xRA
-// LA464 SP
+// LA64 SP
 #define xSP     3
 // xZR regs
 #define xZR     0
diff --git a/src/dynarec/la464/la464_epilog.S b/src/dynarec/la64/la64_epilog.S
index 41eae0cc..41eae0cc 100644
--- a/src/dynarec/la464/la464_epilog.S
+++ b/src/dynarec/la64/la64_epilog.S
diff --git a/src/dynarec/la464/la464_lock.S b/src/dynarec/la64/la64_lock.S
index 9a728b14..9a728b14 100644
--- a/src/dynarec/la464/la464_lock.S
+++ b/src/dynarec/la64/la64_lock.S
diff --git a/src/dynarec/la464/la464_lock.h b/src/dynarec/la64/la64_lock.h
index 8cff10d6..1bf9a004 100644
--- a/src/dynarec/la464/la464_lock.h
+++ b/src/dynarec/la64/la64_lock.h
@@ -1,5 +1,5 @@
-#ifndef __LA464_LOCK__H__
-#define __LA464_LOCK__H__
+#ifndef __LA64_LOCK__H__
+#define __LA64_LOCK__H__
 #include <stdint.h>
 
 // Atomically exchange value at [p] with val, return old p
@@ -70,4 +70,4 @@ uint16_t la464_lock_xchg_h(void* addr, uint16_t v);
 int la464_lock_cas_b(void* p, uint8_t ref, uint8_t val);
 int la464_lock_cas_h(void* p, uint16_t ref, uint16_t val);
 
-#endif  //__LA464_LOCK__H__
+#endif  //__LA64_LOCK__H__
diff --git a/src/dynarec/la464/la464_next.S b/src/dynarec/la64/la64_next.S
index e2c4924d..e2c4924d 100644
--- a/src/dynarec/la464/la464_next.S
+++ b/src/dynarec/la64/la64_next.S
diff --git a/src/dynarec/la464/la464_printer.c b/src/dynarec/la64/la64_printer.c
index 5651ec12..5651ec12 100644
--- a/src/dynarec/la464/la464_printer.c
+++ b/src/dynarec/la64/la64_printer.c
diff --git a/src/dynarec/la64/la64_printer.h b/src/dynarec/la64/la64_printer.h
new file mode 100644
index 00000000..2bc4ded8
--- /dev/null
+++ b/src/dynarec/la64/la64_printer.h
@@ -0,0 +1,6 @@
+#ifndef _LA64_PRINTER_H_
+#define _LA64_PRINTER_H_
+
+const char* la464_print(uint32_t opcode, uint64_t addr);
+
+#endif //_LA64_PRINTER_H_
diff --git a/src/dynarec/la464/la464_prolog.S b/src/dynarec/la64/la64_prolog.S
index aafe4dc7..aafe4dc7 100644
--- a/src/dynarec/la464/la464_prolog.S
+++ b/src/dynarec/la64/la64_prolog.S
diff --git a/src/dynarec/native_lock.h b/src/dynarec/native_lock.h
index 66cb026f..1ab1da3d 100644
--- a/src/dynarec/native_lock.h
+++ b/src/dynarec/native_lock.h
@@ -77,43 +77,43 @@
 #define native_lock_get_d(A)                rv64_lock_get_d(A)

 #define native_lock_get_dd(A)               rv64_lock_get_dd(A)

 

-#elif defined(LA464)

-#include "la464/la464_lock.h"

+#elif defined(LA64)

+#include "la64/la64_lock.h"

 

 #define USE_CAS

 

-// no byte or 2-bytes atomic access on LA464

-#define native_lock_xchg_dd(A, B)           la464_lock_xchg_dd(A, B)

-#define native_lock_xchg_d(A, B)            la464_lock_xchg_d(A, B)

-#define native_lock_xchg_h(A, B)            la464_lock_xchg_h(A, B)

-#define native_lock_xchg_b(A, B)            la464_lock_xchg_b(A, B)

-#define native_lock_storeifref(A, B, C)     la464_lock_storeifref(A, B, C)

-#define native_lock_storeifref_d(A, B, C)   la464_lock_storeifref_d(A, B, C)

-#define native_lock_storeifref2_d(A, B, C)  la464_lock_storeifref2_d(A, B, C)

-#define native_lock_storeifnull(A, B)       la464_lock_storeifnull(A, B)

-#define native_lock_storeifnull_d(A, B)     la464_lock_storeifnull_d(A, B)

-#define native_lock_decifnot0b(A)           la464_lock_decifnot0b(A)

-#define native_lock_storeb(A, B)            la464_lock_storeb(A, B)

-#define native_lock_incif0(A)               la464_lock_incif0(A)

-#define native_lock_decifnot0(A)            la464_lock_decifnot0(A)

-#define native_lock_store(A, B)             la464_lock_store(A, B)

-#define native_lock_store_dd(A, B)          la464_lock_store_dd(A, B)

+// no byte or 2-bytes atomic access on LA64

+#define native_lock_xchg_dd(A, B)           la64_lock_xchg_dd(A, B)

+#define native_lock_xchg_d(A, B)            la64_lock_xchg_d(A, B)

+#define native_lock_xchg_h(A, B)            la64_lock_xchg_h(A, B)

+#define native_lock_xchg_b(A, B)            la64_lock_xchg_b(A, B)

+#define native_lock_storeifref(A, B, C)     la64_lock_storeifref(A, B, C)

+#define native_lock_storeifref_d(A, B, C)   la64_lock_storeifref_d(A, B, C)

+#define native_lock_storeifref2_d(A, B, C)  la64_lock_storeifref2_d(A, B, C)

+#define native_lock_storeifnull(A, B)       la64_lock_storeifnull(A, B)

+#define native_lock_storeifnull_d(A, B)     la64_lock_storeifnull_d(A, B)

+#define native_lock_decifnot0b(A)           la64_lock_decifnot0b(A)

+#define native_lock_storeb(A, B)            la64_lock_storeb(A, B)

+#define native_lock_incif0(A)               la64_lock_incif0(A)

+#define native_lock_decifnot0(A)            la64_lock_decifnot0(A)

+#define native_lock_store(A, B)             la64_lock_store(A, B)

+#define native_lock_store_dd(A, B)          la64_lock_store_dd(A, B)

 

 // there is no atomic move on 8bytes, so faking it

 #define native_lock_read_b(A)               tmpcas=*(uint8_t*)(A)

-#define native_lock_write_b(A, B)           la464_lock_cas_b(A, tmpcas, B)

+#define native_lock_write_b(A, B)           la64_lock_cas_b(A, tmpcas, B)

 // there is no atomic move on 16bytes, so faking it

 #define native_lock_read_h(A)               tmpcas=*(uint16_t*)(A)

-#define native_lock_write_h(A, B)           la464_lock_cas_h(A, tmpcas, B)

+#define native_lock_write_h(A, B)           la64_lock_cas_h(A, tmpcas, B)

 #define native_lock_read_d(A)               tmpcas=*(uint32_t*)(A)

-#define native_lock_write_d(A, B)           la464_lock_cas_d(A, tmpcas, B)

+#define native_lock_write_d(A, B)           la64_lock_cas_d(A, tmpcas, B)

 #define native_lock_read_dd(A)              tmpcas=*(uint64_t*)(A)

-#define native_lock_write_dd(A, B)          la464_lock_cas_dd(A, tmpcas, B)

+#define native_lock_write_dd(A, B)          la64_lock_cas_dd(A, tmpcas, B)

 #define native_lock_read_dq(A, B, C)        *A=tmpcas=((uint64_t*)(C))[0]; *B=((uint64_t*)(C))[1];

-#define native_lock_write_dq(A, B, C)       la464_lock_cas_dq(C, A, tmpcas, B)

-#define native_lock_get_b(A)                la464_lock_get_b(A)

-#define native_lock_get_d(A)                la464_lock_get_d(A)

-#define native_lock_get_dd(A)               la464_lock_get_dd(A)

+#define native_lock_write_dq(A, B, C)       la64_lock_cas_dq(C, A, tmpcas, B)

+#define native_lock_get_b(A)                la64_lock_get_b(A)

+#define native_lock_get_d(A)                la64_lock_get_d(A)

+#define native_lock_get_dd(A)               la64_lock_get_dd(A)

 

 #else

 #error Unsupported architecture

diff --git a/src/emu/x64emu_private.h b/src/emu/x64emu_private.h
index 4548d7e9..65a99bc3 100644
--- a/src/emu/x64emu_private.h
+++ b/src/emu/x64emu_private.h
@@ -74,7 +74,7 @@ typedef struct x64emu_s {
     #ifdef RV64         // it would be better to use a dedicated register for this like arm64 xSavedSP, but we're running of of free registers.
     uintptr_t xSPSave;  // sp base value of current dynarec frame, used by call/ret optimization to reset stack when unmatch.
     #endif
-    #ifdef LA464         // it would be better to use a dedicated register for this like arm64 xSavedSP, but we're running of of free registers.
+    #ifdef LA64         // it would be better to use a dedicated register for this like arm64 xSavedSP, but we're running of of free registers.
     uintptr_t xSPSave;  // sp base value of current dynarec frame, used by call/ret optimization to reset stack when unmatch.
     #endif
     fpu_ld_t    fpu_ld[8]; // for long double emulation / 80bits fld fst
diff --git a/src/include/dynarec_la464.h b/src/include/dynarec_la464.h
index 2adb3e98..cf8946f0 100644
--- a/src/include/dynarec_la464.h
+++ b/src/include/dynarec_la464.h
@@ -1,5 +1,5 @@
-#ifndef __DYNAREC_LA464_H_
-#define __DYNAREC_LA464_H_
+#ifndef __DYNAREC_LA64_H_
+#define __DYNAREC_LA64_H_
 
 typedef struct dynablock_s dynablock_t;
 typedef struct x64emu_s x64emu_t;
@@ -7,4 +7,4 @@ typedef struct x64emu_s x64emu_t;
 void CancelBlock64(void);
 void* FillBlock64(dynablock_t* block, uintptr_t addr);
 
-#endif //__DYNAREC_LA464_H_
\ No newline at end of file
+#endif //__DYNAREC_LA64_H_
\ No newline at end of file
diff --git a/src/libtools/signals.c b/src/libtools/signals.c
index c3c1c572..1fe7a1de 100644
--- a/src/libtools/signals.c
+++ b/src/libtools/signals.c
@@ -494,7 +494,7 @@ x64emu_t* getEmuSignal(x64emu_t* emu, ucontext_t* p, dynablock_t* db)
         if(db && p->uc_mcontext.regs[0]>0x10000) {
             emu = (x64emu_t*)p->uc_mcontext.regs[0];
         }
-#elif defined(LA464)
+#elif defined(LA64)
         if(db && p->uc_mcontext.__gregs[4]>0x10000) {
             emu = (x64emu_t*)p->uc_mcontext.__gregs[4];
         }
@@ -530,7 +530,7 @@ void copyUCTXreg2Emu(x64emu_t* emu, ucontext_t* p, uintptr_t ip) {
     emu->regs[_R15].q[0] = p->uc_mcontext.regs[25];
     emu->ip.q[0] = ip;
     emu->eflags.x64 = p->uc_mcontext.regs[26];
-#elif defined(LA464)
+#elif defined(LA64)
         emu->regs[_AX].q[0] = p->uc_mcontext.__gregs[12];
         emu->regs[_CX].q[0] = p->uc_mcontext.__gregs[13];
         emu->regs[_DX].q[0] = p->uc_mcontext.__gregs[14];
@@ -851,7 +851,7 @@ void my_sigactionhandler_oldcode(int32_t sig, int simple, siginfo_t* info, void
         if(db)
             frame = (uintptr_t)p->uc_mcontext.regs[10+_SP];
     }
-#elif defined(LA464)
+#elif defined(LA64)
     dynablock_t* db = (dynablock_t*)cur_db;//FindDynablockFromNativeAddress(pc);
     ucontext_t *p = (ucontext_t *)ucntx;
     void* pc = NULL;
@@ -944,7 +944,7 @@ void my_sigactionhandler_oldcode(int32_t sig, int simple, siginfo_t* info, void
         sigcontext->uc_mcontext.gregs[X64_R15] = p->uc_mcontext.regs[25];
         sigcontext->uc_mcontext.gregs[X64_RIP] = getX64Address(db, (uintptr_t)pc);
     }
-#elif defined(LA464)
+#elif defined(LA64)
     if(db && p) {
         sigcontext->uc_mcontext.gregs[X64_RAX] = p->uc_mcontext.__gregs[12];
         sigcontext->uc_mcontext.gregs[X64_RCX] = p->uc_mcontext.__gregs[13];
@@ -1278,7 +1278,7 @@ void my_box64signalhandler(int32_t sig, siginfo_t* info, void * ucntx)
 #elif defined __powerpc64__
     void * pc = (void*)p->uc_mcontext.gp_regs[PT_NIP];
     void* fpsimd = NULL;
-#elif defined(LA464)
+#elif defined(LA64)
     void * pc = (void*)p->uc_mcontext.__pc;
     void* fpsimd = NULL;
 #elif defined(SW64)
@@ -1348,7 +1348,7 @@ void my_box64signalhandler(int32_t sig, siginfo_t* info, void * ucntx)
                     emu->xmm[2].u128 = fpsimd->vregs[2];
                     emu->xmm[3].u128 = fpsimd->vregs[3];
                 }*/
-#elif defined(LA464)
+#elif defined(LA64)
                 /*if(fpsimd) {
                     emu->xmm[0].u128 = fpsimd->vregs[0];
                     emu->xmm[1].u128 = fpsimd->vregs[1];
@@ -1505,7 +1505,7 @@ dynarec_log(/*LOG_DEBUG*/LOG_INFO, "Repeated SIGSEGV with Access error on %p for
             x64pc = getX64Address(db, (uintptr_t)pc);
             rsp = (void*)p->uc_mcontext.regs[10+_SP];
         }
-#elif defined(LA464)
+#elif defined(LA64)
         if(db && p->uc_mcontext.__gregs[4]>0x10000) {
             emu = (x64emu_t*)p->uc_mcontext.__gregs[4];
         }
@@ -1684,7 +1684,7 @@ dynarec_log(/*LOG_DEBUG*/LOG_INFO, "Repeated SIGSEGV with Access error on %p for
                 for (int i=-4; i<4; ++i) {
                     printf_log(log_minimum, "%sRSP%c0x%02x:0x%016lx", (i%4)?" ":"\n", i<0?'-':'+', abs(i)*8, *(uintptr_t*)(rsp+i*8));
                 }
-#elif defined(LA464)
+#elif defined(LA64)
             if(db) {
                 shown_regs = 1;
                 for (int i=0; i<16; ++i) {
@@ -1741,7 +1741,7 @@ void my_sigactionhandler(int32_t sig, siginfo_t* info, void * ucntx)
     ucontext_t *p = (ucontext_t *)ucntx;
     #ifdef ARM64
     void * pc = (void*)p->uc_mcontext.pc;
-    #elif defined(LA464)
+    #elif defined(LA64)
     void * pc = (void*)p->uc_mcontext.__pc;
     #elif defined(RV64)
     void * pc = (void*)p->uc_mcontext.__gregs[0];
diff --git a/src/main.c b/src/main.c
index 14d86798..bf628181 100644
--- a/src/main.c
+++ b/src/main.c
@@ -442,7 +442,7 @@ HWCAP2_ECV
         printf_log(LOG_INFO, " FRINT");
     if(arm64_afp)
         printf_log(LOG_INFO, " AFP");
-#elif defined(LA464)
+#elif defined(LA64)
     printf_log(LOG_INFO, "Dynarec for LoongArch");
 #elif defined(RV64)
     void RV64_Detect_Function();