Merge from upstream lightening

10 files changed, 326 insertions, 344 deletions

diff --git a/libguile/lightening/lightening.h b/libguile/lightening/lightening.h
index 4747a7149..d5a96fa8b 100644
--- a/libguile/lightening/lightening.h
+++ b/libguile/lightening/lightening.h
@@ -37,18 +37,33 @@ typedef float		jit_float32_t;
 typedef double		jit_float64_t;
 typedef void*		jit_pointer_t;
 typedef int		jit_bool_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); }
+typedef struct jit_gpr { uint8_t regno; } jit_gpr_t;
+typedef struct jit_fpr { uint8_t regno; } jit_fpr_t;
+
+// Precondition: regno between 0 and 63, inclusive.
+#define JIT_GPR(regno) ((jit_gpr_t) { regno })
+#define JIT_FPR(regno) ((jit_fpr_t) { regno })
+
+static inline uint8_t jit_gpr_regno (jit_gpr_t reg) { return reg.regno; }
+static inline uint8_t jit_fpr_regno (jit_fpr_t reg) { return reg.regno; }
+
+static inline jit_bool_t
+jit_same_gprs (jit_gpr_t a, jit_gpr_t b)
+{
+  return jit_gpr_regno (a) == jit_gpr_regno (b);
+}
+
+static inline jit_bool_t
+jit_same_fprs (jit_fpr_t a, jit_fpr_t b)
+{
+  return jit_fpr_regno (a) == jit_fpr_regno (b);
+}
 
 enum jit_reloc_kind
 {
@@ -95,22 +110,6 @@ typedef struct jit_reloc
 #  include "lightening/alpha.h"
 #endif
 
-#define jit_class_sav		0x10000000	/* callee save */
-#define jit_class(bits)		((bits) & 0xffff0000)
-#define jit_regno(bits)		((bits) & 0x00007fff)
-
-static inline jit_bool_t
-jit_same_gprs (jit_gpr_t a, jit_gpr_t b)
-{
-  return a.bits == b.bits;
-}
-
-static inline jit_bool_t
-jit_same_fprs (jit_fpr_t a, jit_fpr_t b)
-{
-  return a.bits == b.bits;
-}
-
 typedef struct jit_state	jit_state_t;
 
 enum jit_operand_abi
@@ -224,9 +223,6 @@ JIT_API jit_pointer_t jit_address(jit_state_t*);
 JIT_API void jit_patch_here(jit_state_t*, jit_reloc_t);
 JIT_API void jit_patch_there(jit_state_t*, jit_reloc_t, jit_pointer_t);
 
-JIT_API jit_bool_t jit_gpr_is_callee_save (jit_state_t*, jit_gpr_t);
-JIT_API jit_bool_t jit_fpr_is_callee_save (jit_state_t*, jit_fpr_t);
-
 JIT_API void jit_move_operands (jit_state_t *_jit, jit_operand_t *dst,
                                 jit_operand_t *src, size_t argc);
 
diff --git a/libguile/lightening/lightening/lightening.c b/libguile/lightening/lightening/lightening.c
index c2d55bd2b..5a98eb43c 100644
--- a/libguile/lightening/lightening/lightening.c
+++ b/libguile/lightening/lightening/lightening.c
@@ -36,8 +36,6 @@
 #endif
 
 #define _NOREG 0xffff
-#define rc(value)               jit_class_##value
-#define rn(reg)                 jit_regno(reg.bits)
 
 #if defined(__i386__) || defined(__x86_64__)
 # define JIT_RET                _RAX
@@ -373,18 +371,6 @@ jit_patch_there(jit_state_t* _jit, jit_reloc_t reloc, jit_pointer_t addr)
     }
 }
 
-jit_bool_t
-jit_gpr_is_callee_save (jit_state_t *_jit, jit_gpr_t reg)
-{
-  return jit_class(reg.bits) & jit_class_sav;
-}
-
-jit_bool_t
-jit_fpr_is_callee_save (jit_state_t *_jit, jit_fpr_t reg)
-{
-  return jit_class(reg.bits) & jit_class_sav;
-}
-
 #if defined(__i386__) || defined(__x86_64__)
 # include "x86.c"
 #elif defined(__mips__)
@@ -469,8 +455,8 @@ jit_fpr_is_callee_save (jit_state_t *_jit, jit_fpr_t reg)
 #define JIT_IMPL__pG__(stem) JIT_IMPL_2(stem, void, pointer, gpr)
 #define JIT_IMPL__p___(stem) JIT_IMPL_1(stem, void, pointer)
 
-#define unwrap_gpr(r) rn(r)
-#define unwrap_fpr(r) rn(r)
+#define unwrap_gpr(r) jit_gpr_regno(r)
+#define unwrap_fpr(r) jit_fpr_regno(r)
 #define unwrap_imm(i) i
 #define unwrap_uimm(u) u
 #define unwrap_off(o) o
diff --git a/libguile/lightening/lightening/x86-cpu.c b/libguile/lightening/lightening/x86-cpu.c
index f49ba7e37..018a58b9a 100644
--- a/libguile/lightening/lightening/x86-cpu.c
+++ b/libguile/lightening/lightening/x86-cpu.c
@@ -505,8 +505,8 @@ alui(jit_state_t *_jit, int32_t code, int32_t r0, jit_word_t i0)
     }
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    alur(_jit, code, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    alur(_jit, code, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -710,8 +710,8 @@ addi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     iaddr(_jit, r0, r1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    iaddr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    iaddr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -736,8 +736,8 @@ addci(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   }
   else if (r0 == r1) {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    iaddr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    iaddr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   } else {
     movi(_jit, r0, i0);
@@ -765,8 +765,8 @@ addxi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   }
   else if (r0 == r1) {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    iaddxr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    iaddxr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   } else {
     movi(_jit, r0, i0);
@@ -810,8 +810,8 @@ subi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     iaddr(_jit, r0, r1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    isubr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    isubr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -821,9 +821,9 @@ subcr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
   if (r0 == r2 && r0 != r1) {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movr(_jit, rn(reg), r0);
+    movr(_jit, jit_gpr_regno(reg), r0);
     movr(_jit, r0, r1);
-    isubr(_jit, r0, rn(reg));
+    isubr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   } else {
     movr(_jit, r0, r1);
@@ -839,8 +839,8 @@ subci(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     isubi(_jit, r0, i0);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    isubr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    isubr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -850,9 +850,9 @@ subxr(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
   if (r0 == r2 && r0 != r1) {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movr(_jit, rn(reg), r0);
+    movr(_jit, jit_gpr_regno(reg), r0);
     movr(_jit, r0, r1);
-    isubxr(_jit, r0, rn(reg));
+    isubxr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   } else {
     movr(_jit, r0, r1);
@@ -868,8 +868,8 @@ subxi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     isubxi(_jit, r0, i0);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    imovi(_jit, rn(reg), i0);
-    isubxr(_jit, r0, rn(reg));
+    imovi(_jit, jit_gpr_regno(reg), i0);
+    isubxr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -888,11 +888,11 @@ rotshr(jit_state_t *_jit, int32_t code,
 {
   if (r0 == _RCX_REGNO) {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movr(_jit, rn(reg), r1);
+    movr(_jit, jit_gpr_regno(reg), r1);
     if (r2 != _RCX_REGNO)
       movr(_jit, _RCX_REGNO, r2);
-    irotshr(_jit, code, rn(reg));
-    movr(_jit, _RCX_REGNO, rn(reg));
+    irotshr(_jit, code, jit_gpr_regno(reg));
+    movr(_jit, _RCX_REGNO, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   } else if (r2 != _RCX_REGNO) {
     /* Already know that R0 isn't RCX.  */
@@ -1005,8 +1005,8 @@ imuli(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     }
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    imulr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    imulr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1133,11 +1133,11 @@ iqmuli(jit_state_t *_jit, int32_t r0, int32_t r1,
     ixorr(_jit, r1, r1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
+    movi(_jit, jit_gpr_regno(reg), i0);
     if (sign)
-      qmulr(_jit, r0, r1, r2, rn(reg));
+      qmulr(_jit, r0, r1, r2, jit_gpr_regno(reg));
     else
-      qmulr_u(_jit, r0, r1, r2, rn(reg));
+      qmulr_u(_jit, r0, r1, r2, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1173,8 +1173,8 @@ 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) {
     jit_gpr_t tmp = get_temp_gpr(_jit);
-    movr(_jit, rn(tmp), r2);
-    r2 = rn(tmp);
+    movr(_jit, jit_gpr_regno(tmp), r2);
+    r2 = jit_gpr_regno(tmp);
     tmp_divisor = 1;
   }
 
@@ -1207,9 +1207,9 @@ divremi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0,
          jit_bool_t sign, jit_bool_t divide)
 {
   jit_gpr_t tmp = get_temp_gpr(_jit);
-  movi(_jit, rn(tmp), i0);
+  movi(_jit, jit_gpr_regno(tmp), i0);
 
-  divremr(_jit, r0, r1, rn(tmp), sign, divide);
+  divremr(_jit, r0, r1, jit_gpr_regno(tmp), sign, divide);
 }
 
 static void
@@ -1273,8 +1273,8 @@ iqdivr(jit_state_t *_jit, int32_t r0, int32_t r1,
   int tmp_divisor = 0;
   if (r3 == _RAX_REGNO || r3 == _RDX_REGNO) {
     jit_gpr_t tmp = get_temp_gpr(_jit);
-    movr(_jit, rn(tmp), r3);
-    r3 = rn(tmp);
+    movr(_jit, jit_gpr_regno(tmp), r3);
+    r3 = jit_gpr_regno(tmp);
     tmp_divisor = 1;
   }
 
@@ -1324,11 +1324,11 @@ iqdivi(jit_state_t *_jit, int32_t r0, int32_t r1,
        int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i0);
+  movi(_jit, jit_gpr_regno(reg), i0);
   if (sign)
-    qdivr(_jit, r0, r1, r2, rn(reg));
+    qdivr(_jit, r0, r1, r2, jit_gpr_regno(reg));
   else
-    qdivr_u(_jit, r0, r1, r2, rn(reg));
+    qdivr_u(_jit, r0, r1, r2, jit_gpr_regno(reg));
   unget_temp_gpr(_jit);
 }
 
@@ -1379,8 +1379,8 @@ andi(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
       iandi(_jit, r0, i0);
     } else {
       jit_gpr_t reg = get_temp_gpr(_jit);
-      movi(_jit, rn(reg), i0);
-      iandr(_jit, r0, rn(reg));
+      movi(_jit, jit_gpr_regno(reg), i0);
+      iandr(_jit, r0, jit_gpr_regno(reg));
       unget_temp_gpr(_jit);
     }
   } else {
@@ -1420,8 +1420,8 @@ ori(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     iorr(_jit, r0, r1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    iorr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    iorr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1457,8 +1457,8 @@ xori(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     ixorr(_jit, r0, r1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ixorr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ixorr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1476,10 +1476,10 @@ cr(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1, int32_t r2)
     cc(_jit, code, r0);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    ixorr(_jit, rn(reg), rn(reg));
+    ixorr(_jit, jit_gpr_regno(reg), jit_gpr_regno(reg));
     icmpr(_jit, r1, r2);
-    cc(_jit, code, rn(reg));
-    movr(_jit, r0, rn(reg));
+    cc(_jit, code, jit_gpr_regno(reg));
+    movr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1497,10 +1497,10 @@ ci(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1, jit_word_t i0)
     cc(_jit, code, r0);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    ixorr(_jit, rn(reg), rn(reg));
+    ixorr(_jit, jit_gpr_regno(reg), jit_gpr_regno(reg));
     icmpi(_jit, r1, i0);
-    cc(_jit, code, rn(reg));
-    movr(_jit, r0, rn(reg));
+    cc(_jit, code, jit_gpr_regno(reg));
+    movr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1518,10 +1518,10 @@ ci0(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1)
     cc(_jit, code, r0);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    ixorr(_jit, rn(reg), rn(reg));
+    ixorr(_jit, jit_gpr_regno(reg), jit_gpr_regno(reg));
     testr(_jit, r1, r1);
-    cc(_jit, code, rn(reg));
-    movr(_jit, r0, rn(reg));
+    cc(_jit, code, jit_gpr_regno(reg));
+    movr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1533,8 +1533,8 @@ extr_c(jit_state_t *_jit, int32_t r0, int32_t r1)
     movcr(_jit, r0, r1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movr(_jit, rn(reg), r1);
-    movcr(_jit, r0, rn(reg));
+    movr(_jit, jit_gpr_regno(reg), r1);
+    movcr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1546,8 +1546,8 @@ extr_uc(jit_state_t *_jit, int32_t r0, int32_t r1)
     movcr_u(_jit, r0, r1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movr(_jit, rn(reg), r1);
-    movcr_u(_jit, r0, rn(reg));
+    movr(_jit, jit_gpr_regno(reg), r1);
+    movcr_u(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1627,8 +1627,8 @@ ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_c(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_c(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1652,8 +1652,8 @@ ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_uc(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_uc(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1677,8 +1677,8 @@ ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_s(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_s(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1702,8 +1702,8 @@ ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_us(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_us(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1734,8 +1734,8 @@ ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_i(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_i(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1759,8 +1759,8 @@ ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_ui(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_ui(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1783,8 +1783,8 @@ ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_l(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_l(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1815,8 +1815,8 @@ ldxi_c(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldxr_c(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_c(_jit, r0, r1, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1845,8 +1845,8 @@ ldxi_uc(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldxr_uc(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_uc(_jit, r0, r1, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1875,8 +1875,8 @@ ldxi_s(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldxr_s(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_s(_jit, r0, r1, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1905,8 +1905,8 @@ ldxi_us(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldxr_us(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_us(_jit, r0, r1, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1937,8 +1937,8 @@ ldxi_i(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldxr_i(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_i(_jit, r0, r1, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1968,8 +1968,8 @@ ldxi_ui(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldxr_ui(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_ui(_jit, r0, r1, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -1992,8 +1992,8 @@ ldxi_l(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     rx(_jit, r0, i0, r1, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldxr_l(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_l(_jit, r0, r1, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -2009,10 +2009,10 @@ str_c(jit_state_t *_jit, int32_t r0, int32_t r1)
     rx(_jit, r1, 0, r0, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movr(_jit, rn(reg), r1);
-    rex(_jit, 0, 0, rn(reg), _NOREG, r0);
+    movr(_jit, jit_gpr_regno(reg), r1);
+    rex(_jit, 0, 0, jit_gpr_regno(reg), _NOREG, r0);
     ic(_jit, 0x88);
-    rx(_jit, rn(reg), 0, r0, _NOREG, _SCL1);
+    rx(_jit, jit_gpr_regno(reg), 0, r0, _NOREG, _SCL1);
     unget_temp_gpr(_jit);
   }
 }
@@ -2027,16 +2027,16 @@ sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
       rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
     } else {
       jit_gpr_t reg = get_temp_gpr(_jit);
-      movr(_jit, rn(reg), r0);
-      rex(_jit, 0, 0, rn(reg), _NOREG, _NOREG);
+      movr(_jit, jit_gpr_regno(reg), r0);
+      rex(_jit, 0, 0, jit_gpr_regno(reg), _NOREG, _NOREG);
       ic(_jit, 0x88);
-      rx(_jit, rn(reg), i0, _NOREG, _NOREG, _SCL1);
+      rx(_jit, jit_gpr_regno(reg), i0, _NOREG, _NOREG, _SCL1);
       unget_temp_gpr(_jit);
     }
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    str_c(_jit, rn(reg), r0);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    str_c(_jit, jit_gpr_regno(reg), r0);
     unget_temp_gpr(_jit);
   }
 }
@@ -2060,8 +2060,8 @@ sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    str_s(_jit, rn(reg), r0);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    str_s(_jit, jit_gpr_regno(reg), r0);
     unget_temp_gpr(_jit);
   }
 }
@@ -2083,8 +2083,8 @@ sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    str_i(_jit, rn(reg), r0);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    str_i(_jit, jit_gpr_regno(reg), r0);
     unget_temp_gpr(_jit);
   }
 }
@@ -2107,8 +2107,8 @@ sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
     rx(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    str_l(_jit, rn(reg), r0);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    str_l(_jit, jit_gpr_regno(reg), r0);
     unget_temp_gpr(_jit);
   }
 }
@@ -2119,8 +2119,8 @@ stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
   jit_gpr_t reg = get_temp_gpr(_jit);
-  addr(_jit, rn(reg), r0, r1);
-  str_c(_jit, rn(reg), r2);
+  addr(_jit, jit_gpr_regno(reg), r0, r1);
+  str_c(_jit, jit_gpr_regno(reg), r2);
   unget_temp_gpr(_jit);
 #else
   if (reg8_p(r2)) {
@@ -2129,10 +2129,10 @@ stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
     rx(_jit, r2, 0, r0, r1, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movr(_jit, rn(reg), r2);
-    rex(_jit, 0, 0, rn(reg), r1, r0);
+    movr(_jit, jit_gpr_regno(reg), r2);
+    rex(_jit, 0, 0, jit_gpr_regno(reg), r1, r0);
     ic(_jit, 0x88);
-    rx(_jit, rn(reg), 0, r0, r1, _SCL1);
+    rx(_jit, jit_gpr_regno(reg), 0, r0, r1, _SCL1);
     unget_temp_gpr(_jit);
   }
 #endif
@@ -2148,16 +2148,16 @@ stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
       rx(_jit, r1, i0, r0, _NOREG, _SCL1);
     } else {
       jit_gpr_t reg = get_temp_gpr(_jit);
-      movr(_jit, rn(reg), r1);
-      rex(_jit, 0, 0, rn(reg), _NOREG, r0);
+      movr(_jit, jit_gpr_regno(reg), r1);
+      rex(_jit, 0, 0, jit_gpr_regno(reg), _NOREG, r0);
       ic(_jit, 0x88);
-      rx(_jit, rn(reg), i0, r0, _NOREG, _SCL1);
+      rx(_jit, jit_gpr_regno(reg), i0, r0, _NOREG, _SCL1);
       unget_temp_gpr(_jit);
     }
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    stxr_c(_jit, rn(reg), r0, r1);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    stxr_c(_jit, jit_gpr_regno(reg), r0, r1);
     unget_temp_gpr(_jit);
   }
 }
@@ -2167,8 +2167,8 @@ stxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
   jit_gpr_t reg = get_temp_gpr(_jit);
-  addr(_jit, rn(reg), r0, r1);
-  str_s(_jit, rn(reg), r2);
+  addr(_jit, jit_gpr_regno(reg), r0, r1);
+  str_s(_jit, jit_gpr_regno(reg), r2);
   unget_temp_gpr(_jit);
 #else
   ic(_jit, 0x66);
@@ -2188,8 +2188,8 @@ stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
     rx(_jit, r1, i0, r0, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    stxr_s(_jit, rn(reg), r0, r1);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    stxr_s(_jit, jit_gpr_regno(reg), r0, r1);
     unget_temp_gpr(_jit);
   }
 }
@@ -2199,8 +2199,8 @@ stxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
   jit_gpr_t reg = get_temp_gpr(_jit);
-  addr(_jit, rn(reg), r0, r1);
-  str_i(rn(reg), r2);
+  addr(_jit, jit_gpr_regno(reg), r0, r1);
+  str_i(jit_gpr_regno(reg), r2);
   unget_temp_gpr(_jit);
 #else
   rex(_jit, 0, 0, r2, r1, r0);
@@ -2218,8 +2218,8 @@ stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
     rx(_jit, r1, i0, r0, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    stxr_i(_jit, rn(reg), r0, r1);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    stxr_i(_jit, jit_gpr_regno(reg), r0, r1);
     unget_temp_gpr(_jit);
   }
 }
@@ -2242,8 +2242,8 @@ stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
     rx(_jit, r1, i0, r0, _NOREG, _SCL1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    stxr_l(_jit, rn(reg), r0, r1);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    stxr_l(_jit, jit_gpr_regno(reg), r0, r1);
     unget_temp_gpr(_jit);
   }
 }
@@ -2439,8 +2439,8 @@ bmsi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     testi(_jit, r0, i1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i1);
-    testr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i1);
+    testr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
   return jnz(_jit);
@@ -2460,8 +2460,8 @@ bmci(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     testi(_jit, r0, i1);
   } else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i1);
-    testr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i1);
+    testr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
   return jz(_jit);
@@ -2482,9 +2482,9 @@ boaddi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     return jo(_jit);
   }
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i1);
+  movi(_jit, jit_gpr_regno(reg), i1);
   unget_temp_gpr(_jit);
-  return boaddr(_jit, r0, rn(reg));
+  return boaddr(_jit, r0, jit_gpr_regno(reg));
 }
 
 static jit_reloc_t
@@ -2502,9 +2502,9 @@ boaddi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     return jc(_jit);
   }
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i1);
+  movi(_jit, jit_gpr_regno(reg), i1);
   unget_temp_gpr(_jit);
-  return boaddr_u(_jit, r0, rn(reg));
+  return boaddr_u(_jit, r0, jit_gpr_regno(reg));
 }
 
 static jit_reloc_t
@@ -2522,9 +2522,9 @@ bxaddi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     return jno(_jit);
   }
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i1);
+  movi(_jit, jit_gpr_regno(reg), i1);
   unget_temp_gpr(_jit);
-  return bxaddr(_jit, r0, rn(reg));
+  return bxaddr(_jit, r0, jit_gpr_regno(reg));
 }
 
 static jit_reloc_t
@@ -2542,9 +2542,9 @@ bxaddi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     return jnc(_jit);
   }
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i1);
+  movi(_jit, jit_gpr_regno(reg), i1);
   unget_temp_gpr(_jit);
-  return bxaddr_u(_jit, r0, rn(reg));
+  return bxaddr_u(_jit, r0, jit_gpr_regno(reg));
 }
 
 static jit_reloc_t
@@ -2562,9 +2562,9 @@ bosubi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     return jo(_jit);
   }
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i1);
+  movi(_jit, jit_gpr_regno(reg), i1);
   unget_temp_gpr(_jit);
-  return bosubr(_jit, r0, rn(reg));
+  return bosubr(_jit, r0, jit_gpr_regno(reg));
 }
 
 static jit_reloc_t
@@ -2582,9 +2582,9 @@ bosubi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     return jc(_jit);
   }
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i1);
+  movi(_jit, jit_gpr_regno(reg), i1);
   unget_temp_gpr(_jit);
-  return bosubr_u(_jit, r0, rn(reg));
+  return bosubr_u(_jit, r0, jit_gpr_regno(reg));
 }
 
 static jit_reloc_t
@@ -2602,9 +2602,9 @@ bxsubi(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     return jno(_jit);
   }
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i1);
+  movi(_jit, jit_gpr_regno(reg), i1);
   unget_temp_gpr(_jit);
-  return bxsubr(_jit, r0, rn(reg));
+  return bxsubr(_jit, r0, jit_gpr_regno(reg));
 }
 
 static jit_reloc_t
@@ -2622,9 +2622,9 @@ bxsubi_u(jit_state_t *_jit, int32_t r0, jit_word_t i1)
     return jnc(_jit);
   }
   jit_gpr_t reg = get_temp_gpr(_jit);
-  movi(_jit, rn(reg), i1);
+  movi(_jit, jit_gpr_regno(reg), i1);
   unget_temp_gpr(_jit);
-  return bxsubr_u(_jit, r0, rn(reg));
+  return bxsubr_u(_jit, r0, jit_gpr_regno(reg));
 }
 
 static void
@@ -2647,8 +2647,8 @@ calli(jit_state_t *_jit, jit_word_t i0)
   else
     {
       jit_gpr_t reg = get_temp_gpr(_jit);
-      jit_patch_there(_jit, mov_addr(_jit, rn(reg)), (void*)i0);
-      callr(_jit, rn(reg));
+      jit_patch_there(_jit, mov_addr(_jit, jit_gpr_regno(reg)), (void*)i0);
+      callr(_jit, jit_gpr_regno(reg));
       unget_temp_gpr(_jit);
     }
 }
@@ -2673,8 +2673,8 @@ jmpi(jit_state_t *_jit, jit_word_t i0)
   else
     {
       jit_gpr_t reg = get_temp_gpr(_jit);
-      jit_patch_there(_jit, mov_addr(_jit, rn(reg)), (void*)i0);
-      jmpr(_jit, rn(reg));
+      jit_patch_there(_jit, mov_addr(_jit, jit_gpr_regno(reg)), (void*)i0);
+      jmpr(_jit, jit_gpr_regno(reg));
       unget_temp_gpr(_jit);
     }
 }
@@ -2716,34 +2716,34 @@ reti(jit_state_t *_jit, jit_word_t i0)
 static void
 retval_c(jit_state_t *_jit, int32_t r0)
 {
-  extr_c(_jit, r0, rn(JIT_RET));
+  extr_c(_jit, r0, jit_gpr_regno(JIT_RET));
 }
 
 static void
 retval_uc(jit_state_t *_jit, int32_t r0)
 {
-  extr_uc(_jit, r0, rn(JIT_RET));
+  extr_uc(_jit, r0, jit_gpr_regno(JIT_RET));
 }
 
 static void
 retval_s(jit_state_t *_jit, int32_t r0)
 {
-  extr_s(_jit, r0, rn(JIT_RET));
+  extr_s(_jit, r0, jit_gpr_regno(JIT_RET));
 }
 
 static void
 retval_us(jit_state_t *_jit, int32_t r0)
 {
-  extr_us(_jit, r0, rn(JIT_RET));
+  extr_us(_jit, r0, jit_gpr_regno(JIT_RET));
 }
 
 static void
 retval_i(jit_state_t *_jit, int32_t r0)
 {
 #if __X32 || __X64_32
-  movr(_jit, r0, rn(JIT_RET));
+  movr(_jit, r0, jit_gpr_regno(JIT_RET));
 #else
-  extr_i(_jit, r0, rn(JIT_RET));
+  extr_i(_jit, r0, jit_gpr_regno(JIT_RET));
 #endif
 }
 
@@ -2751,12 +2751,12 @@ retval_i(jit_state_t *_jit, int32_t r0)
 static void
 retval_ui(jit_state_t *_jit, int32_t r0)
 {
-  extr_ui(_jit, r0, rn(JIT_RET));
+  extr_ui(_jit, r0, jit_gpr_regno(JIT_RET));
 }
 
 static void
 retval_l(jit_state_t *_jit, int32_t r0)
 {
-  movr(_jit, r0, rn(JIT_RET));
+  movr(_jit, r0, jit_gpr_regno(JIT_RET));
 }
 #endif
diff --git a/libguile/lightening/lightening/x86-sse.c b/libguile/lightening/lightening/x86-sse.c
index 370f5f401..bc6c060ff 100644
--- a/libguile/lightening/lightening/x86-sse.c
+++ b/libguile/lightening/lightening/x86-sse.c
@@ -173,8 +173,8 @@ static void
 pushr_d(jit_state_t *_jit, int32_t r0)
 {
   jit_gpr_t tmp = get_temp_gpr(_jit);
-  movdqxr(_jit, rn(tmp), r0);
-  pushr(_jit, rn(tmp));
+  movdqxr(_jit, jit_gpr_regno(tmp), r0);
+  pushr(_jit, jit_gpr_regno(tmp));
   unget_temp_gpr(_jit);
 }
 
@@ -182,8 +182,8 @@ static void
 popr_d(jit_state_t *_jit, int32_t r0)
 {
   jit_gpr_t tmp = get_temp_gpr(_jit);
-  popr(_jit, rn(tmp));
-  ssexr(_jit, 0x66, X86_SSE_G2X, r0, rn(tmp));
+  popr(_jit, jit_gpr_regno(tmp));
+  ssexr(_jit, 0x66, X86_SSE_G2X, r0, jit_gpr_regno(tmp));
   unget_temp_gpr(_jit);
 }
 
@@ -379,8 +379,8 @@ movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t i0)
     xorpsr(_jit, r0, r0);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), data.i);
-    movdlxr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), data.i);
+    movdlxr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -400,14 +400,14 @@ movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t i0)
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64 && !__X64_32
-    movi(_jit, rn(reg), data.w);
-    movdqxr(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), data.w);
+    movdqxr(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
 #else
-    movi(_jit, rn(reg), data.ii[0]);
-    stxi_i(CVT_OFFSET, _RBP_REGNO, rn(reg));
-    movi(_jit, rn(reg), data.ii[1]);
-    stxi_i(CVT_OFFSET + 4, _RBP_REGNO, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), data.ii[0]);
+    stxi_i(CVT_OFFSET, _RBP_REGNO, jit_gpr_regno(reg));
+    movi(_jit, jit_gpr_regno(reg), data.ii[1]);
+    stxi_i(CVT_OFFSET + 4, _RBP_REGNO, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
     ldxi_d(_jit, r0, _RBP_REGNO, CVT_OFFSET);
 #endif
@@ -418,7 +418,7 @@ static void
 retval_f(jit_state_t *_jit, int32_t r0)
 {
 #if __X64
-  movr_f(_jit, r0, rn(JIT_FRET));
+  movr_f(_jit, r0, jit_fpr_regno(JIT_FRET));
 #endif
 }
 
@@ -426,21 +426,21 @@ static void
 retval_d(jit_state_t *_jit, int32_t r0)
 {
 #if __X64
-  movr_d(_jit, r0, rn(JIT_FRET));
+  movr_d(_jit, r0, jit_fpr_regno(JIT_FRET));
 #endif
 }
 
 static void
 retr_f(jit_state_t *_jit, int32_t u)
 {
-  movr_f(_jit, rn(JIT_FRET), u);
+  movr_f(_jit, jit_fpr_regno(JIT_FRET), u);
   ret(_jit);
 }
 
 static void
 retr_d(jit_state_t *_jit, int32_t u)
 {
-  movr_d(_jit, rn(JIT_FRET), u);
+  movr_d(_jit, jit_fpr_regno(JIT_FRET), u);
   ret(_jit);
 }
 
@@ -477,9 +477,9 @@ subr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
     subssr(_jit, r0, r2);
   else if (r0 == r2) {
     jit_fpr_t reg = get_temp_xpr(_jit);
-    movr_f(_jit, rn(reg), r0);
+    movr_f(_jit, jit_fpr_regno(reg), r0);
     movr_f(_jit, r0, r1);
-    subssr(_jit, r0, rn(reg));
+    subssr(_jit, r0, jit_fpr_regno(reg));
     unget_temp_xpr(_jit);
   }
   else {
@@ -495,9 +495,9 @@ subr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
     subsdr(_jit, r0, r2);
   else if (r0 == r2) {
     jit_fpr_t reg = get_temp_xpr(_jit);
-    movr_d(_jit, rn(reg), r0);
+    movr_d(_jit, jit_fpr_regno(reg), r0);
     movr_d(_jit, r0, r1);
-    subsdr(_jit, r0, rn(reg));
+    subsdr(_jit, r0, jit_fpr_regno(reg));
     unget_temp_xpr(_jit);
   }
   else {
@@ -539,9 +539,9 @@ divr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
     divssr(_jit, r0, r2);
   else if (r0 == r2) {
     jit_fpr_t reg = get_temp_xpr(_jit);
-    movr_f(_jit, rn(reg), r0);
+    movr_f(_jit, jit_fpr_regno(reg), r0);
     movr_f(_jit, r0, r1);
-    divssr(_jit, r0, rn(reg));
+    divssr(_jit, r0, jit_fpr_regno(reg));
     unget_temp_xpr(_jit);
   }
   else {
@@ -557,9 +557,9 @@ divr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
     divsdr(_jit, r0, r2);
   else if (r0 == r2) {
     jit_fpr_t reg = get_temp_xpr(_jit);
-    movr_d(_jit, rn(reg), r0);
+    movr_d(_jit, jit_fpr_regno(reg), r0);
     movr_d(_jit, r0, r1);
-    divsdr(_jit, r0, rn(reg));
+    divsdr(_jit, r0, jit_fpr_regno(reg));
     unget_temp_xpr(_jit);
   }
   else {
@@ -573,9 +573,9 @@ absr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
   if (r0 == r1) {
     jit_fpr_t reg = get_temp_xpr(_jit);
-    pcmpeqlr(_jit, rn(reg), rn(reg));
-    psrl(_jit, rn(reg), 1);
-    andpsr(_jit, r0, rn(reg));
+    pcmpeqlr(_jit, jit_fpr_regno(reg), jit_fpr_regno(reg));
+    psrl(_jit, jit_fpr_regno(reg), 1);
+    andpsr(_jit, r0, jit_fpr_regno(reg));
     unget_temp_xpr(_jit);
   }
   else {
@@ -590,9 +590,9 @@ absr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
   if (r0 == r1) {
     jit_fpr_t reg = get_temp_xpr(_jit);
-    pcmpeqlr(_jit, rn(reg), rn(reg));
-    psrq(_jit, rn(reg), 1);
-    andpdr(_jit, r0, rn(reg));
+    pcmpeqlr(_jit, jit_fpr_regno(reg), jit_fpr_regno(reg));
+    psrq(_jit, jit_fpr_regno(reg), 1);
+    andpdr(_jit, r0, jit_fpr_regno(reg));
     unget_temp_xpr(_jit);
   }
   else {
@@ -606,14 +606,14 @@ static void
 negr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
   jit_gpr_t ireg = get_temp_gpr(_jit);
-  imovi(_jit, rn(ireg), 0x80000000);
+  imovi(_jit, jit_gpr_regno(ireg), 0x80000000);
   if (r0 == r1) {
     jit_fpr_t freg = get_temp_xpr(_jit);
-    movdlxr(_jit, rn(freg), rn(ireg));
-    xorpsr(_jit, r0, rn(freg));
+    movdlxr(_jit, jit_fpr_regno(freg), jit_gpr_regno(ireg));
+    xorpsr(_jit, r0, jit_fpr_regno(freg));
     unget_temp_xpr(_jit);
   } else {
-    movdlxr(_jit, r0, rn(ireg));
+    movdlxr(_jit, r0, jit_gpr_regno(ireg));
     xorpsr(_jit, r0, r1);
   }
   unget_temp_gpr(_jit);
@@ -623,15 +623,15 @@ static void
 negr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
   jit_gpr_t ireg = get_temp_gpr(_jit);
-  imovi(_jit, rn(ireg), 0x80000000);
+  imovi(_jit, jit_gpr_regno(ireg), 0x80000000);
   if (r0 == r1) {
     jit_fpr_t freg = get_temp_xpr(_jit);
-    movdlxr(_jit, rn(freg), rn(ireg));
-    pslq(_jit, rn(freg), 32);
-    xorpdr(_jit, r0, rn(freg));
+    movdlxr(_jit, jit_fpr_regno(freg), jit_gpr_regno(ireg));
+    pslq(_jit, jit_fpr_regno(freg), 32);
+    xorpdr(_jit, r0, jit_fpr_regno(freg));
     unget_temp_xpr(_jit);
   } else {
-    movdlxr(_jit, r0, rn(ireg));
+    movdlxr(_jit, r0, jit_gpr_regno(ireg));
     pslq(_jit, r0, 32);
     xorpdr(_jit, r0, r1);
   }
@@ -653,8 +653,8 @@ ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     movssmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_f(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_f(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -664,8 +664,8 @@ ldxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
   jit_gpr_t reg = get_temp_gpr(_jit);
-  addr(_jit, rn(reg), r1, r2);
-  ldr_f(_jit, r0, rn(reg));
+  addr(_jit, jit_gpr_regno(reg), r1, r2);
+  ldr_f(_jit, r0, jit_gpr_regno(reg));
   unget_temp_gpr(_jit);
 #else
   movssmr(_jit, 0, r1, r2, _SCL1, r0);
@@ -680,11 +680,11 @@ ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64_32
-    addi(rn(reg), r1, i0);
-    ldr_f(_jit, r0, rn(reg));
+    addi(jit_gpr_regno(reg), r1, i0);
+    ldr_f(_jit, r0, jit_gpr_regno(reg));
 #else
-    movi(_jit, rn(reg), i0);
-    ldxr_f(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_f(_jit, r0, r1, jit_gpr_regno(reg));
 #endif
     unget_temp_gpr(_jit);
   }
@@ -697,8 +697,8 @@ sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
     movssrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    str_f(_jit, rn(reg), r0);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    str_f(_jit, jit_gpr_regno(reg), r0);
     unget_temp_gpr(_jit);
   }
 }
@@ -708,8 +708,8 @@ stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
   jit_gpr_t reg = get_temp_gpr(_jit);
-  addr(_jit, rn(reg), r0, r1);
-  str_f(_jit, rn(reg), r2);
+  addr(_jit, jit_gpr_regno(reg), r0, r1);
+  str_f(_jit, jit_gpr_regno(reg), r2);
   unget_temp_gpr(_jit);
 #else
   movssrm(_jit, r2, 0, r0, r1, _SCL1);
@@ -724,11 +724,11 @@ stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64_32
-    addi(rn(reg), r0, i0);
-    str_f(_jit, rn(reg), r1);
+    addi(jit_gpr_regno(reg), r0, i0);
+    str_f(_jit, jit_gpr_regno(reg), r1);
 #else
-    movi(_jit, rn(reg), i0);
-    stxr_f(_jit, rn(reg), r0, r1);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    stxr_f(_jit, jit_gpr_regno(reg), r0, r1);
 #endif
     unget_temp_gpr(_jit);
   }
@@ -847,8 +847,8 @@ ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     movsdmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    ldr_d(_jit, r0, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldr_d(_jit, r0, jit_gpr_regno(reg));
     unget_temp_gpr(_jit);
   }
 }
@@ -858,8 +858,8 @@ ldxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
   jit_gpr_t reg = get_temp_gpr(_jit);
-  addr(_jit, rn(reg), r1, r2);
-  ldr_d(_jit, r0, rn(reg));
+  addr(_jit, jit_gpr_regno(reg), r1, r2);
+  ldr_d(_jit, r0, jit_gpr_regno(reg));
   unget_temp_gpr(_jit);
 #else
   movsdmr(_jit, 0, r1, r2, _SCL1, r0);
@@ -874,11 +874,11 @@ ldxi_d(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64_32
-    addi(rn(reg), r1, i0);
-    ldr_d(_jit, r0, rn(reg));
+    addi(jit_gpr_regno(reg), r1, i0);
+    ldr_d(_jit, r0, jit_gpr_regno(reg));
 #else
-    movi(_jit, rn(reg), i0);
-    ldxr_d(_jit, r0, r1, rn(reg));
+    movi(_jit, jit_gpr_regno(reg), i0);
+    ldxr_d(_jit, r0, r1, jit_gpr_regno(reg));
 #endif
     unget_temp_gpr(_jit);
   }
@@ -891,8 +891,8 @@ sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
     movsdrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-    movi(_jit, rn(reg), i0);
-    str_d(_jit, rn(reg), r0);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    str_d(_jit, jit_gpr_regno(reg), r0);
     unget_temp_gpr(_jit);
   }
 }
@@ -902,8 +902,8 @@ stxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
 #if __X64_32
   jit_gpr_t reg = get_temp_gpr(_jit);
-  addr(_jit, rn(reg), r0, r1);
-  str_d(_jit, rn(reg), r2);
+  addr(_jit, jit_gpr_regno(reg), r0, r1);
+  str_d(_jit, jit_gpr_regno(reg), r2);
   unget_temp_gpr(_jit);
 #else
   movsdrm(_jit, r2, 0, r0, r1, _SCL1);
@@ -918,11 +918,11 @@ stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
 #if __X64_32
-    addi(rn(reg), r0, i0);
-    str_d(_jit, rn(reg), r1);
+    addi(jit_gpr_regno(reg), r0, i0);
+    str_d(_jit, jit_gpr_regno(reg), r1);
 #else
-    movi(_jit, rn(reg), i0);
-    stxr_d(_jit, rn(reg), r0, r1);
+    movi(_jit, jit_gpr_regno(reg), i0);
+    stxr_d(_jit, jit_gpr_regno(reg), r0, r1);
 #endif
     unget_temp_gpr(_jit);
   }
diff --git a/libguile/lightening/lightening/x86.c b/libguile/lightening/lightening/x86.c
index ad0e8489c..144816dfd 100644
--- a/libguile/lightening/lightening/x86.c
+++ b/libguile/lightening/lightening/x86.c
@@ -617,7 +617,7 @@ jit_move_operands(jit_state_t *_jit, jit_operand_t *dst, jit_operand_t *src,
     for (size_t i = 0; i < argc; i++) {
       switch (src[i].kind) {
       case JIT_OPERAND_KIND_GPR:
-        src_gprs |= 1ULL << rn(src[i].loc.gpr.gpr);
+        src_gprs |= 1ULL << jit_gpr_regno(src[i].loc.gpr.gpr);
         break;
       case JIT_OPERAND_KIND_FPR:
       case JIT_OPERAND_KIND_IMM:
@@ -629,20 +629,20 @@ jit_move_operands(jit_state_t *_jit, jit_operand_t *dst, jit_operand_t *src,
       switch (dst[i].kind) {
       case JIT_OPERAND_KIND_GPR: {
         ASSERT(dst[i].loc.gpr.addend == 0);
-        uint64_t bit = 1ULL << rn(dst[i].loc.gpr.gpr);
+        uint64_t bit = 1ULL << jit_gpr_regno(dst[i].loc.gpr.gpr);
         ASSERT((dst_gprs & bit) == 0);
         dst_gprs |= bit;
         break;
       }
       case JIT_OPERAND_KIND_FPR: {
-        uint64_t bit = 1ULL << rn(dst[i].loc.fpr);
+        uint64_t bit = 1ULL << jit_fpr_regno(dst[i].loc.fpr);
         ASSERT((dst_fprs & bit) == 0);
         dst_fprs |= bit;
         break;
       }
       case JIT_OPERAND_KIND_MEM: {
         ASSERT(dst[i].loc.mem.addend == 0);
-        uint64_t bit = 1ULL << rn(dst[i].loc.mem.base);
+        uint64_t bit = 1ULL << jit_gpr_regno(dst[i].loc.mem.base);
         dst_mem_base_gprs |= bit;
         break;
       }
@@ -830,7 +830,7 @@ jit_callr(jit_state_t *_jit, jit_gpr_t f, size_t argc, jit_operand_t args[])
 {
   size_t spill_size = prepare_call_args(_jit, argc, args);
 
-  callr(_jit, rn(f));
+  callr(_jit, jit_gpr_regno(f));
 
   if (spill_size)
     jit_addi(_jit, JIT_SP, JIT_SP, spill_size);
diff --git a/libguile/lightening/lightening/x86.h b/libguile/lightening/lightening/x86.h
index c2a2500f2..de47df8a9 100644
--- a/libguile/lightening/lightening/x86.h
+++ b/libguile/lightening/lightening/x86.h
@@ -44,81 +44,33 @@
 #  define __X32    0
 #endif
 
-#if __X32
-#  define _RAX     JIT_GPR(0)
-#  define _RCX     JIT_GPR(1)
-#  define _RDX     JIT_GPR(2)
-#  define _RBX     JIT_GPR(3 | jit_class_sav)
-#  define _RSP     JIT_GPR(4 | jit_class_sav)
-#  define _RBP     JIT_GPR(5 | jit_class_sav)
-#  define _RSI     JIT_GPR(6 | jit_class_sav)
-#  define _RDI     JIT_GPR(7 | jit_class_sav)
-#  define _XMM0    JIT_FPR(0)
-#  define _XMM1    JIT_FPR(1)
-#  define _XMM2    JIT_FPR(2)
-#  define _XMM3    JIT_FPR(3)
-#  define _XMM4    JIT_FPR(4)
-#  define _XMM5    JIT_FPR(5)
-#  define _XMM6    JIT_FPR(6)
-#  define _XMM7    JIT_FPR(7)
-#elif __CYGWIN__
-#  define _RAX     JIT_GPR(0)
-#  define _RCX     JIT_GPR(1)
-#  define _RDX     JIT_GPR(2)
-#  define _RBX     JIT_GPR(3 | jit_class_sav)
-#  define _RSP     JIT_GPR(4 | jit_class_sav)
-#  define _RBP     JIT_GPR(5 | jit_class_sav)
-#  define _RSI     JIT_GPR(6 | jit_class_sav)
-#  define _RDI     JIT_GPR(7 | jit_class_sav)
-#  define _R8      JIT_GPR(8)
-#  define _R9      JIT_GPR(9)
-#  define _R10     JIT_GPR(10)
-#  define _R11     JIT_GPR(11)
-#  define _R12     JIT_GPR(12 | jit_class_sav)
-#  define _R13     JIT_GPR(13 | jit_class_sav)
-#  define _R14     JIT_GPR(14 | jit_class_sav)
-#  define _R15     JIT_GPR(15 | jit_class_sav)
-#  define _XMM0    JIT_FPR(0)
-#  define _XMM1    JIT_FPR(1)
-#  define _XMM2    JIT_FPR(2)
-#  define _XMM3    JIT_FPR(3)
-#  define _XMM4    JIT_FPR(4)
-#  define _XMM5    JIT_FPR(5)
-#  define _XMM6    JIT_FPR(6 | jit_class_sav)
-#  define _XMM7    JIT_FPR(7 | jit_class_sav)
-#  define _XMM8    JIT_FPR(8 | jit_class_sav)
-#  define _XMM9    JIT_FPR(9 | jit_class_sav)
-#  define _XMM10   JIT_FPR(10 | jit_class_sav)
-#  define _XMM11   JIT_FPR(11 | jit_class_sav)
-#  define _XMM12   JIT_FPR(12 | jit_class_sav)
-#  define _XMM13   JIT_FPR(13 | jit_class_sav)
-#  define _XMM14   JIT_FPR(14 | jit_class_sav)
-#  define _XMM15   JIT_FPR(15 | jit_class_sav)
-#else
-#  define _RAX     JIT_GPR(0)
-#  define _RCX     JIT_GPR(1)
-#  define _RDX     JIT_GPR(2)
-#  define _RBX     JIT_GPR(3 | jit_class_sav)
-#  define _RSP     JIT_GPR(4 | jit_class_sav)
-#  define _RBP     JIT_GPR(5 | jit_class_sav)
-#  define _RSI     JIT_GPR(6)
-#  define _RDI     JIT_GPR(7)
+#define _RAX     JIT_GPR(0)
+#define _RCX     JIT_GPR(1)
+#define _RDX     JIT_GPR(2)
+#define _RBX     JIT_GPR(3)
+#define _RSP     JIT_GPR(4)
+#define _RBP     JIT_GPR(5)
+#define _RSI     JIT_GPR(6)
+#define _RDI     JIT_GPR(7)
+
+#define _XMM0    JIT_FPR(0)
+#define _XMM1    JIT_FPR(1)
+#define _XMM2    JIT_FPR(2)
+#define _XMM3    JIT_FPR(3)
+#define _XMM4    JIT_FPR(4)
+#define _XMM5    JIT_FPR(5)
+#define _XMM6    JIT_FPR(6)
+#define _XMM7    JIT_FPR(7)
+
+#if __X64
 #  define _R8      JIT_GPR(8)
 #  define _R9      JIT_GPR(9)
 #  define _R10     JIT_GPR(10)
 #  define _R11     JIT_GPR(11)
-#  define _R12     JIT_GPR(12 | jit_class_sav)
-#  define _R13     JIT_GPR(13 | jit_class_sav)
-#  define _R14     JIT_GPR(14 | jit_class_sav)
-#  define _R15     JIT_GPR(15 | jit_class_sav)
-#  define _XMM0    JIT_FPR(0)
-#  define _XMM1    JIT_FPR(1)
-#  define _XMM2    JIT_FPR(2)
-#  define _XMM3    JIT_FPR(3)
-#  define _XMM4    JIT_FPR(4)
-#  define _XMM5    JIT_FPR(5)
-#  define _XMM6    JIT_FPR(6)
-#  define _XMM7    JIT_FPR(7)
+#  define _R12     JIT_GPR(12)
+#  define _R13     JIT_GPR(13)
+#  define _R14     JIT_GPR(14)
+#  define _R15     JIT_GPR(15)
 #  define _XMM8    JIT_FPR(8)
 #  define _XMM9    JIT_FPR(9)
 #  define _XMM10   JIT_FPR(10)
@@ -129,6 +81,54 @@
 #  define _XMM15   JIT_FPR(15)
 #endif
 
+static inline jit_bool_t
+jit_gpr_is_callee_save (jit_gpr_t reg)
+{
+#if __X32
+  return jit_same_gprs (reg, _RBX) ||
+    jit_same_gprs (reg, _RBP) ||
+    jit_same_gprs (reg, _RSI) ||
+    jit_same_gprs (reg, _RDI);
+#elif __CYGWIN__
+  return jit_same_gprs (reg, _RBX) ||
+    jit_same_gprs (reg, _RBP) ||
+    jit_same_gprs (reg, _RSI) ||
+    jit_same_gprs (reg, _RDI) ||
+    jit_same_gprs (reg, _R12) ||
+    jit_same_gprs (reg, _R13) ||
+    jit_same_gprs (reg, _R14) ||
+    jit_same_gprs (reg, _R15);
+#else
+  return jit_same_gprs (reg, _RBX) ||
+    jit_same_gprs (reg, _RBP) ||
+    jit_same_gprs (reg, _R12) ||
+    jit_same_gprs (reg, _R13) ||
+    jit_same_gprs (reg, _R14) ||
+    jit_same_gprs (reg, _R15);
+#endif
+}
+
+static inline jit_bool_t
+jit_fpr_is_callee_save (jit_fpr_t reg)
+{
+#if __X32
+  return 0;
+#elif __CYGWIN__
+  return jit_same_fprs (reg, _XMM6) ||
+    jit_same_fprs (reg, _XMM7) ||
+    jit_same_fprs (reg, _XMM8) ||
+    jit_same_fprs (reg, _XMM9) ||
+    jit_same_fprs (reg, _XMM10) ||
+    jit_same_fprs (reg, _XMM11) ||
+    jit_same_fprs (reg, _XMM12) ||
+    jit_same_fprs (reg, _XMM13) ||
+    jit_same_fprs (reg, _XMM14) ||
+    jit_same_fprs (reg, _XMM15);
+#else
+  return 0;
+#endif
+}
+
 #define JIT_SP     _RSP
 #define JIT_FP     _RBP
 #if __X32
diff --git a/libguile/lightening/tests/qdivr.c b/libguile/lightening/tests/qdivr.c
index d54c3c181..b4dd8f637 100644
--- a/libguile/lightening/tests/qdivr.c
+++ b/libguile/lightening/tests/qdivr.c
@@ -3,14 +3,14 @@
 static void
 maybe_save(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_gpr_is_callee_save (j, reg))
+  if (jit_gpr_is_callee_save (reg))
     jit_pushr(j, reg);
 }    
 
 static void
 maybe_restore(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_gpr_is_callee_save (j, reg))
+  if (jit_gpr_is_callee_save (reg))
     jit_popr(j, reg);
 }    
 
diff --git a/libguile/lightening/tests/qdivr_u.c b/libguile/lightening/tests/qdivr_u.c
index 0471e9ed2..30849bd54 100644
--- a/libguile/lightening/tests/qdivr_u.c
+++ b/libguile/lightening/tests/qdivr_u.c
@@ -3,14 +3,14 @@
 static void
 maybe_save(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_gpr_is_callee_save (j, reg))
+  if (jit_gpr_is_callee_save (reg))
     jit_pushr(j, reg);
 }    
 
 static void
 maybe_restore(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_gpr_is_callee_save (j, reg))
+  if (jit_gpr_is_callee_save (reg))
     jit_popr(j, reg);
 }    
 
diff --git a/libguile/lightening/tests/qmulr.c b/libguile/lightening/tests/qmulr.c
index 68a2f40dd..9d0b2324e 100644
--- a/libguile/lightening/tests/qmulr.c
+++ b/libguile/lightening/tests/qmulr.c
@@ -3,14 +3,14 @@
 static void
 maybe_save(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_gpr_is_callee_save (j, reg))
+  if (jit_gpr_is_callee_save (reg))
     jit_pushr(j, reg);
 }    
 
 static void
 maybe_restore(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_gpr_is_callee_save (j, reg))
+  if (jit_gpr_is_callee_save (reg))
     jit_popr(j, reg);
 }    
 
diff --git a/libguile/lightening/tests/qmulr_u.c b/libguile/lightening/tests/qmulr_u.c
index f3724e543..741ea8175 100644
--- a/libguile/lightening/tests/qmulr_u.c
+++ b/libguile/lightening/tests/qmulr_u.c
@@ -3,14 +3,14 @@
 static void
 maybe_save(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_gpr_is_callee_save (j, reg))
+  if (jit_gpr_is_callee_save (reg))
     jit_pushr(j, reg);
 }    
 
 static void
 maybe_restore(jit_state_t *j, jit_gpr_t reg)
 {
-  if (jit_gpr_is_callee_save (j, reg))
+  if (jit_gpr_is_callee_save (reg))
     jit_popr(j, reg);
 }