diff --git a/jit.h b/jit.h
index 16214802a..ba8079d9f 100644
--- a/jit.h
+++ b/jit.h
@@ -37,15 +37,19 @@ typedef float		jit_float32_t;
 typedef double		jit_float64_t;
 typedef void*		jit_pointer_t;
 typedef int		jit_bool_t;
-/* FIXME: Make the compiler warn when confusing GPR/FPR/immediate.  */
-typedef int		jit_gpr_t;
-typedef int		jit_fpr_t;
+typedef struct jit_gpr { int bits; } jit_gpr_t;
+typedef struct jit_fpr { int bits; } jit_fpr_t;
 
 typedef void*		jit_addr_t;
 typedef ptrdiff_t	jit_off_t;
 typedef intptr_t	jit_imm_t;
 typedef uintptr_t	jit_uimm_t;
 
+#define JIT_GPR(bits) ((jit_gpr_t) { bits })
+#define JIT_FPR(bits) ((jit_fpr_t) { bits })
+static inline jit_gpr_t jit_gpr(int bits) { return JIT_GPR(bits); }
+static inline jit_fpr_t jit_fpr(int bits) { return JIT_FPR(bits); }
+
 enum jit_reloc_kind
 {
   JIT_RELOC_ABSOLUTE,
@@ -91,9 +95,9 @@ typedef struct jit_reloc
 #  include "jit/alpha.h"
 #endif
 
-#define JIT_R(index)		jit_r(index)
-#define JIT_V(index)		jit_v(index)
-#define JIT_F(index)		jit_f(index)
+#define JIT_R(index)		JIT_GPR(jit_r(index))
+#define JIT_V(index)		JIT_GPR(jit_v(index))
+#define JIT_F(index)		JIT_FPR(jit_f(index))
 #define JIT_R_NUM		jit_r_num()
 #define JIT_V_NUM		jit_v_num()
 #define JIT_F_NUM		jit_f_num()
@@ -103,8 +107,8 @@ typedef struct jit_reloc
 #define jit_class_sav		0x10000000	/* callee save */
 #define jit_class_gpr		0x20000000	/* general purpose */
 #define jit_class_fpr		0x40000000	/* float */
-#define jit_class(reg)		((reg) & 0xffff0000)
-#define jit_regno(reg)		((reg) & 0x00007fff)
+#define jit_class(bits)		((bits) & 0xffff0000)
+#define jit_regno(bits)		((bits) & 0x00007fff)
 
 typedef struct jit_state	jit_state_t;
 enum jit_arg_loc
diff --git a/jit/jit.c b/jit/jit.c
index 586b9b1fe..666b1dfec 100644
--- a/jit/jit.c
+++ b/jit/jit.c
@@ -36,70 +36,70 @@
 #endif
 
 #define rc(value)               jit_class_##value
-#define rn(reg)                 (jit_regno(_rvs[jit_regno(reg)].spec))
+#define rn(reg)                 (jit_regno(_rvs[jit_regno(reg.bits)].spec))
 
 #if defined(__i386__) || defined(__x86_64__)
-# define JIT_SP         _RSP
-# define JIT_RET                _RAX
+# define JIT_SP         JIT_GPR(_RSP)
+# define JIT_RET                JIT_GPR(_RAX)
 # if __X32
-#  define JIT_FRET              _ST0
+#  define JIT_FRET              JIT_FPR(_ST0)
 # else
 #  if __CYGWIN__
-#   define JIT_RA0              _RCX
+#   define JIT_RA0              JIT_GPR(_RCX)
 #  else
-#   define JIT_RA0              _RDI
+#   define JIT_RA0              JIT_GPR(_RDI)
 #  endif
-#  define JIT_FA0               _XMM0
-#  define JIT_FRET              _XMM0
+#  define JIT_FA0               JIT_FPR(_XMM0)
+#  define JIT_FRET              JIT_FPR(_XMM0)
 # endif
 #elif defined(__mips__)
-# define JIT_RA0                _A0
-# define JIT_FA0                _F12
-# define JIT_SP         _SP
-# define JIT_RET                _V0
-# define JIT_FRET               _F0
+# define JIT_RA0                JIT_GPR(_A0)
+# define JIT_FA0                JIT_FPR(_F12)
+# define JIT_SP         JIT_GPR(_SP)
+# define JIT_RET                JIT_GPR(_V0)
+# define JIT_FRET               JIT_FPR(_F0)
 #elif defined(__arm__)
-# define JIT_RA0                _R0
-# define JIT_FA0                _D0
-# define JIT_SP         _R13
-# define JIT_RET                _R0
+# define JIT_RA0                JIT_GPR(_R0)
+# define JIT_FA0                JIT_FPR(_D0)
+# define JIT_SP         JIT_GPR(_R13)
+# define JIT_RET                JIT_GPR(_R0)
 # if defined(__ARM_PCS_VFP)
-#  define JIT_FRET              _D0
+#  define JIT_FRET              JIT_FPR(_D0)
 # else
-#  define JIT_FRET              _R0
+#  define JIT_FRET              JIT_FPR(_R0)
 # endif
 #elif defined(__ppc__) || defined(__powerpc__)
-# define JIT_RA0                _R3
-# define JIT_FA0                _F1
-# define JIT_SP         _R1
-# define JIT_RET                _R3
-# define JIT_FRET               _F1
+# define JIT_RA0                JIT_GPR(_R3)
+# define JIT_FA0                JIT_FPR(_F1)
+# define JIT_SP         JIT_GPR(_R1)
+# define JIT_RET                JIT_GPR(_R3)
+# define JIT_FRET               JIT_FPR(_F1)
 #elif defined(__sparc__)
-# define JIT_SP         _SP
-# define JIT_RET                _I0
-# define JIT_FRET               _F0
+# define JIT_SP         JIT_GPR(_SP)
+# define JIT_RET                JIT_GPR(_I0)
+# define JIT_FRET               JIT_FPR(_F0)
 #elif defined(__ia64__)
-# define JIT_SP         _R12
-# define JIT_RET                _R8
-# define JIT_FRET               _F8
+# define JIT_SP         JIT_GPR(_R12)
+# define JIT_RET                JIT_GPR(_R8)
+# define JIT_FRET               JIT_FPR(_F8)
 #elif defined(__hppa__)
-# define JIT_SP         _R30
-# define JIT_RET                _R28
-# define JIT_FRET               _F4
+# define JIT_SP         JIT_GPR(_R30)
+# define JIT_RET                JIT_GPR(_R28)
+# define JIT_FRET               JIT_FPR(_F4)
 #elif defined(__aarch64__)
-# define JIT_RA0                _R0
-# define JIT_FA0                _V0
-# define JIT_SP         _SP
-# define JIT_RET                _R0
-# define JIT_FRET               _V0
+# define JIT_RA0                JIT_GPR(_R0)
+# define JIT_FA0                JIT_FPR(_V0)
+# define JIT_SP         JIT_GPR(_SP)
+# define JIT_RET                JIT_GPR(_R0)
+# define JIT_FRET               JIT_FPR(_V0)
 #elif defined(__s390__) || defined(__s390x__)
-# define JIT_SP         _R15
-# define JIT_RET                _R2
-# define JIT_FRET               _F0
+# define JIT_SP         JIT_GPR(_R15)
+# define JIT_RET                JIT_GPR(_R2)
+# define JIT_FRET               JIT_FPR(_F0)
 #elif defined(__alpha__)
-# define JIT_SP         _SP
-# define JIT_RET                _V0
-# define JIT_FRET               _F0
+# define JIT_SP         JIT_GPR(_SP)
+# define JIT_RET                JIT_GPR(_V0)
+# define JIT_FRET               JIT_FPR(_F0)
 #endif
 
 /*
diff --git a/jit/x86-cpu.c b/jit/x86-cpu.c
index bffb74477..1c1da2b4f 100644
--- a/jit/x86-cpu.c
+++ b/jit/x86-cpu.c
@@ -272,9 +272,9 @@ get_temp_gpr(jit_state_t *_jit)
   _jit->temp_gpr_saved = 1;
 #if __X32
   pushr(_jit, _RBP_REGNO);
-  return _RBP;
+  return JIT_GPR(_RBP);
 #else
-  return _R8;
+  return JIT_GPR(_R8);
 #endif
 }
 
@@ -504,7 +504,7 @@ alui(jit_state_t *_jit, int32_t code, int32_t r0, jit_word_t i0)
       ii(_jit, i0);
     }
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     alur(_jit, code, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -709,7 +709,7 @@ addi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     movi(_jit, r0, i0);
     iaddr(_jit, r0, r1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     iaddr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -735,7 +735,7 @@ addci(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     iaddi(_jit, r0, i0);
   }
   else if (r0 == r1) {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     iaddr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -764,7 +764,7 @@ addxi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     iaddxi(_jit, r0, i0);
   }
   else if (r0 == r1) {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     iaddxr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -809,7 +809,7 @@ subi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     movi(_jit, r0, -i0);
     iaddr(_jit, r0, r1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     isubr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -820,7 +820,7 @@ static void
 subcr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
   if (r0 == r2 && r0 != r1) {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movr(_jit, rn(reg), r0);
     movr(_jit, r0, r1);
     isubr(_jit, r0, rn(reg));
@@ -838,7 +838,7 @@ subci(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   if (can_sign_extend_int_p(i0)) {
     isubi(_jit, r0, i0);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     isubr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -849,7 +849,7 @@ static void
 subxr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
   if (r0 == r2 && r0 != r1) {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movr(_jit, rn(reg), r0);
     movr(_jit, r0, r1);
     isubxr(_jit, r0, rn(reg));
@@ -867,7 +867,7 @@ subxi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   if (can_sign_extend_int_p(i0)) {
     isubxi(_jit, r0, i0);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     imovi(_jit, rn(reg), i0);
     isubxr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -887,7 +887,7 @@ rotshr(jit_state_t *_jit, int32_t code,
         int32_t r0, int32_t r1, int32_t r2)
 {
   if (r0 == _RCX_REGNO) {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movr(_jit, rn(reg), r1);
     if (r2 != _RCX_REGNO)
       movr(_jit, _RCX_REGNO, r2);
@@ -1004,7 +1004,7 @@ imuli(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
       ii(_jit, i0);
     }
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     imulr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1132,7 +1132,7 @@ iqmuli(jit_state_t *_jit, int32_t r0, int32_t r1,
     ixorr(_jit, r0, r0);
     ixorr(_jit, r1, r1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     if (sign)
       qmulr(_jit, r0, r1, r2, rn(reg));
@@ -1172,9 +1172,9 @@ divremr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2,
 
   int tmp_divisor = 0;
   if (r2 == _RAX_REGNO || r2 == _RDX_REGNO) {
-    int32_t tmp = get_temp_gpr(_jit);
-    movr(_jit, tmp, r2);
-    r2 = tmp;
+    jit_gpr_t tmp = get_temp_gpr(_jit);
+    movr(_jit, rn(tmp), r2);
+    r2 = rn(tmp);
     tmp_divisor = 1;
   }
 
@@ -1206,10 +1206,10 @@ static void
 divremi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0,
          jit_bool_t sign, jit_bool_t divide)
 {
-  int32_t r2 = get_temp_gpr(_jit);
-  movi(_jit, r2, i0);
+  jit_gpr_t tmp = get_temp_gpr(_jit);
+  movi(_jit, rn(tmp), i0);
 
-  divremr(_jit, r0, r1, r2, sign, divide);
+  divremr(_jit, r0, r1, rn(tmp), sign, divide);
 }
 
 static void
@@ -1272,9 +1272,9 @@ iqdivr(jit_state_t *_jit, int32_t r0, int32_t r1,
 
   int tmp_divisor = 0;
   if (r3 == _RAX_REGNO || r3 == _RDX_REGNO) {
-    int32_t tmp = get_temp_gpr(_jit);
-    movr(_jit, tmp, r3);
-    r3 = tmp;
+    jit_gpr_t tmp = get_temp_gpr(_jit);
+    movr(_jit, rn(tmp), r3);
+    r3 = rn(tmp);
     tmp_divisor = 1;
   }
 
@@ -1323,7 +1323,7 @@ static void
 iqdivi(jit_state_t *_jit, int32_t r0, int32_t r1,
        int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i0);
   if (sign)
     qdivr(_jit, r0, r1, r2, rn(reg));
@@ -1378,7 +1378,7 @@ andi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     if (can_sign_extend_int_p(i0)) {
       iandi(_jit, r0, i0);
     } else {
-      int32_t reg = get_temp_gpr(_jit);
+      jit_gpr_t reg = get_temp_gpr(_jit);
       movi(_jit, rn(reg), i0);
       iandr(_jit, r0, rn(reg));
       unget_temp_gpr(_jit);
@@ -1419,7 +1419,7 @@ ori(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     movi(_jit, r0, i0);
     iorr(_jit, r0, r1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     iorr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1456,7 +1456,7 @@ xori(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     movi(_jit, r0, i0);
     ixorr(_jit, r0, r1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ixorr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1475,7 +1475,7 @@ cr(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1, int32_t r2)
       imovi(_jit, r0, 0);
     cc(_jit, code, r0);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     ixorr(_jit, rn(reg), rn(reg));
     icmpr(_jit, r1, r2);
     cc(_jit, code, rn(reg));
@@ -1496,7 +1496,7 @@ ci(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1, jit_word_t i0)
       imovi(_jit, r0, 0);
     cc(_jit, code, r0);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     ixorr(_jit, rn(reg), rn(reg));
     icmpi(_jit, r1, i0);
     cc(_jit, code, rn(reg));
@@ -1517,7 +1517,7 @@ ci0(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1)
       imovi(_jit, r0, 0);
     cc(_jit, code, r0);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     ixorr(_jit, rn(reg), rn(reg));
     testr(_jit, r1, r1);
     cc(_jit, code, rn(reg));
@@ -1532,7 +1532,7 @@ extr_c(jit_state_t *_jit, int32_t r0, int32_t r1)
   if (reg8_p(r1)) {
     movcr(_jit, r0, r1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movr(_jit, rn(reg), r1);
     movcr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1545,7 +1545,7 @@ extr_uc(jit_state_t *_jit, int32_t r0, int32_t r1)
   if (reg8_p(r1)) {
     movcr_u(_jit, r0, r1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movr(_jit, rn(reg), r1);
     movcr_u(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1626,7 +1626,7 @@ ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     ic(_jit, 0xbe);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_c(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1651,7 +1651,7 @@ ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     ic(_jit, 0xb6);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_uc(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1676,7 +1676,7 @@ ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     ic(_jit, 0xbf);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_s(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1701,7 +1701,7 @@ ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     ic(_jit, 0xb7);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_us(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1733,7 +1733,7 @@ ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 #endif
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_i(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1758,7 +1758,7 @@ ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     ic(_jit, 0x63);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_ui(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1782,7 +1782,7 @@ ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     ic(_jit, 0x8b);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_l(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -1814,7 +1814,7 @@ ldxi_c(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     ic(_jit, 0xbe);
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldxr_c(_jit, r0, r1, rn(reg));
     unget_temp_gpr(_jit);
@@ -1844,7 +1844,7 @@ ldxi_uc(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     ic(_jit, 0xb6);
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldxr_uc(_jit, r0, r1, rn(reg));
     unget_temp_gpr(_jit);
@@ -1874,7 +1874,7 @@ ldxi_s(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     ic(_jit, 0xbf);
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldxr_s(_jit, r0, r1, rn(reg));
     unget_temp_gpr(_jit);
@@ -1904,7 +1904,7 @@ ldxi_us(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     ic(_jit, 0xb7);
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldxr_us(_jit, r0, r1, rn(reg));
     unget_temp_gpr(_jit);
@@ -1936,7 +1936,7 @@ ldxi_i(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
 #endif
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldxr_i(_jit, r0, r1, rn(reg));
     unget_temp_gpr(_jit);
@@ -1967,7 +1967,7 @@ ldxi_ui(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     ic(_jit, 0x8b);
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldxr_ui(_jit, r0, r1, rn(reg));
     unget_temp_gpr(_jit);
@@ -1991,7 +1991,7 @@ ldxi_l(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     ic(_jit, 0x8b);
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldxr_l(_jit, r0, r1, rn(reg));
     unget_temp_gpr(_jit);
@@ -2008,7 +2008,7 @@ str_c(jit_state_t *_jit, int32_t r0, int32_t r1)
     ic(_jit, 0x88);
     rx(_jit, r1, 0, r0, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movr(_jit, rn(reg), r1);
     rex(_jit, 0, 0, rn(reg), _NOREG, r0);
     ic(_jit, 0x88);
@@ -2026,7 +2026,7 @@ sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
       ic(_jit, 0x88);
       rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
     } else {
-      int32_t reg = get_temp_gpr(_jit);
+      jit_gpr_t reg = get_temp_gpr(_jit);
       movr(_jit, rn(reg), r0);
       rex(_jit, 0, 0, rn(reg), _NOREG, _NOREG);
       ic(_jit, 0x88);
@@ -2034,7 +2034,7 @@ sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
       unget_temp_gpr(_jit);
     }
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     str_c(_jit, rn(reg), r0);
     unget_temp_gpr(_jit);
@@ -2059,7 +2059,7 @@ sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
     ic(_jit, 0x89);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     str_s(_jit, rn(reg), r0);
     unget_temp_gpr(_jit);
@@ -2082,7 +2082,7 @@ sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
     ic(_jit, 0x89);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     str_i(_jit, rn(reg), r0);
     unget_temp_gpr(_jit);
@@ -2106,7 +2106,7 @@ sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
     ic(_jit, 0x89);
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     str_l(_jit, rn(reg), r0);
     unget_temp_gpr(_jit);
@@ -2118,7 +2118,7 @@ static void
 stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   addr(_jit, rn(reg), r0, r1);
   str_c(_jit, rn(reg), r2);
   unget_temp_gpr(_jit);
@@ -2128,7 +2128,7 @@ stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
     ic(_jit, 0x88);
     rx(_jit, r2, 0, r0, r1, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movr(_jit, rn(reg), r2);
     rex(_jit, 0, 0, rn(reg), r1, r0);
     ic(_jit, 0x88);
@@ -2147,7 +2147,7 @@ stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
       ic(_jit, 0x88);
       rx(_jit, r1, i0, r0, _NOREG, _SCL1);
     } else {
-      int32_t reg = get_temp_gpr(_jit);
+      jit_gpr_t reg = get_temp_gpr(_jit);
       movr(_jit, rn(reg), r1);
       rex(_jit, 0, 0, rn(reg), _NOREG, r0);
       ic(_jit, 0x88);
@@ -2155,7 +2155,7 @@ stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
       unget_temp_gpr(_jit);
     }
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     stxr_c(_jit, rn(reg), r0, r1);
     unget_temp_gpr(_jit);
@@ -2166,7 +2166,7 @@ static void
 stxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   addr(_jit, rn(reg), r0, r1);
   str_s(_jit, rn(reg), r2);
   unget_temp_gpr(_jit);
@@ -2187,7 +2187,7 @@ stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
     ic(_jit, 0x89);
     rx(_jit, r1, i0, r0, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     stxr_s(_jit, rn(reg), r0, r1);
     unget_temp_gpr(_jit);
@@ -2198,7 +2198,7 @@ static void
 stxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   addr(_jit, rn(reg), r0, r1);
   str_i(rn(reg), r2);
   unget_temp_gpr(_jit);
@@ -2217,7 +2217,7 @@ stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
     ic(_jit, 0x89);
     rx(_jit, r1, i0, r0, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     stxr_i(_jit, rn(reg), r0, r1);
     unget_temp_gpr(_jit);
@@ -2241,7 +2241,7 @@ stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
     ic(_jit, 0x89);
     rx(_jit, r1, i0, r0, _NOREG, _SCL1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     stxr_l(_jit, rn(reg), r0, r1);
     unget_temp_gpr(_jit);
@@ -2438,7 +2438,7 @@ bmsi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
   if (can_zero_extend_int_p(i1)) {
     testi(_jit, r0, i1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i1);
     testr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -2459,7 +2459,7 @@ bmci(jit_state_t *_jit, int32_t r0, jit_word_t i1)
   if (can_zero_extend_int_p(i1)) {
     testi(_jit, r0, i1);
   } else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i1);
     testr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -2481,7 +2481,7 @@ boaddi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     iaddi(_jit, r0, i1);
     return jo(_jit);
   }
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i1);
   unget_temp_gpr(_jit);
   return boaddr(_jit, r0, rn(reg));
@@ -2501,7 +2501,7 @@ boaddi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     iaddi(_jit, r0, i1);
     return jc(_jit);
   }
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i1);
   unget_temp_gpr(_jit);
   return boaddr_u(_jit, r0, rn(reg));
@@ -2521,7 +2521,7 @@ bxaddi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     iaddi(_jit, r0, i1);
     return jno(_jit);
   }
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i1);
   unget_temp_gpr(_jit);
   return bxaddr(_jit, r0, rn(reg));
@@ -2541,7 +2541,7 @@ bxaddi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     iaddi(_jit, r0, i1);
     return jnc(_jit);
   }
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i1);
   unget_temp_gpr(_jit);
   return bxaddr_u(_jit, r0, rn(reg));
@@ -2561,7 +2561,7 @@ bosubi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     isubi(_jit, r0, i1);
     return jo(_jit);
   }
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i1);
   unget_temp_gpr(_jit);
   return bosubr(_jit, r0, rn(reg));
@@ -2581,7 +2581,7 @@ bosubi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     isubi(_jit, r0, i1);
     return jc(_jit);
   }
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i1);
   unget_temp_gpr(_jit);
   return bosubr_u(_jit, r0, rn(reg));
@@ -2601,7 +2601,7 @@ bxsubi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     isubi(_jit, r0, i1);
     return jno(_jit);
   }
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i1);
   unget_temp_gpr(_jit);
   return bxsubr(_jit, r0, rn(reg));
@@ -2621,7 +2621,7 @@ bxsubi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     isubi(_jit, r0, i1);
     return jnc(_jit);
   }
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   movi(_jit, rn(reg), i1);
   unget_temp_gpr(_jit);
   return bxsubr_u(_jit, r0, rn(reg));
@@ -2646,7 +2646,7 @@ calli(jit_state_t *_jit, jit_word_t i0)
     }
   else
     {
-      int32_t reg = get_temp_gpr(_jit);
+      jit_gpr_t reg = get_temp_gpr(_jit);
       jit_patch_there(_jit, mov_addr(_jit, rn(reg)), (void*)i0);
       callr(_jit, rn(reg));
       unget_temp_gpr(_jit);
@@ -2672,7 +2672,7 @@ jmpi(jit_state_t *_jit, jit_word_t i0)
     }
   else
     {
-      int32_t reg = get_temp_gpr(_jit);
+      jit_gpr_t reg = get_temp_gpr(_jit);
       jit_patch_there(_jit, mov_addr(_jit, rn(reg)), (void*)i0);
       jmpr(_jit, rn(reg));
       unget_temp_gpr(_jit);
diff --git a/jit/x86-sse.c b/jit/x86-sse.c
index 1a277304d..44d990545 100644
--- a/jit/x86-sse.c
+++ b/jit/x86-sse.c
@@ -181,7 +181,7 @@ pushr_d(jit_state_t *_jit, int32_t r0)
 static void
 popr_d(jit_state_t *_jit, int32_t r0)
 {
-  int32_t tmp = get_temp_gpr(_jit);
+  jit_gpr_t tmp = get_temp_gpr(_jit);
   popr(_jit, rn(tmp));
   ssexr(_jit, 0x66, X86_SSE_G2X, r0, rn(tmp));
   unget_temp_gpr(_jit);
@@ -193,7 +193,7 @@ get_temp_xpr(jit_state_t *_jit)
   /* Reserve XMM7 for the JIT.  */
   ASSERT(!_jit->temp_fpr_saved);
   _jit->temp_fpr_saved = 1;
-  return _XMM7;
+  return JIT_FPR(_XMM7);
 }
 
 static void
@@ -379,7 +379,7 @@ movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t i0)
   if (data.f == 0.0 && !(data.i & 0x80000000))
     xorpsr(_jit, r0, r0);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), data.i);
     movdlxr(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -399,7 +399,7 @@ movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t i0)
   if (data.d == 0.0 && !(data.ii[1] & 0x80000000))
     xorpdr(_jit, r0, r0);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64 && !__X64_32
     movi(_jit, rn(reg), data.w);
     movdqxr(_jit, r0, rn(reg));
@@ -477,7 +477,7 @@ subr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
   if (r0 == r1)
     subssr(_jit, r0, r2);
   else if (r0 == r2) {
-    int32_t reg = get_temp_xpr(_jit);
+    jit_fpr_t reg = get_temp_xpr(_jit);
     movr_f(_jit, rn(reg), r0);
     movr_f(_jit, r0, r1);
     subssr(_jit, r0, rn(reg));
@@ -495,7 +495,7 @@ subr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
   if (r0 == r1)
     subsdr(_jit, r0, r2);
   else if (r0 == r2) {
-    int32_t reg = get_temp_xpr(_jit);
+    jit_fpr_t reg = get_temp_xpr(_jit);
     movr_d(_jit, rn(reg), r0);
     movr_d(_jit, r0, r1);
     subsdr(_jit, r0, rn(reg));
@@ -539,7 +539,7 @@ divr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
   if (r0 == r1)
     divssr(_jit, r0, r2);
   else if (r0 == r2) {
-    int32_t reg = get_temp_xpr(_jit);
+    jit_fpr_t reg = get_temp_xpr(_jit);
     movr_f(_jit, rn(reg), r0);
     movr_f(_jit, r0, r1);
     divssr(_jit, r0, rn(reg));
@@ -557,7 +557,7 @@ divr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
   if (r0 == r1)
     divsdr(_jit, r0, r2);
   else if (r0 == r2) {
-    int32_t reg = get_temp_xpr(_jit);
+    jit_fpr_t reg = get_temp_xpr(_jit);
     movr_d(_jit, rn(reg), r0);
     movr_d(_jit, r0, r1);
     divsdr(_jit, r0, rn(reg));
@@ -573,7 +573,7 @@ static void
 absr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
   if (r0 == r1) {
-    int32_t reg = get_temp_xpr(_jit);
+    jit_fpr_t reg = get_temp_xpr(_jit);
     pcmpeqlr(_jit, rn(reg), rn(reg));
     psrl(_jit, rn(reg), 1);
     andpsr(_jit, r0, rn(reg));
@@ -590,7 +590,7 @@ static void
 absr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
   if (r0 == r1) {
-    int32_t reg = get_temp_xpr(_jit);
+    jit_fpr_t reg = get_temp_xpr(_jit);
     pcmpeqlr(_jit, rn(reg), rn(reg));
     psrq(_jit, rn(reg), 1);
     andpdr(_jit, r0, rn(reg));
@@ -606,10 +606,10 @@ absr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
 static void
 negr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
-  int32_t ireg = get_temp_gpr(_jit);
+  jit_gpr_t ireg = get_temp_gpr(_jit);
   imovi(_jit, rn(ireg), 0x80000000);
   if (r0 == r1) {
-    int32_t freg = get_temp_xpr(_jit);
+    jit_fpr_t freg = get_temp_xpr(_jit);
     movdlxr(_jit, rn(freg), rn(ireg));
     xorpsr(_jit, r0, rn(freg));
     unget_temp_xpr(_jit);
@@ -623,10 +623,10 @@ negr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
 static void
 negr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
-  int32_t ireg = get_temp_gpr(_jit);
+  jit_gpr_t ireg = get_temp_gpr(_jit);
   imovi(_jit, rn(ireg), 0x80000000);
   if (r0 == r1) {
-    int32_t freg = get_temp_xpr(_jit);
+    jit_fpr_t freg = get_temp_xpr(_jit);
     movdlxr(_jit, rn(freg), rn(ireg));
     pslq(_jit, rn(freg), 32);
     xorpdr(_jit, r0, rn(freg));
@@ -653,7 +653,7 @@ ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
   if (sse_address_p(i0))
     movssmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_f(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -664,7 +664,7 @@ static void
 ldxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   addr(_jit, rn(reg), r1, r2);
   ldr_f(_jit, r0, rn(reg));
   unget_temp_gpr(_jit);
@@ -679,7 +679,7 @@ ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   if (can_sign_extend_int_p(i0))
     movssmr(_jit, i0, r1, _NOREG, _SCL1, r0);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64_32
     addi(rn(reg), r1, i0);
     ldr_f(_jit, r0, rn(reg));
@@ -697,7 +697,7 @@ sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
   if (sse_address_p(i0))
     movssrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     str_f(_jit, rn(reg), r0);
     unget_temp_gpr(_jit);
@@ -708,7 +708,7 @@ static void
 stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   addr(_jit, rn(reg), r0, r1);
   str_f(_jit, rn(reg), r2);
   unget_temp_gpr(_jit);
@@ -723,7 +723,7 @@ stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
   if (can_sign_extend_int_p(i0))
     movssrm(_jit, r1, i0, r0, _NOREG, _SCL1);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64_32
     addi(rn(reg), r0, i0);
     str_f(_jit, rn(reg), r1);
@@ -847,7 +847,7 @@ ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
   if (sse_address_p(i0))
     movsdmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     ldr_d(_jit, r0, rn(reg));
     unget_temp_gpr(_jit);
@@ -858,7 +858,7 @@ static void
 ldxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   addr(_jit, rn(reg), r1, r2);
   ldr_d(_jit, r0, rn(reg));
   unget_temp_gpr(_jit);
@@ -873,7 +873,7 @@ ldxi_d(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   if (can_sign_extend_int_p(i0))
     movsdmr(_jit, i0, r1, _NOREG, _SCL1, r0);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64_32
     addi(rn(reg), r1, i0);
     ldr_d(_jit, r0, rn(reg));
@@ -891,7 +891,7 @@ sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
   if (sse_address_p(i0))
     movsdrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
     movi(_jit, rn(reg), i0);
     str_d(_jit, rn(reg), r0);
     unget_temp_gpr(_jit);
@@ -902,7 +902,7 @@ static void
 stxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
-  int32_t reg = get_temp_gpr(_jit);
+  jit_gpr_t reg = get_temp_gpr(_jit);
   addr(_jit, rn(reg), r0, r1);
   str_d(_jit, rn(reg), r2);
   unget_temp_gpr(_jit);
@@ -917,7 +917,7 @@ stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
   if (can_sign_extend_int_p(i0))
     movsdrm(_jit, r1, i0, r0, _NOREG, _SCL1);
   else {
-    int32_t reg = get_temp_gpr(_jit);
+    jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64_32
     addi(rn(reg), r0, i0);
     str_d(_jit, rn(reg), r1);
diff --git a/jit/x86.c b/jit/x86.c
index 9999f8711..d965afe9c 100644
--- a/jit/x86.c
+++ b/jit/x86.c
@@ -376,23 +376,23 @@ is_gpr_arg(jit_arg_abi_t arg)
   return !is_fpr_arg(arg);
 }
 
-static const jit_reg_t abi_gpr_args[] = {
+static const jit_gpr_t abi_gpr_args[] = {
 #if __X32
   /* No GPRs in args.  */
 #elif __CYGWIN__
-  _RCX, _RDX, _R8, _R9
+  JIT_GPR(_RCX), JIT_GPR(_RDX), JIT_GPR(_R8), JIT_GPR(_R9)
 #else
-  _RDI, _RSI, _RDX, _RCX, _R8, _R9
+  JIT_GPR(_RDI), JIT_GPR(_RSI), JIT_GPR(_RDX), JIT_GPR(_RCX), JIT_GPR(_R8), JIT_GPR(_R9)
 #endif
 };
 
-static const jit_reg_t abi_fpr_args[] = {
+static const jit_fpr_t abi_fpr_args[] = {
 #if __X32
   /* No FPRs in args.  */
 #elif __CYGWIN__
-  _XMM0, _XMM1, _XMM2, _XMM3
+  JIT_FPR(_XMM0), JIT_FPR(_XMM1), JIT_FPR(_XMM2), JIT_FPR(_XMM3)
 #else
-  _XMM0, _XMM1, _XMM2, _XMM3, _XMM4, _XMM5, _XMM6, _XMM7
+  JIT_FPR(_XMM0), JIT_FPR(_XMM1), JIT_FPR(_XMM2), JIT_FPR(_XMM3), JIT_FPR(_XMM4), JIT_FPR(_XMM5), JIT_FPR(_XMM6), JIT_FPR(_XMM7)
 #endif
 };
 
@@ -583,13 +583,13 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
 {
   ASSERT(args[idx].kind == JIT_ARG_LOC_GPR);
 
-  if (args[idx].loc.gpr == dst)
+  if (rn(args[idx].loc.gpr) == rn(dst))
     return;
 
   /* Arg in a reg but it's not the right one.  See if this reg
      holds some other arg, and swap if so.  */
   for (size_t j=idx+1; j<argc; j++)
-    if (args[j].kind == JIT_ARG_LOC_GPR && args[j].loc.gpr == dst)
+    if (args[j].kind == JIT_ARG_LOC_GPR && rn(args[j].loc.gpr) == rn(dst))
       {
         xchgr(_jit, rn(args[idx].loc.gpr), rn(dst));
         args[j].loc.gpr = args[idx].loc.gpr;
@@ -597,7 +597,7 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
         /* Could be this register holds a value for more than one argument;
            update subsequent args if any.  */
         for (size_t k=j+1; k<argc; k++)
-          if (args[k].kind == JIT_ARG_LOC_GPR && args[k].loc.gpr == dst)
+          if (args[k].kind == JIT_ARG_LOC_GPR && rn(args[k].loc.gpr) == rn(dst))
             args[k].loc.gpr = args[j].loc.gpr;
         return;
       }
@@ -614,13 +614,13 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
 {
   ASSERT(args[idx].kind == JIT_ARG_LOC_FPR);
 
-  if (args[idx].loc.fpr == dst)
+  if (rn(args[idx].loc.fpr) == rn(dst))
     return;
 
   /* Arg in a reg but it's not the right one.  See if this reg
      holds some other arg, and swap if so.  */
   for (size_t j=idx+1; j<argc; j++)
-    if (args[j].kind == JIT_ARG_LOC_FPR && args[j].loc.fpr == dst)
+    if (args[j].kind == JIT_ARG_LOC_FPR && rn(args[j].loc.fpr) == rn(dst))
       {
         jit_fpr_t tmp = get_temp_xpr(_jit);
         jit_movr_d (_jit, tmp, args[idx].loc.fpr);
@@ -632,7 +632,7 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
         /* Could be this register holds a value for more than one argument;
            update subsequent args if any.  */
         for (size_t k=j+1; k<argc; k++)
-          if (args[k].kind == JIT_ARG_LOC_FPR && args[k].loc.fpr == dst)
+          if (args[k].kind == JIT_ARG_LOC_FPR && rn(args[k].loc.fpr) == rn(dst))
             args[k].loc.fpr = args[j].loc.fpr;
         return;
       }
@@ -750,7 +750,7 @@ jit_callr(jit_state_t *_jit, jit_gpr_t f,
 {
   prepare_args(_jit, argc, abi, args);
 
-  callr(_jit, f);
+  callr(_jit, rn(f));
 }
 
 void
@@ -769,123 +769,34 @@ jit_load_args(jit_state_t *_jit, size_t argc,
               const jit_arg_abi_t abi[], jit_arg_t args[],
               const jit_anyreg_t regs[])
 {
-  /* First shuffle the arguments in registers into position.  */
+  /* First shuffle any arguments that are already in registers into
+     position.  */
   for (size_t i = 0; i < argc; i++) {
-    const jit_arg_t arg = args[i];
-    const jit_anyreg_t reg = regs[i];
-    switch (arg.kind) {
+    switch (args[i].kind) {
     case JIT_ARG_LOC_IMM:
       abort();
     case JIT_ARG_LOC_GPR:
-      {
-        if (arg.loc.gpr != reg.gpr)
-          /* Arg in a reg but it's not the right one.  See if this reg
-             holds some other arg, and swap if so.  */
-          for (size_t j=i+1; j<argc; j++)
-            if (args[j].kind == JIT_ARG_LOC_GPR && args[j].loc.gpr == reg.gpr)
-              {
-                xchgr(_jit, rn(arg.loc.gpr), rn(reg.gpr));
-                args[j].loc.gpr = arg.loc.gpr;
-                args[i].loc.gpr = reg.gpr;
-                break;
-              }
-        if (arg.loc.gpr != reg.gpr)
-          /* Arg in reg, but it's not the right one, and the desired reg
-             is free.  */
-          {
-            movr(_jit, rn(reg.gpr), rn(arg.loc.gpr));
-            args[i].loc.gpr = reg.gpr;
-          }
-      }
+      shuffle_gpr_arg(_jit, regs[i].gpr, argc, args, i);
       break;
     case JIT_ARG_LOC_FPR:
-      {
-        if (arg.loc.fpr != reg.fpr)
-          /* Arg in a reg but it's not the right one.  See if this reg
-             holds some other arg, and swap if so.  */
-          for (size_t j=i+1; j<argc; j++)
-            if (args[j].kind == JIT_ARG_LOC_FPR && args[j].loc.fpr == reg.fpr)
-              {
-                jit_fpr_t tmp = get_temp_xpr(_jit);
-                movr_d (_jit, tmp, rn(arg.loc.fpr));
-                movr_d (_jit, rn(arg.loc.fpr), rn(reg.fpr));
-                movr_d (_jit, rn(reg.fpr), tmp);
-                unget_temp_xpr(_jit);
-                args[j].loc.fpr = arg.loc.fpr;
-                args[i].loc.fpr = reg.fpr;
-                break;
-              }
-        if (arg.loc.fpr != reg.fpr)
-          /* Arg in reg, but it's not the right one, and the desired reg
-             is free.  */
-          {
-            movr_d(_jit, rn(reg.fpr), rn(arg.loc.fpr));
-            args[i].loc.fpr = reg.fpr;
-          }
-      }
+      shuffle_fpr_arg(_jit, regs[i].fpr, argc, args, i);
       break;
     case JIT_ARG_LOC_MEM:
-      /* Load spilled arguments once we're done with registers.  */
       break;
     default:
       abort();
     }
   }
 
-  /* Load spilled arguments from memory into registers.  */
+  /* Now load spilled arguments from memory into registers.  */
   for (size_t i = 0; i < argc; i++) {
-    const jit_arg_t arg = args[i];
-    const jit_anyreg_t reg = regs[i];
-    switch (arg.kind) {
-    case JIT_ARG_LOC_IMM:
-      abort();
-    case JIT_ARG_LOC_GPR:
-    case JIT_ARG_LOC_FPR:
-      break;
-    case JIT_ARG_LOC_MEM:
-      {
-        jit_gpr_t base = arg.loc.mem.base;
-        ptrdiff_t offset = arg.loc.mem.offset;
-        switch (abi[i]) {
-        case JIT_ARG_ABI_UINT8:
-          jit_ldxi_uc(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_INT8:
-          jit_ldxi_c(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_UINT16:
-          jit_ldxi_us(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_INT16:
-          jit_ldxi_s(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_UINT32:
-          jit_ldxi_ui(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_INT32:
-          jit_ldxi_i(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_UINT64:
-          jit_ldxi_l(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_INT64:
-          jit_ldxi_l(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_POINTER:
-          jit_ldxi_l(_jit, reg.gpr, base, offset);
-          break;
-        case JIT_ARG_ABI_FLOAT:
-          jit_ldxi_f(_jit, reg.fpr, base, offset);
-          break;
-        case JIT_ARG_ABI_DOUBLE:
-          jit_ldxi_d(_jit, reg.fpr, base, offset);
-          break;
-        default:
-          abort();
-        }
-      }
-    default:
-      abort();
+    if (args[i].kind == JIT_ARG_LOC_MEM) {
+      if (is_gpr_arg(abi[i]))
+        abi_mem_to_gpr(_jit, abi[i], regs[i].gpr, args[i].loc.mem.base,
+                       args[i].loc.mem.offset);
+      else
+        abi_mem_to_fpr(_jit, abi[i], regs[i].fpr, args[i].loc.mem.base,
+                       args[i].loc.mem.offset);
     }
   }
 }
diff --git a/jit/x86.h b/jit/x86.h
index 89e341da4..b275e5e8b 100644
--- a/jit/x86.h
+++ b/jit/x86.h
@@ -44,7 +44,7 @@
 #  define __X32    0
 #endif
 
-#define JIT_FP                  _RBP
+#define JIT_FP                  JIT_GPR(_RBP)
 typedef enum {
 #if __X32
 #  define jit_r(i)              (_RAX + (i))
@@ -53,22 +53,22 @@ typedef enum {
 #  define jit_v_num()           3
 #  define jit_f(i)              (jit_cpu.sse2 ? _XMM0 + (i) : _ST0 + (i))
 #  define jit_f_num()           (jit_cpu.sse2 ? 8 : 6)
-#  define JIT_R0                _RAX
-#  define JIT_R1                _RCX
-#  define JIT_R2                _RDX
+#  define JIT_R0                JIT_GPR(_RAX)
+#  define JIT_R1                JIT_GPR(_RCX)
+#  define JIT_R2                JIT_GPR(_RDX)
   _RAX, _RCX, _RDX,
-#  define JIT_V0                _RBX
-#  define JIT_V1                _RSI
-#  define JIT_V2                _RDI
+#  define JIT_V0                JIT_GPR(_RBX)
+#  define JIT_V1                JIT_GPR(_RSI)
+#  define JIT_V2                JIT_GPR(_RDI)
   _RBX, _RSI, _RDI,
   _RSP, _RBP,
-#  define JIT_F0                _XMM0
-#  define JIT_F1                _XMM1
-#  define JIT_F2                _XMM2
-#  define JIT_F3                _XMM3
-#  define JIT_F4                _XMM4
-#  define JIT_F5                _XMM5
-#  define JIT_F6                _XMM6
+#  define JIT_F0                JIT_FPR(_XMM0)
+#  define JIT_F1                JIT_FPR(_XMM1)
+#  define JIT_F2                JIT_FPR(_XMM2)
+#  define JIT_F3                JIT_FPR(_XMM3)
+#  define JIT_F4                JIT_FPR(_XMM4)
+#  define JIT_F5                JIT_FPR(_XMM5)
+#  define JIT_F6                JIT_FPR(_XMM6)
   _XMM0, _XMM1, _XMM2, _XMM3, _XMM4, _XMM5, _XMM6, _XMM7,
 #  define jit_sse_reg_p(reg)    ((reg) >= _XMM0 && (reg) <= _XMM7)
 #else
@@ -79,16 +79,16 @@ typedef enum {
 #    define jit_v_num()         7
 #    define jit_f(index)        (_XMM4 + (index))
 #    define jit_f_num()         12
-#    define JIT_R0              _RAX
-#    define JIT_R1              _R10
-#    define JIT_R2              _R11
-#    define JIT_V0              _RBX
-#    define JIT_V1              _RDI
-#    define JIT_V2              _RSI
-#    define JIT_V3              _R12
-#    define JIT_V4              _R13
-#    define JIT_V5              _R14
-#    define JIT_V6              _R15
+#    define JIT_R0              JIT_GPR(_RAX)
+#    define JIT_R1              JIT_GPR(_R10)
+#    define JIT_R2              JIT_GPR(_R11)
+#    define JIT_V0              JIT_GPR(_RBX)
+#    define JIT_V1              JIT_GPR(_RDI)
+#    define JIT_V2              JIT_GPR(_RSI)
+#    define JIT_V3              JIT_GPR(_R12)
+#    define JIT_V4              JIT_GPR(_R13)
+#    define JIT_V5              JIT_GPR(_R14)
+#    define JIT_V6              JIT_GPR(_R15)
   /* Volatile - Return value register */
   _RAX,
   /* Volatile */
@@ -100,22 +100,22 @@ typedef enum {
   _R9, _R8, _RDX, _RCX,
   /* Nonvolatile */
   _RSP, _RBP,
-#    define JIT_F0              _XMM0
-#    define JIT_F1              _XMM1
-#    define JIT_F2              _XMM2
-#    define JIT_F3              _XMM3
-#    define JIT_F4              _XMM4
-#    define JIT_F5              _XMM5
-#    define JIT_F6              _XMM6
-#    define JIT_F7              _XMM7
-#    define JIT_F8              _XMM8
-#    define JIT_F9              _XMM9
-#    define JIT_F10             _XMM10
-#    define JIT_F11             _XMM11
-#    define JIT_F12             _XMM12
-#    define JIT_F13             _XMM13
-#    define JIT_F14             _XMM14
-#    define JIT_F15             _XMM15
+#    define JIT_F0              JIT_FPR(_XMM0)
+#    define JIT_F1              JIT_FPR(_XMM1)
+#    define JIT_F2              JIT_FPR(_XMM2)
+#    define JIT_F3              JIT_FPR(_XMM3)
+#    define JIT_F4              JIT_FPR(_XMM4)
+#    define JIT_F5              JIT_FPR(_XMM5)
+#    define JIT_F6              JIT_FPR(_XMM6)
+#    define JIT_F7              JIT_FPR(_XMM7)
+#    define JIT_F8              JIT_FPR(_XMM8)
+#    define JIT_F9              JIT_FPR(_XMM9)
+#    define JIT_F10             JIT_FPR(_XMM10)
+#    define JIT_F11             JIT_FPR(_XMM11)
+#    define JIT_F12             JIT_FPR(_XMM12)
+#    define JIT_F13             JIT_FPR(_XMM13)
+#    define JIT_F14             JIT_FPR(_XMM14)
+#    define JIT_F15             JIT_FPR(_XMM15)
   /* Volatile */
   _XMM4, _XMM5,
   /* Nonvolatile */
@@ -131,34 +131,34 @@ typedef enum {
 #    define jit_v_num()         4
 #    define jit_f(index)        (_XMM8 + (index))
 #    define jit_f_num()         8
-#    define JIT_R0              _RAX
-#    define JIT_R1              _R10
-#    define JIT_R2              _R11
-#    define JIT_R3              _R12
+#    define JIT_R0              JIT_GPR(_RAX)
+#    define JIT_R1              JIT_GPR(_R10)
+#    define JIT_R2              JIT_GPR(_R11)
+#    define JIT_R3              JIT_GPR(_R12)
   _RAX, _R10, _R11, _R12,
-#    define JIT_V0              _RBX
-#    define JIT_V1              _R13
-#    define JIT_V2              _R14
-#    define JIT_V3              _R15
+#    define JIT_V0              JIT_GPR(_RBX)
+#    define JIT_V1              JIT_GPR(_R13)
+#    define JIT_V2              JIT_GPR(_R14)
+#    define JIT_V3              JIT_GPR(_R15)
   _RBX, _R13, _R14, _R15,
   _R9, _R8, _RCX, _RDX, _RSI, _RDI,
   _RSP, _RBP,
-#    define JIT_F0              _XMM0
-#    define JIT_F1              _XMM1
-#    define JIT_F2              _XMM2
-#    define JIT_F3              _XMM3
-#    define JIT_F4              _XMM4
-#    define JIT_F5              _XMM5
-#    define JIT_F6              _XMM6
-#    define JIT_F7              _XMM7
-#    define JIT_F8              _XMM8
-#    define JIT_F9              _XMM9
-#    define JIT_F10             _XMM10
-#    define JIT_F11             _XMM11
-#    define JIT_F12             _XMM12
-#    define JIT_F13             _XMM13
-#    define JIT_F14             _XMM14
-#    define JIT_F15             _XMM15
+#    define JIT_F0              JIT_FPR(_XMM0)
+#    define JIT_F1              JIT_FPR(_XMM1)
+#    define JIT_F2              JIT_FPR(_XMM2)
+#    define JIT_F3              JIT_FPR(_XMM3)
+#    define JIT_F4              JIT_FPR(_XMM4)
+#    define JIT_F5              JIT_FPR(_XMM5)
+#    define JIT_F6              JIT_FPR(_XMM6)
+#    define JIT_F7              JIT_FPR(_XMM7)
+#    define JIT_F8              JIT_FPR(_XMM8)
+#    define JIT_F9              JIT_FPR(_XMM9)
+#    define JIT_F10             JIT_FPR(_XMM10)
+#    define JIT_F11             JIT_FPR(_XMM11)
+#    define JIT_F12             JIT_FPR(_XMM12)
+#    define JIT_F13             JIT_FPR(_XMM13)
+#    define JIT_F14             JIT_FPR(_XMM14)
+#    define JIT_F15             JIT_FPR(_XMM15)
   _XMM8, _XMM9, _XMM10, _XMM11, _XMM12, _XMM13, _XMM14, _XMM15,
   _XMM7, _XMM6, _XMM5, _XMM4, _XMM3, _XMM2, _XMM1, _XMM0,
 #    define jit_sse_reg_p(reg)  ((reg) >= _XMM8 && (reg) <= _XMM0)
diff --git a/tests/addr_d.c b/tests/addr_d.c
index 21a9dddae..e89663eb0 100644
--- a/tests/addr_d.c
+++ b/tests/addr_d.c
@@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
   jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }};
+  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
 
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
diff --git a/tests/addr_f.c b/tests/addr_f.c
index 4bcd533df..ce918fd0f 100644
--- a/tests/addr_f.c
+++ b/tests/addr_f.c
@@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
   jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }};
+  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
 
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
diff --git a/tests/divr_d.c b/tests/divr_d.c
index 978e4a44d..8597fdda0 100644
--- a/tests/divr_d.c
+++ b/tests/divr_d.c
@@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
   jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }};
+  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
 
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
diff --git a/tests/divr_f.c b/tests/divr_f.c
index 681df0af0..dd2c63317 100644
--- a/tests/divr_f.c
+++ b/tests/divr_f.c
@@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
   jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }};
+  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
 
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
diff --git a/tests/mulr_d.c b/tests/mulr_d.c
index e7945b998..0b4fa18ad 100644
--- a/tests/mulr_d.c
+++ b/tests/mulr_d.c
@@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
   jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }};
+  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
 
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
diff --git a/tests/mulr_f.c b/tests/mulr_f.c
index b57cf7bf1..ed716fa5f 100644
--- a/tests/mulr_f.c
+++ b/tests/mulr_f.c
@@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
   jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }};
+  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
 
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
diff --git a/tests/qdivr.c b/tests/qdivr.c
index f3862ffd4..37871f375 100644
--- a/tests/qdivr.c
+++ b/tests/qdivr.c
@@ -3,14 +3,14 @@
 static void
 maybe_save(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_class(reg) & jit_class_sav)
+  if (jit_class(reg.bits) & jit_class_sav)
     jit_pushr(j, reg);
 }    
 
 static void
 maybe_restore(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_class(reg) & jit_class_sav)
+  if (jit_class(reg.bits) & jit_class_sav)
     jit_popr(j, reg);
 }    
 
diff --git a/tests/qdivr_u.c b/tests/qdivr_u.c
index 29589c845..84f101f56 100644
--- a/tests/qdivr_u.c
+++ b/tests/qdivr_u.c
@@ -3,14 +3,14 @@
 static void
 maybe_save(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_class(reg) & jit_class_sav)
+  if (jit_class(reg.bits) & jit_class_sav)
     jit_pushr(j, reg);
 }    
 
 static void
 maybe_restore(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_class(reg) & jit_class_sav)
+  if (jit_class(reg.bits) & jit_class_sav)
     jit_popr(j, reg);
 }    
 
diff --git a/tests/qmulr.c b/tests/qmulr.c
index 279045cb5..7e3d4b0e8 100644
--- a/tests/qmulr.c
+++ b/tests/qmulr.c
@@ -3,14 +3,14 @@
 static void
 maybe_save(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_class(reg) & jit_class_sav)
+  if (jit_class(reg.bits) & jit_class_sav)
     jit_pushr(j, reg);
 }    
 
 static void
 maybe_restore(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_class(reg) & jit_class_sav)
+  if (jit_class(reg.bits) & jit_class_sav)
     jit_popr(j, reg);
 }    
 
diff --git a/tests/qmulr_u.c b/tests/qmulr_u.c
index 6b8121cbd..6ac5cd057 100644
--- a/tests/qmulr_u.c
+++ b/tests/qmulr_u.c
@@ -3,14 +3,14 @@
 static void
 maybe_save(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_class(reg) & jit_class_sav)
+  if (jit_class(reg.bits) & jit_class_sav)
     jit_pushr(j, reg);
 }    
 
 static void
 maybe_restore(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_class(reg) & jit_class_sav)
+  if (jit_class(reg.bits) & jit_class_sav)
     jit_popr(j, reg);
 }    
 
diff --git a/tests/sti_d.c b/tests/sti_d.c
index 6f5960e4e..2c51827f5 100644
--- a/tests/sti_d.c
+++ b/tests/sti_d.c
@@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   jit_receive(j, 1, abi, args);
   jit_load_args(j, 1, abi, args, regs);
 
-  jit_sti_d(j, &data[1], JIT_R0);
+  jit_sti_d(j, &data[1], JIT_F0);
   jit_ret(j);
 
   void (*f)(double) = jit_end(j, NULL);
diff --git a/tests/sti_f.c b/tests/sti_f.c
index eb008b4fc..1e3674a4f 100644
--- a/tests/sti_f.c
+++ b/tests/sti_f.c
@@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   jit_receive(j, 1, abi, args);
   jit_load_args(j, 1, abi, args, regs);
 
-  jit_sti_f(j, &data[1], JIT_R0);
+  jit_sti_f(j, &data[1], JIT_F0);
   jit_ret(j);
 
   void (*f)(float) = jit_end(j, NULL);
diff --git a/tests/str_d.c b/tests/str_d.c
index 2850553ff..04e5aed57 100644
--- a/tests/str_d.c
+++ b/tests/str_d.c
@@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
 
-  jit_str_d(j, JIT_F0, JIT_R0);
+  jit_str_d(j, JIT_R0, JIT_F0);
   jit_ret(j);
 
   void (*f)(void*, double) = jit_end(j, NULL);
diff --git a/tests/str_f.c b/tests/str_f.c
index 5d1138f2b..167fac038 100644
--- a/tests/str_f.c
+++ b/tests/str_f.c
@@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
 
-  jit_str_f(j, JIT_F0, JIT_R0);
+  jit_str_f(j, JIT_R0, JIT_F0);
   jit_ret(j);
 
   void (*f)(void*, float) = jit_end(j, NULL);
diff --git a/tests/subr_d.c b/tests/subr_d.c
index d6f18483a..94c5ea477 100644
--- a/tests/subr_d.c
+++ b/tests/subr_d.c
@@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
   jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }};
+  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
 
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);
diff --git a/tests/subr_f.c b/tests/subr_f.c
index ea364f995..fd6b37777 100644
--- a/tests/subr_f.c
+++ b/tests/subr_f.c
@@ -7,7 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
   jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_F0 }, { .gpr=JIT_F1 }};
+  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
 
   jit_receive(j, 2, abi, args);
   jit_load_args(j, 2, abi, args, regs);