diff --git a/src/codegen_allocator.c b/src/codegen_allocator.c
index 4b4ffd7..5807b5d 100644
--- a/src/codegen_allocator.c
+++ b/src/codegen_allocator.c
@@ -1,6 +1,7 @@
 #if defined(__linux__) || defined(__APPLE__)
 #include <sys/mman.h>
 #include <unistd.h>
+#include <stdlib.h>
 #endif
 #if defined WIN32 || defined _WIN32 || defined _WIN32
 #include <windows.h>
diff --git a/src/codegen_backend_x86-64.c b/src/codegen_backend_x86-64.c
index 03cde31..a214b69 100644
--- a/src/codegen_backend_x86-64.c
+++ b/src/codegen_backend_x86-64.c
@@ -13,6 +13,7 @@
 #if defined(__linux__) || defined(__APPLE__)
 #include <sys/mman.h>
 #include <unistd.h>
+#include <stdlib.h>
 #endif
 #if defined WIN32 || defined _WIN32 || defined _WIN32
 #include <windows.h>
@@ -288,12 +289,6 @@ void codegen_backend_init()
 {
         codeblock_t *block;
         int c;
-#if defined(__linux__) || defined(__APPLE__)
-	void *start;
-	size_t len;
-	long pagesize = sysconf(_SC_PAGESIZE);
-	long pagemask = ~(pagesize - 1);
-#endif
 
         codeblock = malloc(BLOCK_SIZE * sizeof(codeblock_t));
         codeblock_hash = malloc(HASH_SIZE * sizeof(codeblock_t *));
@@ -322,7 +317,7 @@ void codegen_backend_init()
         host_x86_XOR32_REG_REG(block, REG_EDI, REG_EDI);
         host_x86_XOR32_REG_REG(block, REG_ESI, REG_ESI);
 #endif
-	host_x86_CALL(block, (uintptr_t)x86gpf);
+	host_x86_CALL(block, (void *)x86gpf);
         codegen_exit_rout = &codeblock[block_current].data[block_pos];
         host_x86_ADD64_REG_IMM(block, REG_RSP, 0x38);
         host_x86_POP(block, REG_R15);
diff --git a/src/codegen_backend_x86-64_uops.c b/src/codegen_backend_x86-64_uops.c
index 596f262..8b73909 100644
--- a/src/codegen_backend_x86-64_uops.c
+++ b/src/codegen_backend_x86-64_uops.c
@@ -195,9 +195,9 @@ static int codegen_CALL_FUNC(codeblock_t *block, uop_t *uop)
 static int codegen_CALL_FUNC_RESULT(codeblock_t *block, uop_t *uop)
 {
         int dest_reg = HOST_REG_GET(uop->dest_reg_a_real);
-        int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real);
 
 #ifdef RECOMPILER_DEBUG
+        int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real);
         if (!REG_IS_L(dest_size))
                 fatal("CALL_FUNC_RESULT %02x\n", uop->dest_reg_a_real);
 #endif
@@ -918,9 +918,9 @@ static int codegen_LOAD_FUNC_ARG3_IMM(codeblock_t *block, uop_t *uop)
 static int codegen_LOAD_SEG(codeblock_t *block, uop_t *uop)
 {
         int src_reg = HOST_REG_GET(uop->src_reg_a_real);
-        int src_size = IREG_GET_SIZE(uop->src_reg_a_real);
 
 #ifdef RECOMPILER_DEBUG
+        int src_size = IREG_GET_SIZE(uop->src_reg_a_real);
         if (!REG_IS_W(src_size))
                 fatal("LOAD_SEG %02x %p\n", uop->src_reg_a_real, uop->p);
 #endif
@@ -1029,9 +1029,9 @@ static int codegen_MEM_LOAD_REG(codeblock_t *block, uop_t *uop)
 static int codegen_MEM_LOAD_SINGLE(codeblock_t *block, uop_t *uop)
 {
         int dest_reg = HOST_REG_GET(uop->dest_reg_a_real), seg_reg = HOST_REG_GET(uop->src_reg_a_real), addr_reg = HOST_REG_GET(uop->src_reg_b_real);
-        int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real);
 
 #ifdef RECOMPILER_DEBUG
+        int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real);
         if (!REG_IS_D(dest_size))
                 fatal("MEM_LOAD_SINGLE - %02x\n", uop->dest_reg_a_real);
 #endif
@@ -1048,9 +1048,9 @@ static int codegen_MEM_LOAD_SINGLE(codeblock_t *block, uop_t *uop)
 static int codegen_MEM_LOAD_DOUBLE(codeblock_t *block, uop_t *uop)
 {
         int dest_reg = HOST_REG_GET(uop->dest_reg_a_real), seg_reg = HOST_REG_GET(uop->src_reg_a_real), addr_reg = HOST_REG_GET(uop->src_reg_b_real);
-        int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real);
 
 #ifdef RECOMPILER_DEBUG
+        int dest_size = IREG_GET_SIZE(uop->dest_reg_a_real);
         if (!REG_IS_D(dest_size))
                 fatal("MEM_LOAD_DOUBLE - %02x\n", uop->dest_reg_a_real);
 #endif
@@ -1174,9 +1174,9 @@ static int codegen_MEM_STORE_REG(codeblock_t *block, uop_t *uop)
 static int codegen_MEM_STORE_SINGLE(codeblock_t *block, uop_t *uop)
 {
         int seg_reg = HOST_REG_GET(uop->src_reg_a_real), addr_reg = HOST_REG_GET(uop->src_reg_b_real), src_reg = HOST_REG_GET(uop->src_reg_c_real);
-        int src_size = IREG_GET_SIZE(uop->src_reg_c_real);
 
 #ifdef RECOMPILER_DEBUG
+        int src_size = IREG_GET_SIZE(uop->src_reg_c_real);
         if (!REG_IS_D(src_size))
                 fatal("MEM_STORE_SINGLE - %02x\n", uop->src_reg_b_real);
 #endif
@@ -1193,9 +1193,9 @@ static int codegen_MEM_STORE_SINGLE(codeblock_t *block, uop_t *uop)
 static int codegen_MEM_STORE_DOUBLE(codeblock_t *block, uop_t *uop)
 {
         int seg_reg = HOST_REG_GET(uop->src_reg_a_real), addr_reg = HOST_REG_GET(uop->src_reg_b_real), src_reg = HOST_REG_GET(uop->src_reg_c_real);
-        int src_size = IREG_GET_SIZE(uop->src_reg_c_real);
 
 #ifdef RECOMPILER_DEBUG
+        int src_size = IREG_GET_SIZE(uop->src_reg_c_real);
         if (!REG_IS_D(src_size))
                 fatal("MEM_STORE_DOUBLE - %02x\n", uop->src_reg_b_real);
 #endif
@@ -1495,7 +1495,7 @@ 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_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))
@@ -2766,7 +2766,7 @@ 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)
@@ -2793,7 +2793,7 @@ 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))
diff --git a/src/codegen_reg.c b/src/codegen_reg.c
index e28068b..da6dd8c 100644
--- a/src/codegen_reg.c
+++ b/src/codegen_reg.c
@@ -274,7 +274,7 @@ static void codegen_reg_load(host_reg_set_t *reg_set, codeblock_t *block, int c,
                 if (ireg_data[IREG_GET_REG(ir_reg.reg)].type != REG_INTEGER)
                         fatal("codegen_reg_load - REG_WORD !REG_INTEGER\n");
                 if ((uintptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p < 256)
-                        codegen_direct_read_16_stack(block, reg_set->reg_list[c].reg, (int)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
+                        codegen_direct_read_16_stack(block, reg_set->reg_list[c].reg, (intptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 else
                         codegen_direct_read_16(block, reg_set->reg_list[c].reg, ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 break;
@@ -283,7 +283,7 @@ static void codegen_reg_load(host_reg_set_t *reg_set, codeblock_t *block, int c,
                 if (ireg_data[IREG_GET_REG(ir_reg.reg)].type != REG_INTEGER)
                         fatal("codegen_reg_load - REG_DWORD !REG_INTEGER\n");
                 if ((uintptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p < 256)
-                        codegen_direct_read_32_stack(block, reg_set->reg_list[c].reg, (int)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
+                        codegen_direct_read_32_stack(block, reg_set->reg_list[c].reg, (intptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 else
                         codegen_direct_read_32(block, reg_set->reg_list[c].reg, ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 break;
@@ -292,7 +292,7 @@ static void codegen_reg_load(host_reg_set_t *reg_set, codeblock_t *block, int c,
                 if (ireg_data[IREG_GET_REG(ir_reg.reg)].type != REG_FP)
                         fatal("codegen_reg_load - REG_QWORD !REG_FP\n");
                 if ((uintptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p < 256)
-                        codegen_direct_read_64_stack(block, reg_set->reg_list[c].reg, (int)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
+                        codegen_direct_read_64_stack(block, reg_set->reg_list[c].reg, (intptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 else
                         codegen_direct_read_64(block, reg_set->reg_list[c].reg, ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 break;
@@ -301,7 +301,7 @@ static void codegen_reg_load(host_reg_set_t *reg_set, codeblock_t *block, int c,
                 if (ireg_data[IREG_GET_REG(ir_reg.reg)].type != REG_INTEGER)
                         fatal("codegen_reg_load - REG_POINTER !REG_INTEGER\n");
                 if ((uintptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p < 256)
-                        codegen_direct_read_pointer_stack(block, reg_set->reg_list[c].reg, (int)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
+                        codegen_direct_read_pointer_stack(block, reg_set->reg_list[c].reg, (intptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 else
                         codegen_direct_read_pointer(block, reg_set->reg_list[c].reg, ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 break;
@@ -310,7 +310,7 @@ static void codegen_reg_load(host_reg_set_t *reg_set, codeblock_t *block, int c,
                 if (ireg_data[IREG_GET_REG(ir_reg.reg)].type != REG_FP)
                         fatal("codegen_reg_load - REG_DOUBLE !REG_FP\n");
                 if ((uintptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p < 256)
-                        codegen_direct_read_double_stack(block, reg_set->reg_list[c].reg, (int)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
+                        codegen_direct_read_double_stack(block, reg_set->reg_list[c].reg, (intptr_t)ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 else
                         codegen_direct_read_double(block, reg_set->reg_list[c].reg, ireg_data[IREG_GET_REG(ir_reg.reg)].p);
                 break;
@@ -382,7 +382,7 @@ static void codegen_reg_writeback(host_reg_set_t *reg_set, codeblock_t *block, i
                 if (ireg_data[ir_reg].type != REG_INTEGER)
                         fatal("codegen_reg_writeback - REG_DWORD !REG_INTEGER\n");
                 if ((uintptr_t)p < 256)
-                        codegen_direct_write_32_stack(block, (int)p, reg_set->reg_list[c].reg);
+                        codegen_direct_write_32_stack(block, (intptr_t)p, reg_set->reg_list[c].reg);
                 else
                         codegen_direct_write_32(block, p, reg_set->reg_list[c].reg);
                 break;
@@ -391,7 +391,7 @@ static void codegen_reg_writeback(host_reg_set_t *reg_set, codeblock_t *block, i
                 if (ireg_data[ir_reg].type != REG_FP)
                         fatal("codegen_reg_writeback - REG_QWORD !REG_FP\n");
                 if ((uintptr_t)p < 256)
-                        codegen_direct_write_64_stack(block, (int)p, reg_set->reg_list[c].reg);
+                        codegen_direct_write_64_stack(block, (intptr_t)p, reg_set->reg_list[c].reg);
                 else
                         codegen_direct_write_64(block, p, reg_set->reg_list[c].reg);
                 break;
@@ -408,7 +408,7 @@ static void codegen_reg_writeback(host_reg_set_t *reg_set, codeblock_t *block, i
                 if (ireg_data[ir_reg].type != REG_FP)
                         fatal("codegen_reg_writeback - REG_DOUBLE !REG_FP\n");
                 if ((uintptr_t)p < 256)
-                        codegen_direct_write_double_stack(block, (int)p, reg_set->reg_list[c].reg);
+                        codegen_direct_write_double_stack(block, (intptr_t)p, reg_set->reg_list[c].reg);
                 else
                         codegen_direct_write_double(block, p, reg_set->reg_list[c].reg);
                 break;