diff --git a/src/codegen_backend_x86.c b/src/codegen_backend_x86.c
index 6119ea2..7beffc5 100644
--- a/src/codegen_backend_x86.c
+++ b/src/codegen_backend_x86.c
@@ -99,7 +99,7 @@ static void build_load_routine(codeblock_t *block, int size, int is_float)
                 host_x86_MOVQ_XREG_BASE_INDEX(block, REG_XMM_TEMP, REG_ESI, REG_ECX);
         else
                 fatal("build_load_routine: size=%i\n", size);
-        host_x86_XOR32_REG_REG(block, REG_ESI, REG_ESI, REG_ESI);
+        host_x86_XOR32_REG_REG(block, REG_ESI, REG_ESI);
         host_x86_RET(block);
         
         *branch_offset = (uint8_t)((uintptr_t)&block_write_data[block_pos] - (uintptr_t)branch_offset) - 1;
@@ -189,7 +189,7 @@ static void build_store_routine(codeblock_t *block, int size, int is_float)
                 host_x86_MOVQ_BASE_INDEX_XREG(block, REG_ESI, REG_EDI, REG_XMM_TEMP);
         else
                 fatal("build_store_routine: size=%i is_float=%i\n", size, is_float);
-        host_x86_XOR32_REG_REG(block, REG_ESI, REG_ESI, REG_ESI);
+        host_x86_XOR32_REG_REG(block, REG_ESI, REG_ESI);
         host_x86_RET(block);
 
         *branch_offset = (uint8_t)((uintptr_t)&block_write_data[block_pos] - (uintptr_t)branch_offset) - 1;
@@ -203,7 +203,7 @@ static void build_store_routine(codeblock_t *block, int size, int is_float)
         if (size == 8)
         {
                 host_x86_MOVQ_STACK_OFFSET_XREG(block, -8, REG_XMM_TEMP);
-                host_x86_SUB32_REG_IMM(block, REG_ESP, REG_ESP, 8);
+                host_x86_SUB32_REG_IMM(block, REG_ESP, 8);
         }
         host_x86_PUSH(block, REG_EDI);
         if (size == 1)
@@ -216,7 +216,7 @@ static void build_store_routine(codeblock_t *block, int size, int is_float)
                 host_x86_CALL(block, (void *)writememql);
         host_x86_POP(block, REG_EDI);
         if (size == 8)
-                host_x86_ADD32_REG_IMM(block, REG_ESP, REG_ESP, 8);
+                host_x86_ADD32_REG_IMM(block, REG_ESP, 8);
         host_x86_POP(block, REG_ECX);
         host_x86_POP(block, REG_EDX);
         host_x86_POP(block, REG_EAX);
@@ -309,7 +309,7 @@ pclog("  offsetof(codeblock_t, next_2)=%i\n", offsetof(codeblock_t, next_2));
         host_x86_MOV32_STACK_IMM(block, STACK_ARG1, 0);
         host_x86_CALL(block, (void *)x86gpf);
         codegen_exit_rout = &codeblock[block_current].data[block_pos];
-        host_x86_ADD32_REG_IMM(block, REG_ESP, REG_ESP, 64);
+        host_x86_ADD32_REG_IMM(block, REG_ESP, 64);
         host_x86_POP(block, REG_EDI);
         host_x86_POP(block, REG_ESI);
         host_x86_POP(block, REG_EBP);
@@ -342,19 +342,19 @@ void codegen_backend_prologue(codeblock_t *block)
         host_x86_PUSH(block, REG_EBP);
         host_x86_PUSH(block, REG_ESI);
         host_x86_PUSH(block, REG_EDI);
-        host_x86_SUB32_REG_IMM(block, REG_ESP, REG_ESP, 64);
+        host_x86_SUB32_REG_IMM(block, REG_ESP, 64);
         host_x86_MOV32_REG_IMM(block, REG_EBP, ((uintptr_t)&cpu_state) + 128);
         if (block->flags & CODEBLOCK_HAS_FPU)
         {
                 host_x86_MOV32_REG_ABS(block, REG_EAX, &cpu_state.TOP);
-                host_x86_SUB32_REG_IMM(block, REG_EAX, REG_EAX, block->TOP);
+                host_x86_SUB32_REG_IMM(block, REG_EAX, block->TOP);
                 host_x86_MOV32_BASE_OFFSET_REG(block, REG_ESP, IREG_TOP_diff_stack_offset, REG_EAX);
         }
 }
 
 void codegen_backend_epilogue(codeblock_t *block)
 {
-        host_x86_ADD32_REG_IMM(block, REG_ESP, REG_ESP, 64);
+        host_x86_ADD32_REG_IMM(block, REG_ESP, 64);
         host_x86_POP(block, REG_EDI);
         host_x86_POP(block, REG_ESI);
         host_x86_POP(block, REG_EBP);
diff --git a/src/codegen_backend_x86_ops.c b/src/codegen_backend_x86_ops.c
index 2d9ef2c..47f7493 100644
--- a/src/codegen_backend_x86_ops.c
+++ b/src/codegen_backend_x86_ops.c
@@ -103,7 +103,7 @@ static int is_imm8(uint32_t imm_data)
         return 0;
 }
 
-void host_x86_ADD32_REG_ABS(codeblock_t *block, int dst_reg, int src_reg, void *p)
+void host_x86_ADD32_REG_ABS(codeblock_t *block, int dst_reg, void *p)
 {
         int offset = (uintptr_t)p - (((uintptr_t)&cpu_state) + 128);
 
@@ -121,11 +121,8 @@ void host_x86_ADD32_REG_ABS(codeblock_t *block, int dst_reg, int src_reg, void *
         }
 }
 
-void host_x86_ADD8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data)
+void host_x86_ADD8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_ADD8_REG_IMM - dst_reg != src_reg\n");
-
         if (dst_reg == REG_EAX)
         {
                 codegen_alloc_bytes(block, 2);
@@ -137,11 +134,8 @@ void host_x86_ADD8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t
                 codegen_addbyte3(block, 0x80, 0xc0 | RM_OP_ADD | dst_reg, imm_data); /*ADD dst_reg, imm_data*/
         }
 }
-void host_x86_ADD16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data)
+void host_x86_ADD16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_ADD16_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 4);
@@ -160,11 +154,8 @@ void host_x86_ADD16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16
                 codegen_addword(block, imm_data);
         }
 }
-void host_x86_ADD32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data)
+void host_x86_ADD32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_ADD32_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 3);
@@ -184,29 +175,20 @@ void host_x86_ADD32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32
         }
 }
 
-void host_x86_ADD8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_ADD8_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_ADD8_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x00, 0xc0 | dst_reg | (src_reg_b << 3)); /*ADD dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x00, 0xc0 | dst_reg | (src_reg << 3)); /*ADD dst_reg, src_reg*/
 }
-void host_x86_ADD16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_ADD16_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_ADD16_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 3);
-        codegen_addbyte3(block, 0x66, 0x01, 0xc0 | dst_reg | (src_reg_b << 3)); /*ADD dst_reg, src_reg_b*/
+        codegen_addbyte3(block, 0x66, 0x01, 0xc0 | dst_reg | (src_reg << 3)); /*ADD dst_reg, src_reg*/
 }
-void host_x86_ADD32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_ADD32_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_ADD32_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 3);
-        codegen_addbyte2(block, 0x01, 0xc0 | dst_reg | (src_reg_b << 3)); /*ADD dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x01, 0xc0 | dst_reg | (src_reg << 3)); /*ADD dst_reg, src_reg*/
 }
 
 void host_x86_ADDPS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg)
@@ -220,11 +202,8 @@ void host_x86_ADDSD_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg)
         codegen_addbyte4(block, 0xf2, 0x0f, 0x58, 0xc0 | src_reg | (dst_reg << 3));
 }
 
-void host_x86_AND8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data)
+void host_x86_AND8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_AND8_REG_IMM - dst_reg != src_reg\n");
-
         if (dst_reg == REG_EAX)
         {
                 codegen_alloc_bytes(block, 2);
@@ -236,11 +215,8 @@ void host_x86_AND8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t
                 codegen_addbyte3(block, 0x80, 0xc0 | RM_OP_AND | dst_reg, imm_data); /*AND dst_reg, imm_data*/
         }
 }
-void host_x86_AND16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data)
+void host_x86_AND16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_AND16_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 4);
@@ -259,11 +235,8 @@ void host_x86_AND16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16
                 codegen_addword(block, imm_data);
         }
 }
-void host_x86_AND32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data)
+void host_x86_AND32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_AND32_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 3);
@@ -283,29 +256,20 @@ void host_x86_AND32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32
         }
 }
 
-void host_x86_AND8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_AND8_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_AND8_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x20, 0xc0 | dst_reg | (src_reg_b << 3)); /*AND dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x20, 0xc0 | dst_reg | (src_reg << 3)); /*AND dst_reg, src_reg_b*/
 }
-void host_x86_AND16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_AND16_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_AND16_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 3);
-        codegen_addbyte3(block, 0x66, 0x21, 0xc0 | dst_reg | (src_reg_b << 3)); /*AND dst_reg, src_reg_b*/
+        codegen_addbyte3(block, 0x66, 0x21, 0xc0 | dst_reg | (src_reg << 3)); /*AND dst_reg, src_reg_b*/
 }
-void host_x86_AND32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_AND32_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_AND32_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x21, 0xc0 | dst_reg | (src_reg_b << 3)); /*AND dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x21, 0xc0 | dst_reg | (src_reg << 3)); /*AND dst_reg, src_reg_b*/
 }
 
 void host_x86_CALL(codeblock_t *block, void *p)
@@ -1263,36 +1227,24 @@ void host_x86_MULSD_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg)
         codegen_addbyte4(block, 0xf2, 0x0f, 0x59, 0xc0 | src_reg | (dst_reg << 3));
 }
 
-void host_x86_OR8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_OR8_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_OR8_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x08, 0xc0 | dst_reg | (src_reg_b << 3)); /*OR dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x08, 0xc0 | dst_reg | (src_reg << 3)); /*OR dst_reg, src_reg_b*/
 }
-void host_x86_OR16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_OR16_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_OR16_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 3);
-        codegen_addbyte3(block, 0x66, 0x09, 0xc0 | dst_reg | (src_reg_b << 3)); /*OR dst_reg, src_reg_b*/
+        codegen_addbyte3(block, 0x66, 0x09, 0xc0 | dst_reg | (src_reg << 3)); /*OR dst_reg, src_reg_b*/
 }
-void host_x86_OR32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_OR32_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_OR32_REG_IMM - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x09, 0xc0 | dst_reg | (src_reg_b << 3)); /*OR dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x09, 0xc0 | dst_reg | (src_reg << 3)); /*OR dst_reg, src_reg_b*/
 }
 
-void host_x86_OR8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data)
+void host_x86_OR8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_OR8_REG_IMM - dst_reg != src_reg\n");
-
         if (dst_reg == REG_EAX)
         {
                 codegen_alloc_bytes(block, 2);
@@ -1304,11 +1256,8 @@ void host_x86_OR8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t
                 codegen_addbyte3(block, 0x80, 0xc0 | RM_OP_OR | dst_reg, imm_data); /*OR dst_reg, imm_data*/
         }
 }
-void host_x86_OR16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data)
+void host_x86_OR16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_OR16_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 4);
@@ -1327,11 +1276,8 @@ void host_x86_OR16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_
                 codegen_addword(block, imm_data);
         }
 }
-void host_x86_OR32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data)
+void host_x86_OR32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_OR32_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 3);
@@ -1732,11 +1678,8 @@ void host_x86_SQRTSS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg)
         codegen_addbyte4(block, 0xf3, 0x0f, 0x51, 0xc0 | src_reg | (dst_reg << 3)); /*SQRTSS dst_reg, src_reg*/
 }
 
-void host_x86_SUB8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data)
+void host_x86_SUB8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_SUB8_REG_IMM - dst_reg != src_reg\n");
-
         if (dst_reg == REG_EAX)
         {
                 codegen_alloc_bytes(block, 2);
@@ -1748,11 +1691,8 @@ void host_x86_SUB8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t
                 codegen_addbyte3(block, 0x80, 0xc0 | RM_OP_SUB | dst_reg, imm_data); /*SUB dst_reg, imm_data*/
         }
 }
-void host_x86_SUB16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data)
+void host_x86_SUB16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_SUB16_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 4);
@@ -1771,11 +1711,8 @@ void host_x86_SUB16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16
                 codegen_addword(block, imm_data);
         }
 }
-void host_x86_SUB32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data)
+void host_x86_SUB32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_SUB32_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 3);
@@ -1795,29 +1732,20 @@ void host_x86_SUB32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32
         }
 }
 
-void host_x86_SUB8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_SUB8_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_SUB8_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x28, 0xc0 | dst_reg | (src_reg_b << 3)); /*SUB dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x28, 0xc0 | dst_reg | (src_reg << 3)); /*SUB dst_reg, src_reg*/
 }
-void host_x86_SUB16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_SUB16_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_SUB16_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 3);
-        codegen_addbyte3(block, 0x66, 0x29, 0xc0 | dst_reg | (src_reg_b << 3)); /*SUB dst_reg, src_reg_b*/
+        codegen_addbyte3(block, 0x66, 0x29, 0xc0 | dst_reg | (src_reg << 3)); /*SUB dst_reg, src_reg*/
 }
-void host_x86_SUB32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_SUB32_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_SUB32_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x29, 0xc0 | dst_reg | (src_reg_b << 3)); /*SUB dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x29, 0xc0 | dst_reg | (src_reg << 3)); /*SUB dst_reg, src_reg*/
 }
 
 void host_x86_SUBPS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg)
@@ -1868,36 +1796,24 @@ void host_x86_UNPCKLPS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg)
         codegen_addbyte3(block, 0x0f, 0x14, 0xc0 | src_reg | (dst_reg << 3));
 }
 
-void host_x86_XOR8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_XOR8_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_XOR8_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x30, 0xc0 | dst_reg | (src_reg_b << 3)); /*XOR dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x30, 0xc0 | dst_reg | (src_reg << 3)); /*XOR dst_reg, src_reg*/
 }
-void host_x86_XOR16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_XOR16_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_XOR16_REG_REG - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 3);
-        codegen_addbyte3(block, 0x66, 0x31, 0xc0 | dst_reg | (src_reg_b << 3)); /*XOR dst_reg, src_reg_b*/
+        codegen_addbyte3(block, 0x66, 0x31, 0xc0 | dst_reg | (src_reg << 3)); /*XOR dst_reg, src_reg*/
 }
-void host_x86_XOR32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b)
+void host_x86_XOR32_REG_REG(codeblock_t *block, int dst_reg, int src_reg)
 {
-        if (dst_reg != src_reg_a)
-                fatal("host_x86_XOR32_REG_IMM - dst_reg != src_reg_a\n");
-
         codegen_alloc_bytes(block, 2);
-        codegen_addbyte2(block, 0x31, 0xc0 | dst_reg | (src_reg_b << 3)); /*XOR dst_reg, src_reg_b*/
+        codegen_addbyte2(block, 0x31, 0xc0 | dst_reg | (src_reg << 3)); /*XOR dst_reg, src_reg*/
 }
 
-void host_x86_XOR8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data)
+void host_x86_XOR8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_XOR8_REG_IMM - dst_reg != src_reg\n");
-
         if (dst_reg == REG_EAX)
         {
                 codegen_alloc_bytes(block, 2);
@@ -1909,11 +1825,8 @@ void host_x86_XOR8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t
                 codegen_addbyte3(block, 0x80, 0xc0 | RM_OP_XOR | dst_reg, imm_data); /*XOR dst_reg, imm_data*/
         }
 }
-void host_x86_XOR16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data)
+void host_x86_XOR16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_XOR16_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 4);
@@ -1932,11 +1845,8 @@ void host_x86_XOR16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16
                 codegen_addword(block, imm_data);
         }
 }
-void host_x86_XOR32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data)
+void host_x86_XOR32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data)
 {
-        if (dst_reg != src_reg)
-                fatal("host_x86_XOR32_REG_IMM - dst_reg != src_reg\n");
-
         if (is_imm8(imm_data))
         {
                 codegen_alloc_bytes(block, 3);
diff --git a/src/codegen_backend_x86_ops.h b/src/codegen_backend_x86_ops.h
index 22a8746..db7b37c 100644
--- a/src/codegen_backend_x86_ops.h
+++ b/src/codegen_backend_x86_ops.h
@@ -1,23 +1,23 @@
-void host_x86_ADD32_REG_ABS(codeblock_t *block, int dst_reg, int src_reg, void *p);
+void host_x86_ADD32_REG_ABS(codeblock_t *block, int dst_reg, void *p);
 
-void host_x86_ADD8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data);
-void host_x86_ADD16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data);
-void host_x86_ADD32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data);
+void host_x86_ADD8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data);
+void host_x86_ADD16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data);
+void host_x86_ADD32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data);
 
-void host_x86_ADD8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_ADD16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_ADD32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
+void host_x86_ADD8_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_ADD16_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_ADD32_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
 
 void host_x86_ADDPS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 void host_x86_ADDSD_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 
-void host_x86_AND8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data);
-void host_x86_AND16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data);
-void host_x86_AND32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data);
+void host_x86_AND8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data);
+void host_x86_AND16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data);
+void host_x86_AND32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data);
 
-void host_x86_AND8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_AND16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_AND32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
+void host_x86_AND8_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_AND16_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_AND32_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
 
 void host_x86_CALL(codeblock_t *block, void *p);
 
@@ -165,13 +165,13 @@ void host_x86_MINPS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 void host_x86_MULPS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 void host_x86_MULSD_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 
-void host_x86_OR8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_OR16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_OR32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
+void host_x86_OR8_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_OR16_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_OR32_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
 
-void host_x86_OR8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data);
-void host_x86_OR16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data);
-void host_x86_OR32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data);
+void host_x86_OR8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data);
+void host_x86_OR16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data);
+void host_x86_OR32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data);
 
 void host_x86_PACKSSWB_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 void host_x86_PACKSSDW_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
@@ -259,13 +259,13 @@ void host_x86_SHR32_IMM(codeblock_t *block, int dst_reg, int shift);
 void host_x86_SQRTSD_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 void host_x86_SQRTSS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 
-void host_x86_SUB8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data);
-void host_x86_SUB16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data);
-void host_x86_SUB32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data);
+void host_x86_SUB8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data);
+void host_x86_SUB16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data);
+void host_x86_SUB32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data);
 
-void host_x86_SUB8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_SUB16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_SUB32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
+void host_x86_SUB8_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_SUB16_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_SUB32_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
 
 void host_x86_SUBPS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 void host_x86_SUBSD_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
@@ -278,13 +278,13 @@ void host_x86_TEST32_REG_IMM(codeblock_t *block, int src_host_reg, uint32_t imm_
 
 void host_x86_UNPCKLPS_XREG_XREG(codeblock_t *block, int dst_reg, int src_reg);
 
-void host_x86_XOR8_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_XOR16_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
-void host_x86_XOR32_REG_REG(codeblock_t *block, int dst_reg, int src_reg_a, int src_reg_b);
+void host_x86_XOR8_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_XOR16_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
+void host_x86_XOR32_REG_REG(codeblock_t *block, int dst_reg, int src_reg);
 
-void host_x86_XOR8_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint8_t imm_data);
-void host_x86_XOR16_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint16_t imm_data);
-void host_x86_XOR32_REG_IMM(codeblock_t *block, int dst_reg, int src_reg, uint32_t imm_data);
+void host_x86_XOR8_REG_IMM(codeblock_t *block, int dst_reg, uint8_t imm_data);
+void host_x86_XOR16_REG_IMM(codeblock_t *block, int dst_reg, uint16_t imm_data);
+void host_x86_XOR32_REG_IMM(codeblock_t *block, int dst_reg, uint32_t imm_data);
 
 void host_x87_FILDq_BASE(codeblock_t *block, int base_reg);
 void host_x87_FISTPq_BASE(codeblock_t *block, int base_reg);
diff --git a/src/codegen_backend_x86_uops.c b/src/codegen_backend_x86_uops.c
index c6dea83..55bcc13 100644
--- a/src/codegen_backend_x86_uops.c
+++ b/src/codegen_backend_x86_uops.c
@@ -40,19 +40,19 @@ static int codegen_ADD(codeblock_t *block, uop_t *uop)
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_LEA_REG_REG(block, dest_reg, src_reg_a, src_reg_b);
                 else
-                        host_x86_ADD32_REG_REG(block, dest_reg, src_reg_a, src_reg_b);
+                        host_x86_ADD32_REG_REG(block, dest_reg, src_reg_b);
         }
         else if (REG_IS_W(dest_size) && REG_IS_W(src_size_a) && REG_IS_W(src_size_b))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV16_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_ADD16_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_ADD16_REG_REG(block, dest_reg, src_reg_b);
         }
         else if (REG_IS_B(dest_size) && REG_IS_B(src_size_a) && REG_IS_B(src_size_b))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV8_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_ADD8_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_ADD8_REG_REG(block, dest_reg, src_reg_b);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -71,19 +71,19 @@ static int codegen_ADD_IMM(codeblock_t *block, uop_t *uop)
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_LEA_REG_IMM(block, dest_reg, src_reg, uop->imm_data);
                 else
-                        host_x86_ADD32_REG_IMM(block, dest_reg, src_reg, uop->imm_data);
+                        host_x86_ADD32_REG_IMM(block, dest_reg, uop->imm_data);
         }
         else if (REG_IS_W(dest_size) && REG_IS_W(src_size))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV16_REG_REG(block, dest_reg, src_reg);
-                host_x86_ADD16_REG_IMM(block, dest_reg, dest_reg, uop->imm_data);
+                host_x86_ADD16_REG_IMM(block, dest_reg, uop->imm_data);
         }
         else if (REG_IS_B(dest_size) && REG_IS_B(src_size))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV8_REG_REG(block, dest_reg, src_reg);
-                host_x86_ADD8_REG_IMM(block, dest_reg, dest_reg, uop->imm_data);
+                host_x86_ADD8_REG_IMM(block, dest_reg, uop->imm_data);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -95,7 +95,12 @@ static int codegen_ADD_IMM(codeblock_t *block, uop_t *uop)
 static int codegen_ADD_LSHIFT(codeblock_t *block, uop_t *uop)
 {
         if (!uop->imm_data)
-                host_x86_ADD32_REG_REG(block, uop->dest_reg_a_real, uop->src_reg_a_real, uop->src_reg_b_real);
+        {
+                if (uop->dest_reg_a_real == uop->src_reg_a_real)
+                        host_x86_ADD32_REG_REG(block, uop->dest_reg_a_real, uop->src_reg_b_real);
+                else
+                        host_x86_LEA_REG_REG(block, uop->dest_reg_a_real, uop->src_reg_a_real, uop->src_reg_b_real);
+        }
         else if (uop->imm_data < 4)
                 host_x86_LEA_REG_REG_SHIFT(block, uop->dest_reg_a_real, uop->src_reg_a_real, uop->src_reg_b_real, uop->imm_data);
 #ifdef RECOMPILER_DEBUG
@@ -118,19 +123,19 @@ static int codegen_AND(codeblock_t *block, uop_t *uop)
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV32_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_AND32_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_AND32_REG_REG(block, dest_reg, src_reg_b);
         }
         else if (REG_IS_W(dest_size) && REG_IS_W(src_size_a) && REG_IS_W(src_size_b))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV16_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_AND16_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_AND16_REG_REG(block, dest_reg, src_reg_b);
         }
         else if (REG_IS_B(dest_size) && REG_IS_B(src_size_a) && REG_IS_B(src_size_b))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV8_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_AND8_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_AND8_REG_REG(block, dest_reg, src_reg_b);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -148,19 +153,19 @@ static int codegen_AND_IMM(codeblock_t *block, uop_t *uop)
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV32_REG_REG(block, dest_reg, src_reg);
-                host_x86_AND32_REG_IMM(block, dest_reg, dest_reg, uop->imm_data);
+                host_x86_AND32_REG_IMM(block, dest_reg, uop->imm_data);
         }
         else if (REG_IS_W(dest_size) && REG_IS_W(src_size))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV16_REG_REG(block, dest_reg, src_reg);
-                host_x86_AND16_REG_IMM(block, dest_reg, dest_reg, uop->imm_data);
+                host_x86_AND16_REG_IMM(block, dest_reg, uop->imm_data);
         }
         else if (REG_IS_B(dest_size) && REG_IS_B(src_size))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV8_REG_REG(block, dest_reg, src_reg);
-                host_x86_AND8_REG_IMM(block, dest_reg, dest_reg, uop->imm_data);
+                host_x86_AND8_REG_IMM(block, dest_reg, uop->imm_data);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -638,10 +643,10 @@ static int codegen_FTST(codeblock_t *block, uop_t *uop)
                 host_x86_PXOR_XREG_XREG(block, REG_XMM_TEMP, REG_XMM_TEMP);
                 if (dest_reg != REG_EAX)
                         host_x86_MOV32_REG_REG(block, REG_ECX, REG_EAX);
-                host_x86_XOR32_REG_REG(block, REG_EAX, REG_EAX, REG_EAX);
+                host_x86_XOR32_REG_REG(block, REG_EAX, REG_EAX);
                 host_x86_COMISD_XREG_XREG(block, src_reg_a, REG_XMM_TEMP);
                 host_x86_LAHF(block);
-                host_x86_AND16_REG_IMM(block, REG_EAX, REG_EAX, C0|C2|C3);
+                host_x86_AND16_REG_IMM(block, REG_EAX, C0|C2|C3);
                 if (dest_reg != REG_EAX)
                 {
                         host_x86_MOV16_REG_REG(block, dest_reg, REG_EAX);
@@ -679,10 +684,10 @@ static int codegen_FCOM(codeblock_t *block, uop_t *uop)
         {
                 if (dest_reg != REG_EAX)
                         host_x86_MOV32_REG_REG(block, REG_ECX, REG_EAX);
-                host_x86_XOR32_REG_REG(block, REG_EAX, REG_EAX, REG_EAX);
+                host_x86_XOR32_REG_REG(block, REG_EAX, REG_EAX);
                 host_x86_COMISD_XREG_XREG(block, src_reg_a, src_reg_b);
                 host_x86_LAHF(block);
-                host_x86_AND16_REG_IMM(block, REG_EAX, REG_EAX, C0|C2|C3);
+                host_x86_AND16_REG_IMM(block, REG_EAX, C0|C2|C3);
                 if (dest_reg != REG_EAX)
                 {
                         host_x86_MOV16_REG_REG(block, dest_reg, REG_EAX);
@@ -924,7 +929,7 @@ static int codegen_MEM_LOAD_REG(codeblock_t *block, uop_t *uop)
 
         host_x86_LEA_REG_REG(block, REG_ESI, seg_reg, addr_reg);
         if (uop->imm_data)
-                host_x86_ADD32_REG_IMM(block, REG_ESI, REG_ESI, uop->imm_data);
+                host_x86_ADD32_REG_IMM(block, REG_ESI, uop->imm_data);
         if (REG_IS_B(dest_size))
         {
                 host_x86_CALL(block, codegen_mem_load_byte);
@@ -977,7 +982,7 @@ static int codegen_MEM_LOAD_SINGLE(codeblock_t *block, uop_t *uop)
 #endif
         host_x86_LEA_REG_REG(block, REG_ESI, seg_reg, addr_reg);
         if (uop->imm_data)
-                host_x86_ADD32_REG_IMM(block, REG_ESI, REG_ESI, uop->imm_data);
+                host_x86_ADD32_REG_IMM(block, REG_ESI, uop->imm_data);
         host_x86_CALL(block, codegen_mem_load_single);
         host_x86_TEST32_REG(block, REG_ESI, REG_ESI);
         host_x86_JNZ(block, codegen_exit_rout);
@@ -997,7 +1002,7 @@ static int codegen_MEM_LOAD_DOUBLE(codeblock_t *block, uop_t *uop)
 #endif
         host_x86_LEA_REG_REG(block, REG_ESI, seg_reg, addr_reg);
         if (uop->imm_data)
-                host_x86_ADD32_REG_IMM(block, REG_ESI, REG_ESI, uop->imm_data);
+                host_x86_ADD32_REG_IMM(block, REG_ESI, uop->imm_data);
         host_x86_CALL(block, codegen_mem_load_double);
         host_x86_TEST32_REG(block, REG_ESI, REG_ESI);
         host_x86_JNZ(block, codegen_exit_rout);
@@ -1044,7 +1049,7 @@ static int codegen_MEM_STORE_REG(codeblock_t *block, uop_t *uop)
 
         host_x86_LEA_REG_REG(block, REG_ESI, seg_reg, addr_reg);
         if (uop->imm_data)
-                host_x86_ADD32_REG_IMM(block, REG_ESI, REG_ESI, uop->imm_data);
+                host_x86_ADD32_REG_IMM(block, REG_ESI, uop->imm_data);
         if (REG_IS_B(src_size))
         {
                 host_x86_MOV8_REG_REG(block, REG_ECX, src_reg);
@@ -1123,7 +1128,7 @@ static int codegen_MEM_STORE_SINGLE(codeblock_t *block, uop_t *uop)
 #endif
         host_x86_LEA_REG_REG(block, REG_ESI, seg_reg, addr_reg);
         if (uop->imm_data)
-                host_x86_ADD32_REG_IMM(block, REG_ESI, REG_ESI, uop->imm_data);
+                host_x86_ADD32_REG_IMM(block, REG_ESI, uop->imm_data);
         host_x86_CVTSD2SS_XREG_XREG(block, REG_XMM_TEMP, src_reg);
         host_x86_CALL(block, codegen_mem_store_single);
         host_x86_TEST32_REG(block, REG_ESI, REG_ESI);
@@ -1142,7 +1147,7 @@ static int codegen_MEM_STORE_DOUBLE(codeblock_t *block, uop_t *uop)
 #endif
         host_x86_LEA_REG_REG(block, REG_ESI, seg_reg, addr_reg);
         if (uop->imm_data)
-                host_x86_ADD32_REG_IMM(block, REG_ESI, REG_ESI, uop->imm_data);
+                host_x86_ADD32_REG_IMM(block, REG_ESI, uop->imm_data);
         host_x86_MOVQ_XREG_XREG(block, REG_XMM_TEMP, src_reg);
         host_x86_CALL(block, codegen_mem_store_double);
         host_x86_TEST32_REG(block, REG_ESI, REG_ESI);
@@ -1364,17 +1369,19 @@ static int codegen_OR(codeblock_t *block, uop_t *uop)
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV32_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_OR32_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_OR32_REG_REG(block, dest_reg, src_reg_b);
         }
         else if (REG_IS_W(dest_size) && REG_IS_W(src_size_a) && REG_IS_W(src_size_b))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV16_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_OR16_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_OR16_REG_REG(block, dest_reg, src_reg_b);
         }
         else if (REG_IS_B(dest_size) && REG_IS_B(src_size_a) && REG_IS_B(src_size_b))
         {
-                host_x86_OR8_REG_REG(block, dest_reg, src_reg_a, src_reg_b);
+                if (uop->dest_reg_a_real != uop->src_reg_a_real)
+                        host_x86_MOV8_REG_REG(block, dest_reg, src_reg_a);
+                host_x86_OR8_REG_REG(block, dest_reg, src_reg_b);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -1385,19 +1392,19 @@ static int codegen_OR(codeblock_t *block, uop_t *uop)
 static int codegen_OR_IMM(codeblock_t *block, uop_t *uop)
 {
         int dest_reg = HOST_REG_GET(uop->dest_reg_a_real), src_reg = HOST_REG_GET(uop->src_reg_a_real);
-        int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real), src_size = IREG_GET_SIZE(uop->src_reg_a_real);
+        int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real);
 
-        if (REG_IS_L(dest_size) && REG_IS_L(src_size))
+        if (REG_IS_L(dest_size) && dest_reg == src_reg)
         {
-                host_x86_OR32_REG_IMM(block, dest_reg, src_reg, uop->imm_data);
+                host_x86_OR32_REG_IMM(block, dest_reg, uop->imm_data);
         }
-        else if (REG_IS_W(dest_size) && REG_IS_W(src_size))
+        else if (REG_IS_W(dest_size) && dest_reg == src_reg)
         {
-                host_x86_OR16_REG_IMM(block, dest_reg, src_reg, uop->imm_data);
+                host_x86_OR16_REG_IMM(block, dest_reg, uop->imm_data);
         }
-        else if (REG_IS_B(dest_size) && REG_IS_B(src_size))
+        else if (REG_IS_B(dest_size) && dest_reg == src_reg)
         {
-                host_x86_OR8_REG_IMM(block, dest_reg, src_reg, uop->imm_data);
+                host_x86_OR8_REG_IMM(block, dest_reg, uop->imm_data);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -2425,19 +2432,19 @@ static int codegen_SUB(codeblock_t *block, uop_t *uop)
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV32_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_SUB32_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_SUB32_REG_REG(block, dest_reg, src_reg_b);
         }
         else if (REG_IS_W(dest_size) && REG_IS_W(src_size_a) && REG_IS_W(src_size_b))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV16_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_SUB16_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_SUB16_REG_REG(block, dest_reg, src_reg_b);
         }
         else if (REG_IS_B(dest_size) && REG_IS_B(src_size_a) && REG_IS_B(src_size_b))
         {
                 if (uop->dest_reg_a_real != uop->src_reg_a_real)
                         host_x86_MOV8_REG_REG(block, dest_reg, src_reg_a);
-                host_x86_SUB8_REG_REG(block, dest_reg, dest_reg, src_reg_b);
+                host_x86_SUB8_REG_REG(block, dest_reg, src_reg_b);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -2454,19 +2461,19 @@ static int codegen_SUB_IMM(codeblock_t *block, uop_t *uop)
         {
                 if (dest_reg != src_reg)
                         host_x86_MOV32_REG_REG(block, dest_reg, src_reg);
-                host_x86_SUB32_REG_IMM(block, dest_reg, dest_reg, uop->imm_data);
+                host_x86_SUB32_REG_IMM(block, dest_reg, uop->imm_data);
         }
         else if (REG_IS_W(dest_size) && REG_IS_W(src_size))
         {
                 if (dest_reg != src_reg)
                         host_x86_MOV16_REG_REG(block, dest_reg, src_reg);
-                host_x86_SUB16_REG_IMM(block, dest_reg, dest_reg, uop->imm_data);
+                host_x86_SUB16_REG_IMM(block, dest_reg, uop->imm_data);
         }
         else if (REG_IS_B(dest_size) && REG_IS_B(src_size))
         {
                 if (dest_reg != src_reg)
                         host_x86_MOV8_REG_REG(block, dest_reg, src_reg);
-                host_x86_SUB8_REG_IMM(block, dest_reg, dest_reg, uop->imm_data);
+                host_x86_SUB8_REG_IMM(block, dest_reg, uop->imm_data);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -2528,24 +2535,24 @@ static int codegen_TEST_JS_DEST(codeblock_t *block, uop_t *uop)
 
 static int codegen_XOR(codeblock_t *block, uop_t *uop)
 {
-        int dest_reg = HOST_REG_GET(uop->dest_reg_a_real), src_reg_a = HOST_REG_GET(uop->src_reg_a_real), src_reg_b = HOST_REG_GET(uop->src_reg_b_real);
+        int dest_reg = HOST_REG_GET(uop->dest_reg_a_real), src_reg_b = HOST_REG_GET(uop->src_reg_b_real);
         int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real), src_size_a = IREG_GET_SIZE(uop->src_reg_a_real), src_size_b = IREG_GET_SIZE(uop->src_reg_b_real);
 
         if (REG_IS_Q(dest_size) && REG_IS_Q(src_size_a) && REG_IS_Q(src_size_b) && uop->dest_reg_a_real == uop->src_reg_a_real)
         {
                 host_x86_PXOR_XREG_XREG(block, dest_reg, src_reg_b);
         }
-        else if (REG_IS_L(dest_size) && REG_IS_L(src_size_a) && REG_IS_L(src_size_b))
+        else if (REG_IS_L(dest_size) && REG_IS_L(src_size_a) && REG_IS_L(src_size_b) && uop->dest_reg_a_real == uop->src_reg_a_real)
         {
-                host_x86_XOR32_REG_REG(block, dest_reg, src_reg_a, src_reg_b);
+                host_x86_XOR32_REG_REG(block, dest_reg, src_reg_b);
         }
-        else if (REG_IS_W(dest_size) && REG_IS_W(src_size_a) && REG_IS_W(src_size_b))
+        else if (REG_IS_W(dest_size) && REG_IS_W(src_size_a) && REG_IS_W(src_size_b) && uop->dest_reg_a_real == uop->src_reg_a_real)
         {
-                host_x86_XOR16_REG_REG(block, dest_reg, src_reg_a, src_reg_b);
+                host_x86_XOR16_REG_REG(block, dest_reg, src_reg_b);
         }
-        else if (REG_IS_B(dest_size) && REG_IS_B(src_size_a) && REG_IS_B(src_size_b))
+        else if (REG_IS_B(dest_size) && REG_IS_B(src_size_a) && REG_IS_B(src_size_b) && uop->dest_reg_a_real == uop->src_reg_a_real)
         {
-                host_x86_XOR8_REG_REG(block, dest_reg, src_reg_a, src_reg_b);
+                host_x86_XOR8_REG_REG(block, dest_reg, src_reg_b);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -2555,20 +2562,20 @@ static int codegen_XOR(codeblock_t *block, uop_t *uop)
 }
 static int codegen_XOR_IMM(codeblock_t *block, uop_t *uop)
 {
-        int dest_reg = HOST_REG_GET(uop->dest_reg_a_real), src_reg = HOST_REG_GET(uop->src_reg_a_real);
+        int dest_reg = HOST_REG_GET(uop->dest_reg_a_real);
         int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real), src_size = IREG_GET_SIZE(uop->src_reg_a_real);
 
-        if (REG_IS_L(dest_size) && REG_IS_L(src_size))
+        if (REG_IS_L(dest_size) && REG_IS_L(src_size) && uop->dest_reg_a_real == uop->src_reg_a_real)
         {
-                host_x86_XOR32_REG_IMM(block, dest_reg, src_reg, uop->imm_data);
+                host_x86_XOR32_REG_IMM(block, dest_reg, uop->imm_data);
         }
-        else if (REG_IS_W(dest_size) && REG_IS_W(src_size))
+        else if (REG_IS_W(dest_size) && REG_IS_W(src_size) && uop->dest_reg_a_real == uop->src_reg_a_real)
         {
-                host_x86_XOR16_REG_IMM(block, dest_reg, src_reg, uop->imm_data);
+                host_x86_XOR16_REG_IMM(block, dest_reg, uop->imm_data);
         }
-        else if (REG_IS_B(dest_size) && REG_IS_B(src_size))
+        else if (REG_IS_B(dest_size) && REG_IS_B(src_size) && uop->dest_reg_a_real == uop->src_reg_a_real)
         {
-                host_x86_XOR8_REG_IMM(block, dest_reg, src_reg, uop->imm_data);
+                host_x86_XOR8_REG_IMM(block, dest_reg, uop->imm_data);
         }
 #ifdef RECOMPILER_DEBUG
         else
@@ -2783,8 +2790,8 @@ void codegen_direct_read_st_8(codeblock_t *block, int host_reg, void *base, int
         int offset = (uintptr_t)base - (((uintptr_t)&cpu_state) + 128);
 
         host_x86_MOV32_REG_BASE_OFFSET(block, REG_ECX, REG_ESP, IREG_TOP_diff_stack_offset);
-        host_x86_ADD32_REG_IMM(block, REG_ECX, REG_ECX, reg_idx);
-        host_x86_AND32_REG_IMM(block, REG_ECX, REG_ECX, 7);
+        host_x86_ADD32_REG_IMM(block, REG_ECX, reg_idx);
+        host_x86_AND32_REG_IMM(block, REG_ECX, 7);
         host_x86_MOV8_REG_ABS_REG_REG_SHIFT(block, host_reg, offset, REG_EBP, REG_ECX, 0);
 }
 void codegen_direct_read_st_64(codeblock_t *block, int host_reg, void *base, int reg_idx)
@@ -2792,8 +2799,8 @@ void codegen_direct_read_st_64(codeblock_t *block, int host_reg, void *base, int
         int offset = (uintptr_t)base - (((uintptr_t)&cpu_state) + 128);
 
         host_x86_MOV32_REG_BASE_OFFSET(block, REG_ECX, REG_ESP, IREG_TOP_diff_stack_offset);
-        host_x86_ADD32_REG_IMM(block, REG_ECX, REG_ECX, reg_idx);
-        host_x86_AND32_REG_IMM(block, REG_ECX, REG_ECX, 7);
+        host_x86_ADD32_REG_IMM(block, REG_ECX, reg_idx);
+        host_x86_AND32_REG_IMM(block, REG_ECX, 7);
         host_x86_MOVQ_XREG_ABS_REG_REG_SHIFT(block, host_reg, offset, REG_EBP, REG_ECX, 3);
 }
 void codegen_direct_read_st_double(codeblock_t *block, int host_reg, void *base, int reg_idx)
@@ -2801,8 +2808,8 @@ void codegen_direct_read_st_double(codeblock_t *block, int host_reg, void *base,
         int offset = (uintptr_t)base - (((uintptr_t)&cpu_state) + 128);
 
         host_x86_MOV32_REG_BASE_OFFSET(block, REG_ECX, REG_ESP, IREG_TOP_diff_stack_offset);
-        host_x86_ADD32_REG_IMM(block, REG_ECX, REG_ECX, reg_idx);
-        host_x86_AND32_REG_IMM(block, REG_ECX, REG_ECX, 7);
+        host_x86_ADD32_REG_IMM(block, REG_ECX, reg_idx);
+        host_x86_AND32_REG_IMM(block, REG_ECX, 7);
         host_x86_MOVQ_XREG_ABS_REG_REG_SHIFT(block, host_reg, offset, REG_EBP, REG_ECX, 3);
 }
 
@@ -2831,8 +2838,8 @@ void codegen_direct_write_st_8(codeblock_t *block, void *base, int reg_idx, int
         int offset = (uintptr_t)base - (((uintptr_t)&cpu_state) + 128);
 
         host_x86_MOV32_REG_BASE_OFFSET(block, REG_ECX, REG_ESP, IREG_TOP_diff_stack_offset);
-        host_x86_ADD32_REG_IMM(block, REG_ECX, REG_ECX, reg_idx);
-        host_x86_AND32_REG_IMM(block, REG_ECX, REG_ECX, 7);
+        host_x86_ADD32_REG_IMM(block, REG_ECX, reg_idx);
+        host_x86_AND32_REG_IMM(block, REG_ECX, 7);
         host_x86_MOV8_ABS_REG_REG_SHIFT_REG(block, offset, REG_EBP, REG_ECX, 0, host_reg);
 }
 void codegen_direct_write_st_64(codeblock_t *block, void *base, int reg_idx, int host_reg)
@@ -2840,8 +2847,8 @@ void codegen_direct_write_st_64(codeblock_t *block, void *base, int reg_idx, int
         int offset = (uintptr_t)base - (((uintptr_t)&cpu_state) + 128);
 
         host_x86_MOV32_REG_BASE_OFFSET(block, REG_ECX, REG_ESP, IREG_TOP_diff_stack_offset);
-        host_x86_ADD32_REG_IMM(block, REG_ECX, REG_ECX, reg_idx);
-        host_x86_AND32_REG_IMM(block, REG_ECX, REG_ECX, 7);
+        host_x86_ADD32_REG_IMM(block, REG_ECX, reg_idx);
+        host_x86_AND32_REG_IMM(block, REG_ECX, 7);
         host_x86_MOVQ_ABS_REG_REG_SHIFT_XREG(block, offset, REG_EBP, REG_ECX, 3, host_reg);
 }
 void codegen_direct_write_st_double(codeblock_t *block, void *base, int reg_idx, int host_reg)
@@ -2849,8 +2856,8 @@ void codegen_direct_write_st_double(codeblock_t *block, void *base, int reg_idx,
         int offset = (uintptr_t)base - (((uintptr_t)&cpu_state) + 128);
 
         host_x86_MOV32_REG_BASE_OFFSET(block, REG_ECX, REG_ESP, IREG_TOP_diff_stack_offset);
-        host_x86_ADD32_REG_IMM(block, REG_ECX, REG_ECX, reg_idx);
-        host_x86_AND32_REG_IMM(block, REG_ECX, REG_ECX, 7);
+        host_x86_ADD32_REG_IMM(block, REG_ECX, reg_idx);
+        host_x86_AND32_REG_IMM(block, REG_ECX, 7);
         host_x86_MOVQ_ABS_REG_REG_SHIFT_XREG(block, offset, REG_EBP, REG_ECX, 3, host_reg);
 }