Merge from upstream lightening

213 files changed, 1249 insertions, 2116 deletions

diff --git a/libguile/lightening/.gitlab-ci.yml b/libguile/lightening/.gitlab-ci.yml
index 384befa31..891112e87 100644
--- a/libguile/lightening/.gitlab-ci.yml
+++ b/libguile/lightening/.gitlab-ci.yml
@@ -1,9 +1,19 @@
 # use the official gcc image, based on debian
 # can use verions as well, like gcc:5.2
 # see https://hub.docker.com/_/gcc/
-image: gcc
+image: debian
 
-test:
+before_script:
+  - dpkg --add-architecture i386
+  - apt-get update -qq
+  - apt-get install -y libc6-dev:amd64 libc6-dev:i386 gcc gcc-multilib make
+
+x86-64:
+  stage: test
+  script:
+    - make -C tests test-native
+
+i686:
   stage: test
   script:
-    - make -C tests check
+    - make -C tests test-ia32
diff --git a/libguile/lightening/lightening.h b/libguile/lightening/lightening.h
index 437ba1872..40db318bb 100644
--- a/libguile/lightening/lightening.h
+++ b/libguile/lightening/lightening.h
@@ -124,8 +124,8 @@ enum jit_operand_abi
   JIT_OPERAND_ABI_POINTER,
   JIT_OPERAND_ABI_FLOAT,
   JIT_OPERAND_ABI_DOUBLE,
-  JIT_OPERAND_ABI_INTMAX = CHOOSE_32_64(JIT_OPERAND_ABI_INT32,
-                                        JIT_OPERAND_ABI_INT64)
+  JIT_OPERAND_ABI_WORD = CHOOSE_32_64(JIT_OPERAND_ABI_INT32,
+                                      JIT_OPERAND_ABI_INT64)
 };
 
 enum jit_operand_kind
@@ -228,6 +228,11 @@ JIT_API void jit_move_operands (jit_state_t *_jit, jit_operand_t *dst,
 JIT_API size_t jit_align_stack (jit_state_t *_jit, size_t expand);
 JIT_API void jit_shrink_stack (jit_state_t *_jit, size_t diff);
 
+JIT_API size_t jit_enter_jit_abi (jit_state_t *_jit,
+                                  size_t v, size_t vf, size_t frame_size);
+JIT_API void jit_leave_jit_abi (jit_state_t *_jit,
+                                size_t v, size_t vf, size_t frame_size);
+
 /* Note that all functions that take jit_operand_t args[] use the args
    as scratch space while shuffling values into position.  */
 JIT_API void jit_calli(jit_state_t *, jit_pointer_t f,
diff --git a/libguile/lightening/lightening/aarch64.c b/libguile/lightening/lightening/aarch64.c
index 332c4c0c6..65efb74c3 100644
--- a/libguile/lightening/lightening/aarch64.c
+++ b/libguile/lightening/lightening/aarch64.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2018  Free Software Foundation, Inc.
+ * Copyright (C) 2013-2019  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
  *
@@ -17,6 +17,12 @@
  *	Paulo Cesar Pereira de Andrade
  */
 
+# define JIT_RA0                _R0
+# define JIT_FA0                _V0
+# define JIT_SP         _SP
+# define JIT_RET                _R0
+# define JIT_FRET               _V0
+
 #define jit_arg_reg_p(i)		((i) >= 0 && (i) < 8)
 #define jit_arg_f_reg_p(i)		((i) >= 0 && (i) < 8)
 
diff --git a/libguile/lightening/lightening/alpha.c b/libguile/lightening/lightening/alpha.c
index 1f1e40634..71e7f8413 100644
--- a/libguile/lightening/lightening/alpha.c
+++ b/libguile/lightening/lightening/alpha.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014-2018  Free Software Foundation, Inc.
+ * Copyright (C) 2014-2019  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
  *
@@ -17,6 +17,10 @@
  *	Paulo Cesar Pereira de Andrade
  */
 
+# define JIT_SP         _SP
+# define JIT_RET                _V0
+# define JIT_FRET               _F0
+
 #define jit_arg_reg_p(i)		((i) >= 0 && (i) < 6)
 #define jit_arg_f_reg_p(i)		((i) >= 0 && (i) < 6)
 #if __BYTE_ORDER == __LITTLE_ENDIAN
diff --git a/libguile/lightening/lightening/arm.c b/libguile/lightening/lightening/arm.c
index ef4a3e2e7..0df47814e 100644
--- a/libguile/lightening/lightening/arm.c
+++ b/libguile/lightening/lightening/arm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2018  Free Software Foundation, Inc.
+ * Copyright (C) 2012-2019  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
  *
@@ -21,6 +21,16 @@
 #  include <stdio.h>
 #endif
 
+# define JIT_RA0                _R0
+# define JIT_FA0                _D0
+# define JIT_SP         _R13
+# define JIT_RET                _R0
+# if defined(__ARM_PCS_VFP)
+#  define JIT_FRET              _D0
+# else
+#  define JIT_FRET              _R0
+# endif
+
 #define jit_arg_reg_p(i)		((i) >= 0 && (i) < 4)
 #define jit_arg_f_reg_p(i)		((i) >= 0 && (i) < 16)
 #define jit_arg_d_reg_p(i)		((i) >= 0 && (i) < 15)
diff --git a/libguile/lightening/lightening/hppa.c b/libguile/lightening/lightening/hppa.c
index 38c75e0ca..d6c56cb44 100644
--- a/libguile/lightening/lightening/hppa.c
+++ b/libguile/lightening/lightening/hppa.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2018  Free Software Foundation, Inc.
+ * Copyright (C) 2013-2019  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
  *
@@ -17,6 +17,10 @@
  *	Paulo Cesar Pereira de Andrade
  */
 
+# define JIT_SP         _R30
+# define JIT_RET                _R28
+# define JIT_FRET               _F4
+
 #define jit_arg_reg_p(i)		(i >= 0 && i < 4)
 
 #define PROTO				1
diff --git a/libguile/lightening/lightening/ia64.c b/libguile/lightening/lightening/ia64.c
index 185d41cbf..9c025116c 100644
--- a/libguile/lightening/lightening/ia64.c
+++ b/libguile/lightening/lightening/ia64.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2018  Free Software Foundation, Inc.
+ * Copyright (C) 2013-2019  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
  *
@@ -17,6 +17,10 @@
  *	Paulo Cesar Pereira de Andrade
  */
 
+# define JIT_SP         _R12
+# define JIT_RET                _R8
+# define JIT_FRET               _F8
+
 #define jit_arg_reg_p(i)		((i) >= 0 && (i) < 8)
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 #  define C_DISP			0
diff --git a/libguile/lightening/lightening/lightening.c b/libguile/lightening/lightening/lightening.c
index faba86bdb..842667267 100644
--- a/libguile/lightening/lightening/lightening.c
+++ b/libguile/lightening/lightening/lightening.c
@@ -37,69 +37,6 @@
 
 #define _NOREG 0xffff
 
-#if defined(__i386__) || defined(__x86_64__)
-# define JIT_RET                _RAX
-# if __X32
-#  define JIT_FRET              _ST0
-# else
-#  if __CYGWIN__
-#   define JIT_RA0              _RCX
-#  else
-#   define JIT_RA0              _RDI
-#  endif
-#  define JIT_FA0               _XMM0
-#  define JIT_FRET              _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
-#elif defined(__arm__)
-# define JIT_RA0                _R0
-# define JIT_FA0                _D0
-# define JIT_SP         _R13
-# define JIT_RET                _R0
-# if defined(__ARM_PCS_VFP)
-#  define JIT_FRET              _D0
-# else
-#  define JIT_FRET              _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
-#elif defined(__sparc__)
-# define JIT_SP         _SP
-# define JIT_RET                _I0
-# define JIT_FRET               _F0
-#elif defined(__ia64__)
-# define JIT_SP         _R12
-# define JIT_RET                _R8
-# define JIT_FRET               _F8
-#elif defined(__hppa__)
-# define JIT_SP         _R30
-# define JIT_RET                _R28
-# define JIT_FRET               _F4
-#elif defined(__aarch64__)
-# define JIT_RA0                _R0
-# define JIT_FA0                _V0
-# define JIT_SP         _SP
-# define JIT_RET                _R0
-# define JIT_FRET               _V0
-#elif defined(__s390__) || defined(__s390x__)
-# define JIT_SP         _R15
-# define JIT_RET                _R2
-# define JIT_FRET               _F0
-#elif defined(__alpha__)
-# define JIT_SP         _SP
-# define JIT_RET                _V0
-# define JIT_FRET               _F0
-#endif
-
 union jit_pc
 {
   uint8_t *uc;
@@ -137,6 +74,13 @@ static void jit_flush(void *fptr, void *tptr);
 static void jit_try_shorten(jit_state_t *_jit, jit_reloc_t reloc,
                             jit_pointer_t addr);
 
+struct abi_arg_iterator;
+
+static void reset_abi_arg_iterator(struct abi_arg_iterator *iter, size_t argc,
+                                   const jit_operand_t *args);
+static void next_abi_arg(struct abi_arg_iterator *iter,
+                         jit_operand_t *arg);
+
 jit_bool_t
 init_jit(void)
 {
@@ -574,21 +518,23 @@ abi_mem_to_gpr(jit_state_t *_jit, enum jit_operand_abi abi,
   case JIT_OPERAND_ABI_INT16:
     jit_ldxi_s(_jit, dst, base, offset);
     break;
+#if __WORDSIZE == 32
   case JIT_OPERAND_ABI_UINT32:
-    jit_ldxi_ui(_jit, dst, base, offset);
-    break;
+  case JIT_OPERAND_ABI_POINTER:
+#endif
   case JIT_OPERAND_ABI_INT32:
     jit_ldxi_i(_jit, dst, base, offset);
     break;
-  case JIT_OPERAND_ABI_UINT64:
-    jit_ldxi_l(_jit, dst, base, offset);
-    break;
-  case JIT_OPERAND_ABI_INT64:
-    jit_ldxi_l(_jit, dst, base, offset);
+#if __WORDSIZE == 64
+  case JIT_OPERAND_ABI_UINT32:
+    jit_ldxi_ui(_jit, dst, base, offset);
     break;
+  case JIT_OPERAND_ABI_UINT64:
   case JIT_OPERAND_ABI_POINTER:
+  case JIT_OPERAND_ABI_INT64:
     jit_ldxi_l(_jit, dst, base, offset);
     break;
+#endif
   default:
     abort();
   }
@@ -612,7 +558,7 @@ abi_mem_to_fpr(jit_state_t *_jit, enum jit_operand_abi abi,
 
 static void
 abi_imm_to_mem(jit_state_t *_jit, enum jit_operand_abi abi, jit_gpr_t base,
-               ptrdiff_t offset, intmax_t imm)
+               ptrdiff_t offset, jit_imm_t imm)
 {
   ASSERT(!is_fpr_arg(abi));
 
@@ -893,7 +839,7 @@ jit_align_stack(jit_state_t *_jit, size_t expand)
   size_t new_size = _jit->frame_size + expand;
   // Align stack to double-word boundaries.  This isn't really a
   // principle but it does work for Aarch32, AArch64 and x86-64.
-  size_t alignment = __WORDSIZE * 2;
+  size_t alignment = jit_stack_alignment ();
   size_t aligned_size = (new_size + alignment - 1) & ~(alignment - 1);
   size_t diff = aligned_size - _jit->frame_size;
   if (diff)
@@ -910,6 +856,107 @@ jit_shrink_stack(jit_state_t *_jit, size_t diff)
   _jit->frame_size -= diff;
 }
 
+static const jit_gpr_t V[] = {
+#ifdef JIT_VTMP
+  JIT_VTMP ,
+#endif
+  JIT_V0, JIT_V1, JIT_V2
+#ifdef JIT_V3
+  , JIT_V3
+#endif
+#ifdef JIT_V4
+  , JIT_V4
+#endif
+#ifdef JIT_V5
+  , JIT_V5
+#endif
+#ifdef JIT_V6
+  , JIT_V6
+#endif
+#ifdef JIT_V7
+  , JIT_V7
+#endif
+ };
+
+static const jit_fpr_t VF[] = {
+#ifdef JIT_VFTMP
+  JIT_VFTMP ,
+#endif
+#ifdef JIT_VF0
+  JIT_VF0
+#endif
+#ifdef JIT_VF1
+  , JIT_VF1
+#endif
+#ifdef JIT_VF2
+  , JIT_VF2
+#endif
+#ifdef JIT_VF3
+  , JIT_VF3
+#endif
+#ifdef JIT_VF4
+  , JIT_VF4
+#endif
+#ifdef JIT_VF5
+  , JIT_VF5
+#endif
+#ifdef JIT_VF6
+  , JIT_VF6
+#endif
+#ifdef JIT_VF7
+  , JIT_VF7
+#endif
+};
+
+static const size_t v_count = sizeof(V) / sizeof(V[0]);
+static const size_t vf_count = sizeof(VF) / sizeof(VF[0]);
+
+size_t
+jit_enter_jit_abi(jit_state_t *_jit, size_t v, size_t vf, size_t frame_size)
+{
+#ifdef JIT_VTMP
+  v++;
+#endif
+#ifdef JIT_VFTMP
+  vf++;
+#endif
+
+  ASSERT(v <= v_count);
+  ASSERT(vf <= vf_count);
+
+  ASSERT(_jit->frame_size == 0);
+  _jit->frame_size = jit_initial_frame_size();
+
+  /* Save values of callee-save registers.  */
+  for (size_t i = 0; i < v; i++)
+    jit_pushr (_jit, V[i]);
+  for (size_t i = 0; i < vf; i++)
+    jit_pushr_d (_jit, VF[i]);
+
+  return jit_align_stack(_jit, frame_size);
+}
+
+void
+jit_leave_jit_abi(jit_state_t *_jit, size_t v, size_t vf, size_t frame_size)
+{
+#ifdef JIT_VTMP
+  v++;
+#endif
+#ifdef JIT_VFTMP
+  vf++;
+#endif
+
+  jit_shrink_stack(_jit, frame_size);
+
+  /* Restore callee-save registers.  */
+  for (size_t i = 0; i < vf; i++)
+    jit_popr_d (_jit, VF[vf - i - 1]);
+
+  for (size_t i = 0; i < v; i++)
+    jit_popr (_jit, V[v - i - 1]);
+}
+
+
 // Precondition: stack is already aligned.
 static size_t
 prepare_call_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
@@ -972,6 +1019,7 @@ jit_locate_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
   struct abi_arg_iterator iter;
     
   reset_abi_arg_iterator(&iter, argc, args);
+  iter.stack_size += _jit->frame_size;
   for (size_t i = 0; i < argc; i++)
     next_abi_arg(&iter, &args[i]);
 }
diff --git a/libguile/lightening/lightening/mips.c b/libguile/lightening/lightening/mips.c
index 70b2d94ea..3b2370f29 100644
--- a/libguile/lightening/lightening/mips.c
+++ b/libguile/lightening/lightening/mips.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2018  Free Software Foundation, Inc.
+ * Copyright (C) 2012-2019  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
  *
@@ -21,6 +21,12 @@
 #  include <sys/cachectl.h>
 #endif
 
+# define JIT_RA0                _A0
+# define JIT_FA0                _F12
+# define JIT_SP         _SP
+# define JIT_RET                _V0
+# define JIT_FRET               _F0
+
 #if NEW_ABI
 #  define NUM_WORD_ARGS			8
 #  define STACK_SLOT			8
diff --git a/libguile/lightening/lightening/ppc.c b/libguile/lightening/lightening/ppc.c
index a6502cbac..1819acdf6 100644
--- a/libguile/lightening/lightening/ppc.c
+++ b/libguile/lightening/lightening/ppc.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2018  Free Software Foundation, Inc.
+ * Copyright (C) 2012-2019  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
  *
@@ -17,6 +17,12 @@
  *	Paulo Cesar Pereira de Andrade
  */
 
+# define JIT_RA0                _R3
+# define JIT_FA0                _F1
+# define JIT_SP         _R1
+# define JIT_RET                _R3
+# define JIT_FRET               _F1
+
 #define jit_arg_reg_p(i)		((i) >= 0 && (i) < 8)
 #define jit_arg_f_reg_p(i)		((i) >= 0 && (i) < 13)
 #if __BYTE_ORDER == __LITTLE_ENDIAN
diff --git a/libguile/lightening/lightening/s390.c b/libguile/lightening/lightening/s390.c
index 0dc109a9f..41e0de42f 100644
--- a/libguile/lightening/lightening/s390.c
+++ b/libguile/lightening/lightening/s390.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2018  Free Software Foundation, Inc.
+ * Copyright (C) 2013-2019  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
  *
@@ -17,6 +17,10 @@
  *	Paulo Cesar Pereira de Andrade
  */
 
+# define JIT_SP         _R15
+# define JIT_RET                _R2
+# define JIT_FRET               _F0
+
 #if __WORDSIZE == 32
 #  define NUM_FLOAT_REG_ARGS		2
 #else
diff --git a/libguile/lightening/lightening/sparc.c b/libguile/lightening/lightening/sparc.c
index 10aac8528..415f21335 100644
--- a/libguile/lightening/lightening/sparc.c
+++ b/libguile/lightening/lightening/sparc.c
@@ -1,4 +1,26 @@
 /*
+ * Copyright (C) 2013-2019  Free Software Foundation, Inc.
+ *
+ * This file is part of GNU lightning.
+ *
+ * GNU lightning is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU lightning is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ * License for more details.
+ *
+ * Authors:
+ *	Paulo Cesar Pereira de Andrade
+ */
+
+# define JIT_SP         _SP
+# define JIT_RET                _I0
+# define JIT_FRET               _F0
+/*
  * Copyright (C) 2013-2018  Free Software Foundation, Inc.
  *
  * This file is part of GNU lightning.
diff --git a/libguile/lightening/lightening/x86-cpu.c b/libguile/lightening/lightening/x86-cpu.c
index aa9d68a68..fab06c7f4 100644
--- a/libguile/lightening/lightening/x86-cpu.c
+++ b/libguile/lightening/lightening/x86-cpu.c
@@ -20,7 +20,7 @@
 /* avoid using it due to partial stalls */
 #define USE_INC_DEC                     0
 
-#if __X32 || __X64_32
+#if __X32
 # define WIDE 0
 # define IF_WIDE(wide, narrow) narrow
 #else
@@ -46,7 +46,7 @@
 #define _R15_REGNO                      15
 #define r7(reg)                 ((reg) & 7)
 #define r8(reg)                 ((reg) & 15)
-#if __X32 || __CYGWIN__ || __X64_32
+#if __X32
 # define reg8_p(rn) ((rn) >= _RAX_REGNO && (rn) <= _RBX_REGNO)
 #else
 # define reg8_p(rn) 1
@@ -160,15 +160,13 @@ ii(jit_state_t *_jit, uint32_t i)
   emit_u32(_jit, i);
 }
 
+#if __X64
 static inline void
-il(jit_state_t *_jit, unsigned long l)
+il(jit_state_t *_jit, uint64_t l)
 {
-#if __X64 && !__X64_32
   emit_u64(_jit, l);
-#else
-  ii(_jit, l);
-#endif
 }
+#endif
 
 static void
 rex(jit_state_t *_jit, int32_t l, int32_t w,
@@ -254,7 +252,7 @@ rx(jit_state_t *_jit, int32_t rd, int32_t md,
 static void
 pushr(jit_state_t *_jit, int32_t r0)
 {
-  _jit->frame_size += __WORDSIZE;
+  _jit->frame_size += __WORDSIZE / 8;
   rex(_jit, 0, WIDE, 0, 0, r0);
   ic(_jit, 0x50 | r7(r0));
 }
@@ -262,7 +260,7 @@ pushr(jit_state_t *_jit, int32_t r0)
 static void
 popr(jit_state_t *_jit, int32_t r0)
 {
-  _jit->frame_size -= __WORDSIZE;
+  _jit->frame_size -= __WORDSIZE / 8;
   rex(_jit, 0, WIDE, 0, 0, r0);
   ic(_jit, 0x58 | r7(r0));
 }
@@ -275,8 +273,7 @@ get_temp_gpr(jit_state_t *_jit)
 #ifdef JIT_RTMP
   return JIT_RTMP;
 #else
-  pushr(_jit, _RBP_REGNO);
-  return _RBP;
+  return JIT_VTMP;
 #endif
 }
 
@@ -285,9 +282,6 @@ unget_temp_gpr(jit_state_t *_jit)
 {
   ASSERT(_jit->temp_gpr_saved);
   _jit->temp_gpr_saved = 0;
-#ifndef JIT_RTMP
-  popr(_jit, _RBP_REGNO);
-#endif
 }
 
 static void
@@ -410,19 +404,15 @@ static void
 imovi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
 #if __X64
-#  if !__X64_32
   if (fits_uint32_p(i0)) {
-#  endif
     rex(_jit, 0, 0, _NOREG, _NOREG, r0);
     ic(_jit, 0xb8 | r7(r0));
     ii(_jit, i0);
-#  if !__X64_32
   } else {
     rex(_jit, 0, 1, _NOREG, _NOREG, r0);
     ic(_jit, 0xb8 | r7(r0));
     il(_jit, i0);
   }
-#  endif
 #else
   ic(_jit, 0xb8 | r7(r0));
   ii(_jit, i0);
@@ -1024,7 +1014,7 @@ ffsw(jit_word_t i)
     return ffs(i);
   int bit = ffs((int)i);
   if (bit == 0) {
-    bit = ffs((int)((unsigned long)i >> 32));
+    bit = ffs((int)((uint64_t)i >> 32));
     if (bit)
       bit += 32;
   }
@@ -1494,7 +1484,7 @@ extr_us(jit_state_t *_jit, int32_t r0, int32_t r1)
   return movsr_u(_jit, r0, r1);
 }
 
-#if __X64 && !__X64_32
+#if __X64
 static void
 extr_i(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
@@ -1527,7 +1517,7 @@ bswapr_ui(jit_state_t *_jit, int32_t r0, int32_t r1)
   ic(_jit, 0xc8 | r7(r0));
 }
 
-#if __X64 && !__X64_32
+#if __X64
 static void
 bswapr_ul(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
@@ -1638,7 +1628,6 @@ ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
   }
 }
 
-#if __X32 || !__X64_32
 static void
 ldr_i(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
@@ -1669,7 +1658,6 @@ ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     unget_temp_gpr(_jit);
   }
 }
-#endif
 
 #if __X64
 static void
@@ -1695,7 +1683,6 @@ ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
   }
 }
 
-#  if !__X64_32
 static void
 ldr_l(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
@@ -1718,21 +1705,15 @@ ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
     unget_temp_gpr(_jit);
   }
 }
-#  endif
 #endif
 
 static void
 ldxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
-#if __X64_32
-  addr(_jit, r0, r1, r2);
-  ldr_c(r0, r0);
-#else
   rex(_jit, 0, WIDE, r0, r1, r2);
   ic(_jit, 0x0f);
   ic(_jit, 0xbe);
   rx(_jit, r0, 0, r2, r1, _SCL1);
-#endif
 }
 
 static void
@@ -1754,15 +1735,10 @@ ldxi_c(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
 static void
 ldxr_uc(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
-#if __X64_32
-  addr(_jit, r0, r1, r2);
-  ldr_uc(_jit, r0, r0);
-#else
   rex(_jit, 0, WIDE, r0, r1, r2);
   ic(_jit, 0x0f);
   ic(_jit, 0xb6);
   rx(_jit, r0, 0, r2, r1, _SCL1);
-#endif
 }
 
 static void
@@ -1784,15 +1760,10 @@ ldxi_uc(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
 static void
 ldxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
-#if __X64_32
-  addr(_jit, r0, r1, r2);
-  ldr_s(_jit, r0, r0);
-#else
   rex(_jit, 0, WIDE, r0, r1, r2);
   ic(_jit, 0x0f);
   ic(_jit, 0xbf);
   rx(_jit, r0, 0, r2, r1, _SCL1);
-#endif
 }
 
 static void
@@ -1814,15 +1785,10 @@ ldxi_s(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
 static void
 ldxr_us(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
-#if __X64_32
-  addr(_jit, r0, r1, r2);
-  ldr_us(_jit, r0, r0);
-#else
   rex(_jit, 0, WIDE, r0, r1, r2);
   ic(_jit, 0x0f);
   ic(_jit, 0xb7);
   rx(_jit, r0, 0, r2, r1, _SCL1);
-#endif
 }
 
 static void
@@ -1841,7 +1807,6 @@ ldxi_us(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   }
 }
 
-#if __X64 || !__X64_32
 static void
 ldxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
@@ -1872,21 +1837,14 @@ ldxi_i(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     unget_temp_gpr(_jit);
   }
 }
-#endif
 
 #if __X64
 static void
 ldxr_ui(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
-#if __X64_32
-  addr(_jit, r0, r1, r2);
-  /* to avoid confusion with macro renames */
-  _ldr_ui(_jit, r0, r0);
-#else
   rex(_jit, 0, 0, r0, r1, r2);
   ic(_jit, 0x8b);
   rx(_jit, r0, 0, r2, r1, _SCL1);
-#endif
 }
 
 static void
@@ -1904,7 +1862,6 @@ ldxi_ui(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
   }
 }
 
-#  if !__X64_32
 static void
 ldxr_l(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
@@ -1927,7 +1884,6 @@ ldxi_l(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     unget_temp_gpr(_jit);
   }
 }
-#  endif
 #endif
 
 static void
@@ -2019,7 +1975,7 @@ sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
   }
 }
 
-#if __X64 && !__X64_32
+#if __X64
 static void
 str_l(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
@@ -2047,12 +2003,6 @@ sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 static void
 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, jit_gpr_regno(reg), r0, r1);
-  str_c(_jit, jit_gpr_regno(reg), r2);
-  unget_temp_gpr(_jit);
-#else
   if (reg8_p(r2)) {
     rex(_jit, 0, 0, r2, r1, r0);
     ic(_jit, 0x88);
@@ -2065,7 +2015,6 @@ stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
     rx(_jit, jit_gpr_regno(reg), 0, r0, r1, _SCL1);
     unget_temp_gpr(_jit);
   }
-#endif
 }
 
 static void
@@ -2095,17 +2044,10 @@ stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
 static void
 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, jit_gpr_regno(reg), r0, r1);
-  str_s(_jit, jit_gpr_regno(reg), r2);
-  unget_temp_gpr(_jit);
-#else
   ic(_jit, 0x66);
   rex(_jit, 0, 0, r2, r1, r0);
   ic(_jit, 0x89);
   rx(_jit, r2, 0, r0, r1, _SCL1);
-#endif
 }
 
 static void
@@ -2127,16 +2069,9 @@ stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
 static void
 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, 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);
   ic(_jit, 0x89);
   rx(_jit, r2, 0, r0, r1, _SCL1);
-#endif
 }
 
 static void
@@ -2154,7 +2089,7 @@ stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
   }
 }
 
-#if __X64 && !__X64_32
+#if __X64
 static void
 stxr_l(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
 {
@@ -2664,47 +2599,47 @@ reti(jit_state_t *_jit, jit_word_t i0)
 static void
 retval_c(jit_state_t *_jit, int32_t r0)
 {
-  extr_c(_jit, r0, jit_gpr_regno(JIT_RET));
+  extr_c(_jit, r0, _RAX_REGNO);
 }
 
 static void
 retval_uc(jit_state_t *_jit, int32_t r0)
 {
-  extr_uc(_jit, r0, jit_gpr_regno(JIT_RET));
+  extr_uc(_jit, r0, _RAX_REGNO);
 }
 
 static void
 retval_s(jit_state_t *_jit, int32_t r0)
 {
-  extr_s(_jit, r0, jit_gpr_regno(JIT_RET));
+  extr_s(_jit, r0, _RAX_REGNO);
 }
 
 static void
 retval_us(jit_state_t *_jit, int32_t r0)
 {
-  extr_us(_jit, r0, jit_gpr_regno(JIT_RET));
+  extr_us(_jit, r0, _RAX_REGNO);
 }
 
 static void
 retval_i(jit_state_t *_jit, int32_t r0)
 {
-#if __X32 || __X64_32
-  movr(_jit, r0, jit_gpr_regno(JIT_RET));
+#if __X32
+  movr(_jit, r0, _RAX_REGNO);
 #else
-  extr_i(_jit, r0, jit_gpr_regno(JIT_RET));
+  extr_i(_jit, r0, _RAX_REGNO);
 #endif
 }
 
-#if __X64 && !__X64_32
+#if __X64
 static void
 retval_ui(jit_state_t *_jit, int32_t r0)
 {
-  extr_ui(_jit, r0, jit_gpr_regno(JIT_RET));
+  extr_ui(_jit, r0, _RAX_REGNO);
 }
 
 static void
 retval_l(jit_state_t *_jit, int32_t r0)
 {
-  movr(_jit, r0, jit_gpr_regno(JIT_RET));
+  movr(_jit, r0, _RAX_REGNO);
 }
 #endif
diff --git a/libguile/lightening/lightening/x86-sse.c b/libguile/lightening/lightening/x86-sse.c
index bc6c060ff..3aca97fd1 100644
--- a/libguile/lightening/lightening/x86-sse.c
+++ b/libguile/lightening/lightening/x86-sse.c
@@ -101,7 +101,7 @@ ssexi(jit_state_t *_jit, int32_t c, int32_t r0,
 static void
 sselxr(jit_state_t *_jit, int32_t p, int32_t c, int32_t r0, int32_t r1)
 {
-  if (__X64 && !__X64_32) {
+  if (__X64) {
     ic(_jit, p);
     rex(_jit, 0, 1, r0, 0, r1);
     ic(_jit, 0x0f);
@@ -316,6 +316,11 @@ xorpdr(jit_state_t *_jit, int32_t r0, int32_t r1)
   ssexr(_jit, 0x66, X86_SSE_XOR, r0, r1);
 }
 static void
+orpdr(jit_state_t *_jit, int32_t r0, int32_t r1)
+{
+  ssexr(_jit, 0x66, X86_SSE_OR, r0, r1);
+}
+static void
 pcmpeqlr(jit_state_t *_jit, int32_t r0, int32_t r1)
 {
   ssexr(_jit, 0x66, X86_SSE_EQD, r0, r1);
@@ -398,49 +403,111 @@ 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 {
-    jit_gpr_t reg = get_temp_gpr(_jit);
-#if __X64 && !__X64_32
-    movi(_jit, jit_gpr_regno(reg), data.w);
-    movdqxr(_jit, r0, jit_gpr_regno(reg));
+    jit_gpr_t ireg = get_temp_gpr(_jit);
+#if __X64
+    movi(_jit, jit_gpr_regno(ireg), data.w);
+    movdqxr(_jit, r0, jit_gpr_regno(ireg));
     unget_temp_gpr(_jit);
 #else
-    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));
+    jit_fpr_t freg = get_temp_xpr(_jit);
+    movi(_jit, jit_gpr_regno(ireg), data.ii[1]);
+    movdlxr(_jit, jit_fpr_regno(freg), jit_gpr_regno(ireg));
+    pslq(_jit, jit_fpr_regno(freg), 32);
+    movi(_jit, jit_gpr_regno(ireg), data.ii[0]);
+    movdlxr(_jit, r0, jit_gpr_regno(ireg));
+    orpdr(_jit, r0, jit_fpr_regno(freg));
+    unget_temp_xpr(_jit);
     unget_temp_gpr(_jit);
-    ldxi_d(_jit, r0, _RBP_REGNO, CVT_OFFSET);
 #endif
   }
 }
 
+#if __X32
+static void
+x87rx(jit_state_t *_jit, int32_t code, int32_t md,
+      int32_t rb, int32_t ri, int32_t ms)
+{
+  rex(_jit, 0, 1, rb, ri, _NOREG);
+  ic(_jit, 0xd8 | (code >> 3));
+  rx(_jit, (code & 7), md, rb, ri, ms);
+}
+
+static void
+fldsm(jit_state_t *_jit, int32_t md, int32_t rb, int32_t ri, int32_t ms)
+{
+  return x87rx(_jit, 010, md, rb, ri, ms);
+}
+
+static void
+fstsm(jit_state_t *_jit, int32_t md, int32_t rb, int32_t ri, int32_t ms)
+{
+  return x87rx(_jit, 012, md, rb, ri, ms);
+}
+
+static void
+fldlm(jit_state_t *_jit, int32_t md, int32_t rb, int32_t ri, int32_t ms)
+{
+  return x87rx(_jit, 050, md, rb, ri, ms);
+}
+
+static void
+fstlm(jit_state_t *_jit, int32_t md, int32_t rb, int32_t ri, int32_t ms)
+{
+  return x87rx(_jit, 052, md, rb, ri, ms);
+}
+#endif
+
 static void
 retval_f(jit_state_t *_jit, int32_t r0)
 {
-#if __X64
-  movr_f(_jit, r0, jit_fpr_regno(JIT_FRET));
+#if __X32
+  subi(_jit, _RSP_REGNO, _RSP_REGNO, 4);
+  fstsm(_jit, 0, _RSP_REGNO, _NOREG, _SCL1);
+  ldr_f(_jit, r0, _RSP_REGNO);
+  addi(_jit, _RSP_REGNO, _RSP_REGNO, 4);
+#else
+  movr_f(_jit, r0, _XMM0_REGNO);
 #endif
 }
 
 static void
 retval_d(jit_state_t *_jit, int32_t r0)
 {
-#if __X64
-  movr_d(_jit, r0, jit_fpr_regno(JIT_FRET));
+#if __X32
+  subi(_jit, _RSP_REGNO, _RSP_REGNO, 8);
+  fstlm(_jit, 0, _RSP_REGNO, _NOREG, _SCL1);
+  ldr_d(_jit, r0, _RSP_REGNO);
+  addi(_jit, _RSP_REGNO, _RSP_REGNO, 8);
+#else
+  movr_d(_jit, r0, _XMM0_REGNO);
 #endif
 }
 
 static void
 retr_f(jit_state_t *_jit, int32_t u)
 {
-  movr_f(_jit, jit_fpr_regno(JIT_FRET), u);
+#if __X32
+  subi(_jit, _RSP_REGNO, _RSP_REGNO, 4);
+  str_f(_jit, _RSP_REGNO, u);
+  fldsm(_jit, 0, _RSP_REGNO, _NOREG, _SCL1);
+  addi(_jit, _RSP_REGNO, _RSP_REGNO, 4);
+#else
+  movr_f(_jit, _XMM0_REGNO, u);
+#endif
   ret(_jit);
 }
 
 static void
 retr_d(jit_state_t *_jit, int32_t u)
 {
-  movr_d(_jit, jit_fpr_regno(JIT_FRET), u);
+#if __X32
+  subi(_jit, _RSP_REGNO, _RSP_REGNO, 8);
+  str_d(_jit, _RSP_REGNO, u);
+  fldlm(_jit, 0, _RSP_REGNO, _NOREG, _SCL1);
+  addi(_jit, _RSP_REGNO, _RSP_REGNO, 8);
+#else
+  movr_d(_jit, _XMM0_REGNO, u);
+#endif
   ret(_jit);
 }
 
@@ -638,18 +705,10 @@ negr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
   unget_temp_gpr(_jit);
 }
 
-#if __X32
-# define sse_address_p(i0) 1
-#elif __X64_32
-# define sse_address_p(i0) ((jit_word_t)(i0) >= 0)
-# else
-# define sse_address_p(i0) can_sign_extend_int_p(i0)
-#endif
-
 static void
 ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-  if (sse_address_p(i0))
+  if (can_sign_extend_int_p(i0))
     movssmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
@@ -662,14 +721,7 @@ ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 static void
 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, 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);
-#endif
 }
 
 static void
@@ -679,13 +731,8 @@ ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     movssmr(_jit, i0, r1, _NOREG, _SCL1, r0);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-#if __X64_32
-    addi(jit_gpr_regno(reg), r1, i0);
-    ldr_f(_jit, r0, jit_gpr_regno(reg));
-#else
     movi(_jit, jit_gpr_regno(reg), i0);
     ldxr_f(_jit, r0, r1, jit_gpr_regno(reg));
-#endif
     unget_temp_gpr(_jit);
   }
 }
@@ -693,7 +740,7 @@ ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
 static void
 sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-  if (sse_address_p(i0))
+  if (can_sign_extend_int_p(i0))
     movssrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
@@ -706,14 +753,7 @@ sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 static void
 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, 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);
-#endif
 }
 
 static void
@@ -723,13 +763,8 @@ stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
     movssrm(_jit, r1, i0, r0, _NOREG, _SCL1);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-#if __X64_32
-    addi(jit_gpr_regno(reg), r0, i0);
-    str_f(_jit, jit_gpr_regno(reg), r1);
-#else
     movi(_jit, jit_gpr_regno(reg), i0);
     stxr_f(_jit, jit_gpr_regno(reg), r0, r1);
-#endif
     unget_temp_gpr(_jit);
   }
 }
@@ -843,7 +878,7 @@ bunordr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
 static void
 ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-  if (sse_address_p(i0))
+  if (can_sign_extend_int_p(i0))
     movsdmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
@@ -856,14 +891,7 @@ ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 static void
 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, 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);
-#endif
 }
 
 static void
@@ -873,13 +901,8 @@ ldxi_d(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
     movsdmr(_jit, i0, r1, _NOREG, _SCL1, r0);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-#if __X64_32
-    addi(jit_gpr_regno(reg), r1, i0);
-    ldr_d(_jit, r0, jit_gpr_regno(reg));
-#else
     movi(_jit, jit_gpr_regno(reg), i0);
     ldxr_d(_jit, r0, r1, jit_gpr_regno(reg));
-#endif
     unget_temp_gpr(_jit);
   }
 }
@@ -887,7 +910,7 @@ ldxi_d(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
 static void
 sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-  if (sse_address_p(i0))
+  if (can_sign_extend_int_p(i0))
     movsdrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
@@ -900,14 +923,7 @@ sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 static void
 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, 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);
-#endif
 }
 
 static void
@@ -917,13 +933,8 @@ stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
     movsdrm(_jit, r1, i0, r0, _NOREG, _SCL1);
   else {
     jit_gpr_t reg = get_temp_gpr(_jit);
-#if __X64_32
-    addi(jit_gpr_regno(reg), r0, i0);
-    str_d(_jit, jit_gpr_regno(reg), r1);
-#else
     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-x87.c b/libguile/lightening/lightening/x86-x87.c
deleted file mode 100644
index e6f8be5f4..000000000
--- a/libguile/lightening/lightening/x86-x87.c
+++ /dev/null
@@ -1,1344 +0,0 @@
-/*
- * Copyright (C) 2012-2017  Free Software Foundation, Inc.
- *
- * This file is part of GNU lightning.
- *
- * GNU lightning is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU lightning is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
- * License for more details.
- *
- * Authors:
- *	Paulo Cesar Pereira de Andrade
- */
-
-#if PROTO
-#  if __X32
-#    define x87_address_p(i0)		1
-#  else
-#    if __X64_32
-#      define x87_address_p(i0)		((jit_word_t)(i0) >= 0)
-#    else
-#      define x87_address_p(i0)		can_sign_extend_int_p(i0)
-#    endif
-#  endif
-#  define _ST0_REGNO			0
-#  define _ST1_REGNO			1
-#  define _ST2_REGNO			2
-#  define _ST3_REGNO			3
-#  define _ST4_REGNO			4
-#  define _ST5_REGNO			5
-#  define _ST6_REGNO			6
-#  define x87rx(code, md, rb, ri, ms)	_x87rx(_jit, code, md, rb, ri, ms)
-#  define fldcwm(md, rb, ri, ms)	x87rx(015, md, rb, ri, ms)
-#  define fstcwm(md, rb, ri, ms)	_fstcwm(_jit, md, rb, ri, ms)
-static void
-_fstcwm(jit_state_t*, int32_t, int32_t, int32_t, int32_t);
-#  define fldsm(md, rb, ri, ms)		x87rx(010, md, rb, ri, ms)
-#  define fstsm(md, rb, ri, ms)		x87rx(012, md, rb, ri, ms)
-#  define fldlm(md, rb, ri, ms)		x87rx(050, md, rb, ri, ms)
-#  define fstlm(md, rb, ri, ms)		x87rx(052, md, rb, ri, ms)
-#  define fisttplm(md, rb, ri, ms)	x87rx(031, md, rb, ri, ms)
-#  define fistlm(md, rb, ri, ms)	x87rx(032, md, rb, ri, ms)
-#  define fisttpqm(md, rb, ri, ms)	x87rx(071, md, rb, ri, ms)
-#  define fildlm(md, rb, ri, ms)	x87rx(030, md, rb,ri, ms)
-#  define fildqm(md, rb, ri, ms)	x87rx(075, md, rb,ri, ms)
-static void
-_x87rx(jit_state_t*, int32_t, int32_t,
-       int32_t, int32_t, int32_t);
-#  define x87ri(cc,r0)			_x87ri(_jit,cc,r0)
-#  define fchs_()			x87ri(014, 0)
-#  define fabs_()			x87ri(014, 1)
-#  define fld1()			x87ri(015, 0)
-#  define fldl2t()			x87ri(015, 1)
-#  define fldl2e()			x87ri(015, 2)
-#  define fldpi()			x87ri(015, 3)
-#  define fldlg2()			x87ri(015, 4)
-#  define fldln2()			x87ri(015, 5)
-#  define fldz()			x87ri(015, 6)
-#  define fsqrt_()			x87ri(017, 2)
-#  define fldr(r0)			x87ri(010, r0)
-#  define fxchr(r0)			x87ri(011, r0)
-#  define fstr(r0)			x87ri(052, r0)
-#  define fstpr(r0)			x87ri(053, r0)
-#  define fucomir(r0)			x87ri(035, r0)
-#  define fucomipr(r0)			x87ri(075, r0)
-static void _x87ri(jit_state_t*, int32_t, int32_t);
-#  define faddr(r0, r1)			x87rri(000, r0, r1)
-#  define fmulr(r0, r1)			x87rri(001, r0, r1)
-#  define fsubr(r0, r1)			x87rri(004, r0, r1)
-#  define fsubrr(r0, r1)		x87rri(005, r0, r1)
-#  define fdivr(r0, r1)			x87rri(006, r0, r1)
-#  define fdivrr(r0, r1)		x87rri(007, r0, r1)
-#  define x87rri(cc, r0, r1)		_x87rri(_jit, cc, r0, r1)
-static void _x87rri(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_addr_f(r0, r1, r2)	_x87_addr_d(_jit, r0, r1, r2)
-#  define x87_addi_f(r0, r1, i0)	_x87_addi_f(_jit, r0, r1, i0)
-static void _x87_addi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_addr_d(r0, r1, r2)	_x87_addr_d(_jit, r0, r1, r2)
-static void _x87_addr_d(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_addi_d(r0, r1, i0)	_x87_addi_d(_jit, r0, r1, i0)
-static void _x87_addi_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_subr_f(r0, r1, r2)	_x87_subr_d(_jit, r0, r1, r2)
-#  define x87_subi_f(r0, r1, i0)	_x87_subi_f(_jit, r0, r1, i0)
-static void _x87_subi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_subr_d(r0, r1, r2)	_x87_subr_d(_jit, r0, r1, r2)
-static void _x87_subr_d(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_subi_d(r0, r1, i0)	_x87_subi_d(_jit, r0, r1, i0)
-static void _x87_subi_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_rsbr_f(r0, r1, r2)	x87_subr_f(r0, r2, r1)
-#  define x87_rsbi_f(r0, r1, i0)	_x87_rsbi_f(_jit, r0, r1, i0)
-static void _x87_rsbi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_rsbr_d(r0, r1, r2)	x87_subr_d(r0, r2, r1)
-#  define x87_rsbi_d(r0, r1, i0)	_x87_rsbi_d(_jit, r0, r1, i0)
-static void _x87_rsbi_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_mulr_f(r0, r1, r2)	_x87_mulr_d(_jit, r0, r1, r2)
-#  define x87_muli_f(r0, r1, i0)	_x87_muli_f(_jit, r0, r1, i0)
-static void _x87_muli_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_mulr_d(r0, r1, r2)	_x87_mulr_d(_jit, r0, r1, r2)
-static void _x87_mulr_d(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_muli_d(r0, r1, i0)	_x87_muli_d(_jit, r0, r1, i0)
-static void _x87_muli_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_divr_f(r0, r1, r2)	_x87_divr_d(_jit, r0, r1, r2)
-#  define x87_divi_f(r0, r1, i0)	_x87_divi_f(_jit, r0, r1, i0)
-static void _x87_divi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_divr_d(r0, r1, r2)	_x87_divr_d(_jit, r0, r1, r2)
-static void _x87_divr_d(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_divi_d(r0, r1, i0)	_x87_divi_d(_jit, r0, r1, i0)
-static void _x87_divi_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_absr_f(r0, r1)		_x87_absr_d(_jit, r0, r1)
-#  define x87_absr_d(r0, r1)		_x87_absr_d(_jit, r0, r1)
-static void _x87_absr_d(jit_state_t*, int32_t, int32_t);
-#  define x87_negr_f(r0, r1)		_x87_negr_d(_jit, r0, r1)
-#  define x87_negr_d(r0, r1)		_x87_negr_d(_jit, r0, r1)
-static void _x87_negr_d(jit_state_t*, int32_t, int32_t);
-#  define x87_sqrtr_f(r0, r1)		_x87_sqrtr_d(_jit, r0, r1)
-#  define x87_sqrtr_d(r0, r1)		_x87_sqrtr_d(_jit, r0, r1)
-static void _x87_sqrtr_d(jit_state_t*, int32_t, int32_t);
-#  define x87_truncr_f_i(r0, r1)	_x87_truncr_d_i(_jit, r0, r1)
-#  define x87_truncr_d_i(r0, r1)	_x87_truncr_d_i(_jit, r0, r1)
-static void _x87_truncr_d_i(jit_state_t*, int32_t, int32_t);
-#  if __X64
-#    define x87_truncr_f_l(r0, r1)	_x87_truncr_d_l(_jit, r0, r1)
-#    define x87_truncr_d_l(r0, r1)	_x87_truncr_d_l(_jit, r0, r1)
-static void _x87_truncr_d_l(jit_state_t*, int32_t, int32_t);
-#  endif
-#  define x87_extr_f(r0, r1)		_x87_extr_d(_jit, r0, r1)
-#  define x87_extr_d(r0, r1)		_x87_extr_d(_jit, r0, r1)
-#  define x87_extr_f_d(r0, r1)		x87_movr_d(r0, r1)
-#  define x87_extr_d_f(r0, r1)		x87_movr_d(r0, r1)
-static void _x87_extr_d(jit_state_t*, int32_t, int32_t);
-#  define x87cmp(code, r0, r1, r2)	_x87cmp(_jit, code, r0, r1, r2)
-static void
-_x87cmp(jit_state_t*, int32_t, int32_t, int32_t, int32_t);
-#  define x87cmp2(code, r0, r1, r2)	_x87cmp2(_jit, code, r0, r1, r2)
-static void
-_x87cmp2(jit_state_t*, int32_t, int32_t, int32_t, int32_t);
-#  define x87jcc(code, i0, r0, r1)	_x87jcc(_jit, code, i0, r0, r1)
-static jit_word_t
-_x87jcc(jit_state_t*, int32_t, jit_word_t, int32_t, int32_t);
-#  define x87jcc2(code, i0, r0, r1)	_x87jcc2(_jit, code, i0, r0, r1)
-static jit_word_t
-_x87jcc2(jit_state_t*, int32_t, jit_word_t, int32_t, int32_t);
-#define x87_movi_f(r0,i0)		_x87_movi_f(_jit,r0,i0)
-static void _x87_movi_f(jit_state_t*, int32_t, jit_float32_t*);
-#  define x87_ldr_f(r0, r1)		_x87_ldr_f(_jit, r0, r1)
-static void _x87_ldr_f(jit_state_t*, int32_t, int32_t);
-#  define x87_ldi_f(r0, i0)		_x87_ldi_f(_jit, r0, i0)
-static void _x87_ldi_f(jit_state_t*, int32_t, jit_word_t);
-#  define x87_ldxr_f(r0, r1, r2)	_x87_ldxr_f(_jit, r0, r1, r2)
-static void _x87_ldxr_f(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_ldxi_f(r0, r1, i0)	_x87_ldxi_f(_jit, r0, r1, i0)
-static void _x87_ldxi_f(jit_state_t*, int32_t, int32_t, jit_word_t);
-#  define x87_str_f(r0, r1)		_x87_str_f(_jit, r0, r1)
-static void _x87_str_f(jit_state_t*,int32_t,int32_t);
-#  define x87_sti_f(i0, r0)		_x87_sti_f(_jit, i0, r0)
-static void _x87_sti_f(jit_state_t*,jit_word_t, int32_t);
-#  define x87_stxr_f(r0, r1, r2)	_x87_stxr_f(_jit, r0, r1, r2)
-static void _x87_stxr_f(jit_state_t*,int32_t,int32_t,int32_t);
-#  define x87_stxi_f(i0, r0, r1)	_x87_stxi_f(_jit, i0, r0, r1)
-static void _x87_stxi_f(jit_state_t*,jit_word_t,int32_t,int32_t);
-#  define x87_ltr_f(r0, r1, r2)		x87cmp(X86_CC_A, r0, r2, r1)
-#  define x87_lti_f(r0, r1, i0)		_x87_lti_f(_jit, r0, r1, i0)
-static void _x87_lti_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_ler_f(r0, r1, r2)		x87cmp(X86_CC_AE, r0, r2, r1)
-#  define x87_lei_f(r0, r1, i0)		_x87_lei_f(_jit, r0, r1, i0)
-static void _x87_lei_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_eqr_f(r0, r1, r2)		x87_eqr_d(r0, r2, r1)
-#  define x87_eqi_f(r0, r1, i0)		_x87_eqi_f(_jit, r0, r1, i0)
-static void _x87_eqi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_ger_f(r0, r1, r2)		x87cmp(X86_CC_AE, r0, r1, r2)
-#  define x87_gei_f(r0, r1, i0)		_x87_gei_f(_jit, r0, r1, i0)
-static void _x87_gei_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_gtr_f(r0, r1, r2)		x87cmp(X86_CC_A, r0, r1, r2)
-#  define x87_gti_f(r0, r1, i0)		_x87_gti_f(_jit, r0, r1, i0)
-static void _x87_gti_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_ner_f(r0, r1, r2)		x87_ner_d(r0, r2, r1)
-#  define x87_nei_f(r0, r1, i0)		_x87_nei_f(_jit, r0, r1, i0)
-static void _x87_nei_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_unltr_f(r0, r1, r2)	x87cmp(X86_CC_NAE, r0, r1, r2)
-#  define x87_unlti_f(r0, r1, i0)	_x87_unlti_f(_jit, r0, r1, i0)
-static void _x87_unlti_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_unler_f(r0, r1, r2)	x87cmp(X86_CC_NA, r0, r1, r2)
-#  define x87_unlei_f(r0, r1, i0)	_x87_unlei_f(_jit, r0, r1, i0)
-static void _x87_unlei_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_uneqr_f(r0, r1, r2)	x87cmp2(X86_CC_E, r0, r1, r2)
-#  define x87_uneqi_f(r0, r1, i0)	_x87_uneqi_f(_jit, r0, r1, i0)
-static void _x87_uneqi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_unger_f(r0, r1, r2)	x87cmp(X86_CC_NA, r0, r2, r1)
-#  define x87_ungei_f(r0, r1, i0)	_x87_ungei_f(_jit, r0, r1, i0)
-static void _x87_ungei_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_ungtr_f(r0, r1, r2)	x87cmp(X86_CC_NAE, r0, r2, r1)
-#  define x87_ungti_f(r0, r1, i0)	_x87_ungti_f(_jit, r0, r1, i0)
-static void _x87_ungti_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_ltgtr_f(r0, r1, r2)	x87_ltgtr_d(r0, r1, r2)
-#  define x87_ltgti_f(r0, r1, i0)	_x87_ltgti_f(_jit, r0, r1, i0)
-static void _x87_ltgti_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_ordr_f(r0, r1, r2)	x87cmp2(X86_CC_NP, r0, r2, r1)
-#  define x87_ordi_f(r0, r1, i0)	_x87_ordi_f(_jit, r0, r1, i0)
-static void _x87_ordi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_unordr_f(r0, r1, r2)	x87cmp2(X86_CC_P, r0, r2, r1)
-#  define x87_unordi_f(r0, r1, i0)	_x87_unordi_f(_jit, r0, r1, i0)
-static void _x87_unordi_f(jit_state_t*,int32_t,int32_t,jit_float32_t*);
-#  define x87_ltr_d(r0, r1, r2)		x87cmp(X86_CC_A, r0, r2, r1)
-#  define x87_lti_d(r0, r1, i0)		_x87_lti_d(_jit, r0, r1, i0)
-static void _x87_lti_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_ler_d(r0, r1, r2)		x87cmp(X86_CC_AE, r0, r2, r1)
-#  define x87_lei_d(r0, r1, i0)		_x87_lei_d(_jit, r0, r1, i0)
-static void _x87_lei_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_eqr_d(r0, r1, r2)		_x87_eqr_d(_jit, r0, r2, r1)
-static void _x87_eqr_d(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_eqi_d(r0, r1, i0)		_x87_eqi_d(_jit, r0, r1, i0)
-static void _x87_eqi_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_ger_d(r0, r1, r2)		x87cmp(X86_CC_AE, r0, r1, r2)
-#  define x87_gei_d(r0, r1, i0)		_x87_gei_d(_jit, r0, r1, i0)
-static void _x87_gei_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_gtr_d(r0, r1, r2)		x87cmp(X86_CC_A, r0, r1, r2)
-#  define x87_gti_d(r0, r1, i0)		_x87_gti_d(_jit, r0, r1, i0)
-static void _x87_gti_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_ner_d(r0, r1, r2)		_x87_ner_d(_jit, r0, r2, r1)
-static void _x87_ner_d(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_nei_d(r0, r1, i0)		_x87_nei_d(_jit, r0, r1, i0)
-static void _x87_nei_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_unltr_d(r0, r1, r2)	x87cmp(X86_CC_NAE, r0, r1, r2)
-#  define x87_unlti_d(r0, r1, i0)	_x87_unlti_d(_jit, r0, r1, i0)
-static void _x87_unlti_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_unler_d(r0, r1, r2)	x87cmp(X86_CC_NA, r0, r1, r2)
-#  define x87_unlei_d(r0, r1, i0)	_x87_unlei_d(_jit, r0, r1, i0)
-static void _x87_unlei_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_uneqr_d(r0, r1, r2)	x87cmp2(X86_CC_E, r0, r1, r2)
-#  define x87_uneqi_d(r0, r1, i0)	_x87_uneqi_d(_jit, r0, r1, i0)
-static void _x87_uneqi_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_unger_d(r0, r1, r2)	x87cmp(X86_CC_NA, r0, r2, r1)
-#  define x87_ungei_d(r0, r1, i0)	_x87_ungei_d(_jit, r0, r1, i0)
-static void _x87_ungei_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_ungtr_d(r0, r1, r2)	x87cmp(X86_CC_NAE, r0, r2, r1)
-#  define x87_ungti_d(r0, r1, i0)	_x87_ungti_d(_jit, r0, r1, i0)
-static void _x87_ungti_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_ltgtr_d(r0, r1, r2)	_x87_ltgtr_d(_jit, r0, r1, r2)
-static void _x87_ltgtr_d(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_ltgti_d(r0, r1, i0)	_x87_ltgti_d(_jit, r0, r1, i0)
-static void _x87_ltgti_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_ordr_d(r0, r1, r2)	x87cmp2(X86_CC_NP, r0, r2, r1)
-#  define x87_ordi_d(r0, r1, i0)	_x87_ordi_d(_jit, r0, r1, i0)
-static void _x87_ordi_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#  define x87_unordr_d(r0, r1, r2)	x87cmp2(X86_CC_P, r0, r2, r1)
-#  define x87_unordi_d(r0, r1, i0)	_x87_unordi_d(_jit, r0, r1, i0)
-static void _x87_unordi_d(jit_state_t*,int32_t,int32_t,jit_float64_t*);
-#define x87_movr_f(r0,r1)		_x87_movr_d(_jit,r0,r1)
-#define x87_movr_d(r0,r1)		_x87_movr_d(_jit,r0,r1)
-static void _x87_movr_d(jit_state_t*, int32_t, int32_t);
-#define x87_movi_d(r0,i0)		_x87_movi_d(_jit,r0,i0)
-static void _x87_movi_d(jit_state_t*, int32_t, jit_float64_t*);
-#  define x87_ldr_d(r0, r1)		_x87_ldr_d(_jit, r0, r1)
-static void _x87_ldr_d(jit_state_t*, int32_t, int32_t);
-#  define x87_ldi_d(r0, i0)		_x87_ldi_d(_jit, r0, i0)
-static void _x87_ldi_d(jit_state_t*, int32_t, jit_word_t);
-#  define x87_ldxr_d(r0, r1, r2)	_x87_ldxr_d(_jit, r0, r1, r2)
-static void _x87_ldxr_d(jit_state_t*, int32_t, int32_t, int32_t);
-#  define x87_ldxi_d(r0, r1, i0)	_x87_ldxi_d(_jit, r0, r1, i0)
-static void _x87_ldxi_d(jit_state_t*, int32_t, int32_t, jit_word_t);
-#  define x87_str_d(r0, r1)		_x87_str_d(_jit, r0, r1)
-static void _x87_str_d(jit_state_t*,int32_t,int32_t);
-#  define x87_sti_d(i0, r0)		_x87_sti_d(_jit, i0, r0)
-static void _x87_sti_d(jit_state_t*,jit_word_t,int32_t);
-#  define x87_stxr_d(r0, r1, r2)	_x87_stxr_d(_jit, r0, r1, r2)
-static void _x87_stxr_d(jit_state_t*,int32_t,int32_t,int32_t);
-#  define x87_stxi_d(i0, r0, r1)	_x87_stxi_d(_jit, i0, r0, r1)
-static void _x87_stxi_d(jit_state_t*,jit_word_t,int32_t,int32_t);
-#  define x87_bltr_f(i0, r0, r1)	x87jcc(X86_CC_A, i0, r1, r0)
-#  define x87_blti_f(i0, r0, i1)	_x87_blti_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_blti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bler_f(i0, r0, r1)	x87jcc(X86_CC_AE, i0, r1, r0)
-#  define x87_blei_f(i0, r0, i1)	_x87_blei_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_blei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_beqr_f(i0, r0, r1)	_x87_beqr_d(_jit, i0, r0, r1)
-#  define x87_beqi_f(i0, r0, i1)	_x87_beqi_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_beqi_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bger_f(i0, r0, r1)	x87jcc(X86_CC_AE, i0, r0, r1)
-#  define x87_bgei_f(i0, r0, i1)	_x87_bgei_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bgei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bgtr_f(i0, r0, r1)	x87jcc(X86_CC_A, i0, r0, r1)
-#  define x87_bgti_f(i0, r0, i1)	_x87_bgti_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bgti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bner_f(i0, r0, r1)	_x87_bner_d(_jit, i0, r0, r1)
-#  define x87_bnei_f(i0, r0, i1)	_x87_bnei_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bnei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bunltr_f(i0, r0, r1)	x87jcc(X86_CC_NAE, i0, r0, r1)
-#  define x87_bunlti_f(i0, r0, i1)	_x87_bunlti_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bunlti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bunler_f(i0, r0, r1)	x87jcc(X86_CC_NA, i0, r0, r1)
-#  define x87_bunlei_f(i0, r0, i1)	_x87_bunlei_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bunlei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_buneqr_f(i0, r0, r1)	x87jcc2(X86_CC_E, i0, r0, r1)
-#  define x87_buneqi_f(i0, r0, i1)	_x87_buneqi_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_buneqi_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bunger_f(i0, r0, r1)	x87jcc(X86_CC_NA, i0, r1, r0)
-#  define x87_bungei_f(i0, r0, i1)	_x87_bungei_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bungei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bungtr_f(i0, r0, r1)	x87jcc(X86_CC_NAE, i0, r1, r0)
-#  define x87_bungti_f(i0, r0, i1)	_x87_bungti_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bungti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bltgtr_f(i0, r0, r1)	x87jcc2(X86_CC_NE, i0, r0, r1)
-#  define x87_bltgti_f(i0, r0, i1)	_x87_bltgti_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bltgti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bordr_f(i0, r0, r1)	x87jcc2(X86_CC_NP, i0, r0, r1)
-#  define x87_bordi_f(i0, r0, i1)	_x87_bordi_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bordi_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bunordr_f(i0, r0, r1)	x87jcc2(X86_CC_P, i0, r0, r1)
-#  define x87_bunordi_f(i0, r0, i1)	_x87_bunordi_f(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bunordi_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
-#  define x87_bltr_d(i0, r0, r1)	x87jcc(X86_CC_A, i0, r1, r0)
-#  define x87_blti_d(i0, r0, i1)	_x87_blti_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_blti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bler_d(i0, r0, r1)	x87jcc(X86_CC_AE, i0, r1, r0)
-#  define x87_blei_d(i0, r0, i1)	_x87_blei_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_blei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_beqr_d(i0, r0, r1)	_x87_beqr_d(_jit, i0, r0, r1)
-static jit_word_t
-_x87_beqr_d(jit_state_t*, jit_word_t, int32_t, int32_t);
-#  define x87_beqi_d(i0, r0, i1)	_x87_beqi_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_beqi_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bger_d(i0, r0, r1)	x87jcc(X86_CC_AE, i0, r0, r1)
-#  define x87_bgei_d(i0, r0, i1)	_x87_bgei_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bgei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bgtr_d(i0, r0, r1)	x87jcc(X86_CC_A, i0, r0, r1)
-#  define x87_bgti_d(i0, r0, i1)	_x87_bgti_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bgti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bner_d(i0, r0, r1)	_x87_bner_d(_jit, i0, r0, r1)
-static jit_word_t
-_x87_bner_d(jit_state_t*, jit_word_t, int32_t, int32_t);
-#  define x87_bnei_d(i0, r0, i1)	_x87_bnei_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bnei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bunltr_d(i0, r0, r1)	x87jcc(X86_CC_NAE, i0, r0, r1)
-#  define x87_bunlti_d(i0, r0, i1)	_x87_bunlti_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bunlti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bunler_d(i0, r0, r1)	x87jcc(X86_CC_NA, i0, r0, r1)
-#  define x87_bunlei_d(i0, r0, i1)	_x87_bunlei_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bunlei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_buneqr_d(i0, r0, r1)	x87jcc2(X86_CC_E, i0, r0, r1)
-#  define x87_buneqi_d(i0, r0, i1)	_x87_buneqi_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_buneqi_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bunger_d(i0, r0, r1)	x87jcc(X86_CC_NA, i0, r1, r0)
-#  define x87_bungei_d(i0, r0, i1)	_x87_bungei_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bungei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bungtr_d(i0, r0, r1)	x87jcc(X86_CC_NAE, i0, r1, r0)
-#  define x87_bungti_d(i0, r0, i1)	_x87_bungti_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bungti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bltgtr_d(i0, r0, r1)	x87jcc2(X86_CC_NE, i0, r0, r1)
-#  define x87_bltgti_d(i0, r0, i1)	_x87_bltgti_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bltgti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bordr_d(i0, r0, r1)	x87jcc2(X86_CC_NP, i0, r0, r1)
-#  define x87_bordi_d(i0, r0, i1)	_x87_bordi_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bordi_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#  define x87_bunordr_d(i0, r0, r1)	x87jcc2(X86_CC_P, i0, r0, r1)
-#  define x87_bunordi_d(i0, r0, i1)	_x87_bunordi_d(_jit, i0, r0, i1)
-static jit_word_t
-_x87_bunordi_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
-#endif
-
-#if CODE
-#  define fpr_opi(name, type, size)					\
-static void								\
-_x87_##name##i_##type(jit_state_t *_jit,				\
-		      int32_t r0, int32_t r1,			\
-		      jit_float##size##_t *i0)				\
-{									\
-    int32_t		reg = jit_get_reg(jit_class_fpr);		\
-    assert(jit_x87_reg_p(reg));						\
-    x87_movi_##type(rn(reg), i0);					\
-    x87_##name##r_##type(r0, r1, rn(reg));				\
-    jit_unget_reg(reg);							\
-}
-#  define fpr_bopi(name, type, size)					\
-static jit_word_t							\
-_x87_b##name##i_##type(jit_state_t *_jit,				\
-		       jit_word_t i0, int32_t r0,			\
-		       jit_float##size##_t *i1)				\
-{									\
-    jit_word_t		word;						\
-    int32_t		reg = jit_get_reg(jit_class_fpr|		\
-					  jit_class_nospill);		\
-    assert(jit_x87_reg_p(reg));						\
-    x87_movi_##type(rn(reg), i1);					\
-    word = x87_b##name##r_##type(i0, r0, rn(reg));			\
-    jit_unget_reg(reg);							\
-    return (word);							\
-}
-#  define fopi(name)			fpr_opi(name, f, 32)
-#  define fbopi(name)			fpr_bopi(name, f, 32)
-#  define dopi(name)			fpr_opi(name, d, 64)
-#  define dbopi(name)			fpr_bopi(name, d, 64)
-
-static void
-_fstcwm(jit_state_t *_jit, int32_t md,
-	int32_t rb,	int32_t ri, int32_t ms)
-{
-    ic(0x9b);
-    rex(0, 1, rb, ri, _NOREG);
-    x87rx(017, md, rb, ri, ms);
-}
-
-static void
-_x87rx(jit_state_t *_jit, int32_t code, int32_t md,
-       int32_t rb, int32_t ri, int32_t ms)
-{
-    rex(0, 1, rb, ri, _NOREG);
-    ic(0xd8 | (code >> 3));
-    rx((code & 7), md, rb, ri, ms);
-}
-
-static void
-_x87ri(jit_state_t *_jit, int32_t code, int32_t r0)
-{
-    ic(0xd8 | (code >> 3));
-    mrm(0x03, (code & 7), r0);
-}
-
-static void
-_x87rri(jit_state_t *_jit, int32_t code, int32_t r0, int32_t r1)
-{
-    if (r1 == _ST0_REGNO)
-	x87ri(code | 040, r0);
-    else {
-	assert(r0 == _ST0_REGNO);
-	x87ri(code, r1);
-    }
-}
-
-fopi(add)
-fopi(sub)
-fopi(rsb)
-fopi(mul)
-fopi(div)
-
-static void
-_x87_addr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-    if (r0 == r1) {
-	if (r2 == _ST0_REGNO)
-	    faddr(r0, _ST0_REGNO);
-	else if (r0 == _ST0_REGNO)
-	    faddr(_ST0_REGNO, r2);
-	else {
-	    fxchr(r0);
-	    faddr(_ST0_REGNO, r0 == r2 ? _ST0_REGNO : r2);
-	    fxchr(r0);
-	}
-    }
-    else if (r0 == r2) {
-	if (r1 == _ST0_REGNO)
-	    faddr(r0, _ST0_REGNO);
-	else if (r0 == _ST0_REGNO)
-	    faddr(_ST0_REGNO, r1);
-	else {
-	    fxchr(r0);
-	    faddr(_ST0_REGNO, r1);
-	    fxchr(r0);
-	}
-    }
-    else {
-	fldr(r1);
-	faddr(_ST0_REGNO, r2 + 1);
-	fstpr(r0 + 1);
-    }
-}
-
-dopi(add)
-
-static void
-_x87_subr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-    if (r0 == r1) {
-	if (r2 == _ST0_REGNO)
-	    fsubrr(r0, _ST0_REGNO);
-	else if (r0 == _ST0_REGNO)
-	    fsubr(_ST0_REGNO, r2);
-	else {
-	    fxchr(r0);
-	    fsubr(_ST0_REGNO, r0 == r2 ? _ST0_REGNO : r2);
-	    fxchr(r0);
-	}
-    }
-    else if (r0 == r2) {
-	if (r1 == _ST0_REGNO)
-	    fsubr(r0, _ST0_REGNO);
-	else if (r0 == _ST0_REGNO)
-	    fsubrr(_ST0_REGNO, r1);
-	else {
-	    fxchr(r0);
-	    fsubrr(_ST0_REGNO, r1);
-	    fxchr(r0);
-	}
-    }
-    else {
-	fldr(r1);
-	fsubr(_ST0_REGNO, r2 + 1);
-	fstpr(r0 + 1);
-    }
-}
-
-dopi(sub)
-
-dopi(rsb)
-
-static void
-_x87_mulr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-    if (r0 == r1) {
-	if (r2 == _ST0_REGNO)
-	    fmulr(r0, _ST0_REGNO);
-	else if (r0 == _ST0_REGNO)
-	    fmulr(_ST0_REGNO, r2);
-	else {
-	    fxchr(r0);
-	    fmulr(_ST0_REGNO, r0 == r2 ? _ST0_REGNO : r2);
-	    fxchr(r0);
-	}
-    }
-    else if (r0 == r2) {
-	if (r1 == _ST0_REGNO)
-	    fmulr(r0, _ST0_REGNO);
-	else if (r0 == _ST0_REGNO)
-	    fmulr(_ST0_REGNO, r1);
-	else {
-	    fxchr(r0);
-	    fmulr(_ST0_REGNO, r1);
-	    fxchr(r0);
-	}
-    }
-    else {
-	fldr(r1);
-	fmulr(_ST0_REGNO, r2 + 1);
-	fstpr(r0 + 1);
-    }
-}
-
-dopi(mul)
-
-static void
-_x87_divr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-    if (r0 == r1) {
-	if (r2 == _ST0_REGNO)
-	    fdivrr(r0, _ST0_REGNO);
-	else if (r0 == _ST0_REGNO)
-	    fdivr(_ST0_REGNO, r2);
-	else {
-	    fxchr(r0);
-	    fdivr(_ST0_REGNO, r0 == r2 ? _ST0_REGNO : r2);
-	    fxchr(r0);
-	}
-    }
-    else if (r0 == r2) {
-	if (r1 == _ST0_REGNO)
-	    fdivr(r0, _ST0_REGNO);
-	else if (r0 == _ST0_REGNO)
-	    fsubrr(_ST0_REGNO, r1);
-	else {
-	    fxchr(r0);
-	    fdivrr(_ST0_REGNO, r1);
-	    fxchr(r0);
-	}
-    }
-    else {
-	fldr(r1);
-	fdivr(_ST0_REGNO, r2 + 1);
-	fstpr(r0 + 1);
-    }
-}
-
-dopi(div)
-
-static void
-_x87_absr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    if (r0 == r1) {
-	if (r1 == _ST0_REGNO)
-	    fabs_();
-	else {
-	    fxchr(r0);
-	    fabs_();
-	    fxchr(r0);
-	}
-    }
-    else {
-	fldr(r1);
-	fabs_();
-	fstpr(r0 + 1);
-    }
-}
-
-static void
-_x87_negr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    if (r0 == r1) {
-	if (r1 == _ST0_REGNO)
-	    fchs_();
-	else {
-	    fxchr(r0);
-	    fchs_();
-	    fxchr(r0);
-	}
-    }
-    else {
-	fldr(r1);
-	fchs_();
-	fstpr(r0 + 1);
-    }
-}
-
-static void
-_x87_sqrtr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    if (r0 == r1) {
-	if (r1 == _ST0_REGNO)
-	    fsqrt_();
-	else {
-	    fxchr(r0);
-	    fsqrt_();
-	    fxchr(r0);
-	}
-    }
-    else {
-	fldr(r1);
-	fsqrt_();
-	fstpr(r0 + 1);
-    }
-}
-
-static void
-_x87_truncr_d_i(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-#if defined(sun)
-    /* for the sake of passing test cases in x87 mode, otherwise only sse
-     * is supported */
-    fstcwm(-4, _RBP_REGNO, _NOREG, _SCL1);
-    ldxi_s(r0, _RBP_REGNO, -4);
-    extr_uc(r0, r0);
-#  define FPCW_CHOP	0xc00
-    ori(r0, r0, FPCW_CHOP);
-    stxi_s(-8, _RBP_REGNO, r0);
-    fldcwm(-8, _RBP_REGNO, _NOREG, _SCL1);
-    if (r1 == _ST0_REGNO)
-	fistlm(CVT_OFFSET, _RBP_REGNO, _NOREG, _SCL1);
-    else {
-	fxchr(r1);
-	fistlm(CVT_OFFSET, _RBP_REGNO, _NOREG, _SCL1);
-	fxchr(r1);
-    }
-    fldcwm(-4, _RBP_REGNO, _NOREG, _SCL1);
-    ldxi(r0, _RBP_REGNO, CVT_OFFSET);
-#else
-    fldr(r1);
-    fisttplm(CVT_OFFSET, _RBP_REGNO, _NOREG, _SCL1);
-    ldxi_i(r0, _RBP_REGNO, CVT_OFFSET);
-#endif
-}
-
-#  if __X64
-static void
-_x87_truncr_d_l(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    fldr(r1);
-    fisttpqm(CVT_OFFSET, _RBP_REGNO, _NOREG, _SCL1);
-    ldxi(r0, _RBP_REGNO, CVT_OFFSET);
-}
-#  endif
-
-static void
-_x87_extr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    stxi(CVT_OFFSET, _RBP_REGNO, r1);
-#  if __X32
-    fildlm(CVT_OFFSET, _RBP_REGNO, _NOREG, _SCL1);
-#  else
-    fildqm(CVT_OFFSET, _RBP_REGNO, _NOREG, _SCL1);
-#  endif
-    fstpr(r0 + 1);
-}
-
-static void
-_x87cmp(jit_state_t *_jit, int32_t code,
-	int32_t r0, int32_t r1, int32_t r2)
-{
-    jit_bool_t		rc;
-    int32_t		reg;
-    if ((rc = reg8_p(r0)))
-	reg = r0;
-    else {
-	reg = _RAX_REGNO;
-	movr(r0, reg);
-    }
-    ixorr(reg, reg);
-    if (r1 == _ST0_REGNO)
-	fucomir(r2);
-    else {
-	fldr(r1);
-	fucomipr(r2 + 1);
-    }
-    cc(code, reg);
-    if (!rc)
-	xchgr(r0, reg);
-}
-
-static void
-_x87cmp2(jit_state_t *_jit, int32_t code,
-	 int32_t r0, int32_t r1, int32_t r2)
-{
-    jit_bool_t			rc;
-    int32_t			reg;
-    int32_t			f1, f2;
-    if (r2 == _ST0_REGNO)	f1 = r2, f2 = r1;
-    else			f1 = r1, f2 = r2;
-    if ((rc = reg8_p(r0)))
-	reg = r0;
-    else {
-	reg = _RAX_REGNO;
-	movr(r0, reg);
-    }
-    ixorr(reg, reg);
-    if (f1 == _ST0_REGNO)
-	fucomir(f2);
-    else {
-	fldr(f1);
-	fucomipr(f2 + 1);
-    }
-    cc(code, reg);
-    if (!rc)
-	xchgr(r0, reg);
-}
-
-static jit_word_t
-_x87jcc(jit_state_t *_jit, int32_t code,
-	jit_word_t i0, int32_t r0, int32_t r1)
-{
-    if (r0 == _ST0_REGNO)
-	fucomir(r1);
-    else {
-	fldr(r0);
-	fucomipr(r1 + 1);
-    }
-    jcc(code, i0);
-    return (_jit->pc.w);
-}
-
-static jit_word_t
-_x87jcc2(jit_state_t *_jit, int32_t code,
-	 jit_word_t i0, int32_t r0, int32_t r1)
-{
-    int32_t			f0, f1;
-    if (r1 == _ST0_REGNO)	f0 = r1, f1 = r0;
-    else			f0 = r0, f1 = r1;
-    if (f0 == _ST0_REGNO)
-	fucomir(f1);
-    else {
-	fldr(f0);
-	fucomipr(f1 + 1);
-    }
-    jcc(code, i0);
-    return (_jit->pc.w);
-}
-
-fopi(lt)
-fopi(le)
-fopi(eq)
-fopi(ge)
-fopi(gt)
-fopi(ne)
-fopi(unlt)
-fopi(unle)
-fopi(uneq)
-fopi(unge)
-fopi(ungt)
-fopi(ltgt)
-fopi(ord)
-fopi(unord)
-fbopi(lt)
-fbopi(le)
-fbopi(eq)
-fbopi(ge)
-fbopi(gt)
-fbopi(ne)
-fbopi(unlt)
-fbopi(unle)
-fbopi(uneq)
-fbopi(unge)
-fbopi(ungt)
-fbopi(ltgt)
-fbopi(ord)
-fbopi(unord)
-
-static void
-_x87_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t *i0)
-{
-    union {
-	int32_t	 i;
-	jit_float32_t	 f;
-    } data;
-    int32_t		 reg;
-
-    data.f = *i0;
-    if (data.f == 0.0 && !(data.i & 0x80000000))
-	fldz();
-    else if (data.f == 1.0)
-	fld1();
-    else if (data.f == 3.3219280948873623478703195458468f)
-	fldl2t();
-    else if (data.f == 1.4426950408889634073599246886656f)
-	fldl2e();
-    else if (data.f == 3.1415926535897932384626421096161f)
-	fldpi();
-    else if (data.f == 0.3010299956639811952137387498515f)
-	fldlg2();
-    else if (data.f == 0.6931471805599453094172323683399f)
-	fldln2();
-    else {
-	if (_jitc->no_data) {
-	    reg = jit_get_reg(jit_class_gpr);
-	    movi(rn(reg), data.i);
-	    stxi_i(CVT_OFFSET, _RBP_REGNO, rn(reg));
-	    jit_unget_reg(reg);
-	    x87_ldxi_f(r0, _RBP_REGNO, CVT_OFFSET);
-	}
-	else
-	    x87_ldi_f(r0, (jit_word_t)i0);
-	return;
-    }
-    fstpr(r0 + 1);
-}
-
-static void
-_x87_ldr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    fldsm(0, r1, _NOREG, _SCL1);
-    fstpr(r0 + 1);
-}
-
-static void
-_x87_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
-{
-    int32_t		reg;
-    if (x87_address_p(i0)) {
-	fldsm(i0, _NOREG, _NOREG, _SCL1);
-	fstpr(r0 + 1);
-    }
-    else {
-	reg = jit_get_reg(jit_class_gpr);
-	movi(rn(reg), i0);
-	x87_ldr_f(r0, rn(reg));
-	jit_unget_reg(reg);
-    }
-}
-
-static void
-_x87_ldxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-#if __X64_32
-    int32_t		reg;
-    reg = jit_get_reg(jit_class_gpr);
-    addr(rn(reg), r1, r2);
-    x87_ldr_f(r0, rn(reg));
-    jit_unget_reg(reg);
-#else
-    fldsm(0, r1, r2, _SCL1);
-    fstpr(r0 + 1);
-#endif
-}
-
-static void
-_x87_ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
-{
-    int32_t		reg;
-    if (can_sign_extend_int_p(i0)) {
-	fldsm(i0, r1, _NOREG, _SCL1);
-	fstpr(r0 + 1);
-    }
-    else {
-	reg = jit_get_reg(jit_class_gpr);
-#if __X64_32
-	addi(rn(reg), r1, i0);
-	x87_ldr_f(r0, rn(reg));
-#else
-	movi(rn(reg), i0);
-	x87_ldxr_f(r0, r1, rn(reg));
-#endif
-	jit_unget_reg(reg);
-    }
-}
-
-static void
-_x87_str_f(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    if (r1 == _ST0_REGNO)
-	fstsm(0, r0, _NOREG, _SCL1);
-    else {
-	fxchr(r1);
-	fstsm(0, r0, _NOREG, _SCL1);
-	fxchr(r1);
-    }
-}
-
-static void
-_x87_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
-{
-    int32_t		reg;
-    if (!x87_address_p(i0)) {
-	reg = jit_get_reg(jit_class_gpr);
-	movi(rn(reg), i0);
-	x87_str_f(rn(reg), r0);
-	jit_unget_reg(reg);
-    }
-    else if (r0 == _ST0_REGNO)
-	fstsm(i0, _NOREG, _NOREG, _SCL1);
-    else {
-	fxchr(r0);
-	fstsm(i0, _NOREG, _NOREG, _SCL1);
-	fxchr(r0);
-    }
-}
-
-static void
-_x87_stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-#if __X64_32
-    int32_t		reg;
-    reg = jit_get_reg(jit_class_gpr);
-    addr(rn(reg), r0, r1);
-    x87_str_f(rn(reg), r2);
-    jit_unget_reg(reg);
-#else
-    if (r2 == _ST0_REGNO)
-	fstsm(0, r0, r1, _SCL1);
-    else {
-	fxchr(r2);
-	fstsm(0, r0, r1, _SCL1);
-	fxchr(r2);
-    }
-#endif
-}
-
-static void
-_x87_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
-{
-    int32_t		reg;
-    if (!can_sign_extend_int_p(i0)) {
-	reg = jit_get_reg(jit_class_gpr);
-#if __X64_32
-	addi(rn(reg), r0, i0);
-	x87_str_f(rn(reg), r1);
-#else
-	movi(rn(reg), i0);
-	x87_stxr_f(rn(reg), r0, r1);
-#endif
-	jit_unget_reg(reg);
-    }
-    else if (r1 == _ST0_REGNO)
-	fstsm(i0, r0, _NOREG, _SCL1);
-    else {
-	fxchr(r1);
-	fstsm(i0, r0, _NOREG, _SCL1);
-	fxchr(r1);
-    }
-}
-
-static void
-_x87_movr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    if (r0 != r1) {
-	if (r1 == _ST0)
-	    fstr(r0);
-	else if (r0 == _ST0) {
-	    fxchr(r1);
-	    fstr(r1);
-	}
-	else {
-	    fldr(r1);
-	    fstpr(r0 + 1);
-	}
-    }
-}
-
-static void
-_x87_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t *i0)
-{
-    union {
-	int32_t	 ii[2];
-	jit_word_t	 w;
-	jit_float64_t	 d;
-    } data;
-    int32_t		 reg;
-
-    data.d = *i0;
-    if (data.d == 0.0 && !(data.ii[1] & 0x80000000))
-	fldz();
-    else if (data.d == 1.0)
-	fld1();
-    else if (data.d == 3.3219280948873623478703195458468)
-	fldl2t();
-    else if (data.d == 1.4426950408889634073599246886656)
-	fldl2e();
-    else if (data.d == 3.1415926535897932384626421096161)
-	fldpi();
-    else if (data.d == 0.3010299956639811952137387498515)
-	fldlg2();
-    else if (data.d == 0.6931471805599453094172323683399)
-	fldln2();
-    else {
-	if (_jitc->no_data) {
-	    reg = jit_get_reg(jit_class_gpr);
-#if __X32 || __X64_32
-	    movi(rn(reg), data.ii[0]);
-	    stxi_i(CVT_OFFSET, _RBP_REGNO, rn(reg));
-	    movi(rn(reg), data.ii[1]);
-	    stxi_i(CVT_OFFSET + 4, _RBP_REGNO, rn(reg));
-#else
-	    movi(rn(reg), data.w);
-	    stxi_l(CVT_OFFSET, _RBP_REGNO, rn(reg));
-#endif
-	    jit_unget_reg(reg);
-	    x87_ldxi_d(r0, _RBP_REGNO, CVT_OFFSET);
-	}
-	else
-	    x87_ldi_d(r0, (jit_word_t)i0);
-	return;
-    }
-    fstpr(r0 + 1);
-}
-
-dopi(lt)
-dopi(le)
-
-static void
-_x87_eqr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-    jit_bool_t			rc;
-    jit_word_t			jp_code;
-    int32_t			reg, f1, f2;
-    if (r2 == _ST0_REGNO)	f1 = r2, f2 = r1;
-    else			f1 = r1, f2 = r2;
-    if ((rc = reg8_p(r0)))
-	reg = r0;
-    else {
-	reg = _RAX_REGNO;
-	movr(r0, reg);
-    }
-    ixorr(reg, reg);
-    if (f1 == _ST0_REGNO)
-	fucomir(f2);
-    else {
-	fldr(f1);
-	fucomipr(f2 + 1);
-    }
-    jpes(0);
-    jp_code = _jit->pc.w;
-    cc(X86_CC_E, reg);
-    patch_rel_char(jp_code, _jit->pc.w);
-    if (!rc)
-	xchgr(r0, reg);
-}
-
-dopi(eq)
-dopi(ge)
-dopi(gt)
-
-static void
-_x87_ner_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-    jit_bool_t			rc;
-    jit_word_t			jp_code;
-    int32_t			reg, f1, f2;
-    if (r2 == _ST0_REGNO)	f1 = r2, f2 = r1;
-    else			f1 = r1, f2 = r2;
-    if ((rc = reg8_p(r0)))
-	reg = r0;
-    else {
-	reg = _RAX_REGNO;
-	movr(r0, reg);
-    }
-    imovi(reg, 1);
-    if (f1 == _ST0_REGNO)
-	fucomir(f2);
-    else {
-	fldr(f1);
-	fucomipr(f2 + 1);
-    }
-    jpes(0);
-    jp_code = _jit->pc.w;
-    cc(X86_CC_NE, reg);
-    patch_rel_char(jp_code, _jit->pc.w);
-    if (!rc)
-	xchgr(r0, reg);
-}
-
-dopi(ne)
-dopi(unlt)
-dopi(unle)
-dopi(uneq)
-dopi(unge)
-dopi(ungt)
-
-static void
-_x87_ltgtr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-    if (r1 == r2)
-	movi(r0, 1);
-    else
-	x87cmp2(X86_CC_NE, r0, r1, r2);
-}
-
-dopi(ltgt)
-dopi(ord)
-dopi(unord)
-
-static void
-_x87_ldr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    fldlm(0, r1, _NOREG, _SCL1);
-    fstpr(r0 + 1);
-}
-
-static void
-_x87_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
-{
-    int32_t		reg;
-    if (x87_address_p(i0)) {
-	fldlm(i0, _NOREG, _NOREG, _SCL1);
-	fstpr(r0 + 1);
-    }
-    else {
-	reg = jit_get_reg(jit_class_gpr);
-	movi(rn(reg), i0);
-	x87_ldr_d(r0, rn(reg));
-	jit_unget_reg(reg);
-    }
-}
-
-static void
-_x87_ldxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-#if __X64_32
-    int32_t		reg;
-    reg = jit_get_reg(jit_class_gpr);
-    addr(rn(reg), r1, r2);
-    x87_ldr_d(r0, rn(reg));
-    jit_unget_reg(reg);
-#else
-    fldlm(0, r1, r2, _SCL1);
-    fstpr(r0 + 1);
-#endif
-}
-
-static void
-_x87_ldxi_d(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
-{
-    int32_t		reg;
-    if (can_sign_extend_int_p(i0)) {
-	fldlm(i0, r1, _NOREG, _SCL1);
-	fstpr(r0 + 1);
-    }
-    else {
-	reg = jit_get_reg(jit_class_gpr);
-#if __X64_32
-	addi(rn(reg), r1, i0);
-	x87_ldr_d(r0, rn(reg));
-#else
-	movi(rn(reg), i0);
-	x87_ldxr_d(r0, r1, rn(reg));
-#endif
-	jit_unget_reg(reg);
-    }
-}
-
-static void
-_x87_str_d(jit_state_t *_jit, int32_t r0, int32_t r1)
-{
-    if (r1 == _ST0_REGNO)
-	fstlm(0, r0, _NOREG, _SCL1);
-    else {
-	fxchr(r1);
-	fstlm(0, r0, _NOREG, _SCL1);
-	fxchr(r1);
-    }
-}
-
-static void
-_x87_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
-{
-    int32_t		reg;
-    if (!x87_address_p(i0)) {
-	reg = jit_get_reg(jit_class_gpr);
-	movi(rn(reg), i0);
-	x87_str_d(rn(reg), r0);
-	jit_unget_reg(reg);
-    }
-    else if (r0 == _ST0_REGNO)
-	fstlm(i0, _NOREG, _NOREG, _SCL1);
-    else {
-	fxchr(r0);
-	fstlm(i0, _NOREG, _NOREG, _SCL1);
-	fxchr(r0);
-    }
-}
-
-static void
-_x87_stxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
-{
-#if __X64_32
-    int32_t		reg;
-    reg = jit_get_reg(jit_class_gpr);
-    addr(rn(reg), r0, r1);
-    x87_str_d(rn(reg), r2);
-    jit_unget_reg(reg);
-#else
-    if (r2 == _ST0_REGNO)
-	fstlm(0, r0, r1, _SCL1);
-    else {
-	fxchr(r2);
-	fstlm(0, r0, r1, _SCL1);
-	fxchr(r2);
-    }
-#endif
-}
-
-static void
-_x87_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
-{
-    int32_t		reg;
-    if (!can_sign_extend_int_p(i0)) {
-	reg = jit_get_reg(jit_class_gpr);
-#if __X64_32
-	addi(rn(reg), r0, i0);
-	x87_str_d(rn(reg), r1);
-#else
-	movi(rn(reg), i0);
-	x87_stxr_d(rn(reg), r0, r1);
-#endif
-	jit_unget_reg(reg);
-    }
-    else if (r1 == _ST0_REGNO)
-	fstlm(i0, r0, _NOREG, _SCL1);
-    else {
-	fxchr(r1);
-	fstlm(i0, r0, _NOREG, _SCL1);
-	fxchr(r1);
-    }
-}
-
-dbopi(lt)
-dbopi(le)
-
-static jit_word_t
-_x87_beqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
-{
-    int32_t			f0, f1;
-    jit_word_t			jp_code;
-    if (r1 == _ST0_REGNO)	f0 = r1, f1 = r0;
-    else			f0 = r0, f1 = r1;
-    if (f0 == _ST0_REGNO)
-	fucomir(f1);
-    else {
-	fldr(f0);
-	fucomipr(f1 + 1);
-    }
-    jpes(0);
-    jp_code = _jit->pc.w;
-    jcc(X86_CC_E, i0);
-    patch_rel_char(jp_code, _jit->pc.w);
-    return (_jit->pc.w);
-}
-dbopi(eq)
-dbopi(ge)
-dbopi(gt)
-
-static jit_word_t
-_x87_bner_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
-{
-    int32_t			f0, f1;
-    jit_word_t			jp_code;
-    jit_word_t			jz_code;
-    if (r1 == _ST0_REGNO)	f0 = r1, f1 = r0;
-    else			f0 = r0, f1 = r1;
-    if (f0 == _ST0_REGNO)
-	fucomir(f1);
-    else {
-	fldr(f0);
-	fucomipr(f1 + 1);
-    }
-    jpes(0);
-    jp_code = _jit->pc.w;
-    jzs(0);
-    jz_code = _jit->pc.w;
-    patch_rel_char(jp_code, _jit->pc.w);
-    jmpi(i0);
-    patch_rel_char(jz_code, _jit->pc.w);
-    return (_jit->pc.w);
-}
-dbopi(ne)
-dbopi(unlt)
-dbopi(unle)
-dbopi(uneq)
-dbopi(unge)
-dbopi(ungt)
-dbopi(ltgt)
-dbopi(ord)
-dbopi(unord)
-#  undef fopi
-#  undef fbopi
-#  undef dopi
-#  undef dbopi
-#  undef fpr_bopi
-#  undef fpr_opi
-#endif
diff --git a/libguile/lightening/lightening/x86.c b/libguile/lightening/lightening/x86.c
index 4031bb1ca..bf48c18df 100644
--- a/libguile/lightening/lightening/x86.c
+++ b/libguile/lightening/lightening/x86.c
@@ -17,44 +17,46 @@
  *      Paulo Cesar Pereira de Andrade
  */
 
-/*
- * Types
- */
-#if __X32 || __CYGWIN__
-typedef jit_pointer_t jit_va_list_t;
-#else
-typedef struct jit_va_list {
-  int32_t             gpoff;
-  int32_t             fpoff;
-  jit_pointer_t       over;
-  jit_pointer_t       save;
-  /* Declared explicitly as int64 for the x32 abi */
-  int64_t             rdi;
-  int64_t             rsi;
-  int64_t             rdx;
-  int64_t             rcx;
-  int64_t             r8;
-  int64_t             r9;
-  jit_float64_t       xmm0;
-  jit_float64_t       _up0;
-  jit_float64_t       xmm1;
-  jit_float64_t       _up1;
-  jit_float64_t       xmm2;
-  jit_float64_t       _up2;
-  jit_float64_t       xmm3;
-  jit_float64_t       _up3;
-  jit_float64_t       xmm4;
-  jit_float64_t       _up4;
-  jit_float64_t       xmm5;
-  jit_float64_t       _up5;
-  jit_float64_t       xmm6;
-  jit_float64_t       _up6;
-  jit_float64_t       xmm7;
-  jit_float64_t       _up7;
-} jit_va_list_t;
-#endif
+typedef struct {
+  /* x87 present */
+  uint32_t fpu                : 1;
+  /* cmpxchg8b instruction */
+  uint32_t cmpxchg8b  : 1;
+  /* cmov and fcmov branchless conditional mov */
+  uint32_t cmov               : 1;
+  /* mmx registers/instructions available */
+  uint32_t mmx                : 1;
+  /* sse registers/instructions available */
+  uint32_t sse                : 1;
+  /* sse2 registers/instructions available */
+  uint32_t sse2               : 1;
+  /* sse3 instructions available */
+  uint32_t sse3               : 1;
+  /* pcmulqdq instruction */
+  uint32_t pclmulqdq  : 1;
+  /* ssse3 suplemental sse3 instructions available */
+  uint32_t ssse3              : 1;
+  /* fused multiply/add using ymm state */
+  uint32_t fma                : 1;
+  /* cmpxchg16b instruction */
+  uint32_t cmpxchg16b : 1;
+  /* sse4.1 instructions available */
+  uint32_t sse4_1             : 1;
+  /* sse4.2 instructions available */
+  uint32_t sse4_2             : 1;
+  /* movbe instruction available */
+  uint32_t movbe              : 1;
+  /* popcnt instruction available */
+  uint32_t popcnt             : 1;
+  /* aes instructions available */
+  uint32_t aes                : 1;
+  /* avx instructions available */
+  uint32_t avx                : 1;
+  /* lahf/sahf available in 64 bits mode */
+  uint32_t lahf               : 1;
+} jit_cpu_t;
 
-jit_cpu_t               jit_cpu;
+static jit_cpu_t jit_cpu;
 
 #include "x86-cpu.c"
 #include "x86-sse.c"
@@ -159,7 +161,7 @@ jit_get_cpu(void)
   /* i386 or i486 without cpuid */
   if ((ac & (1 << 21)) == 0)
     /* probably without x87 as well */
-    return false;
+    return 0;
 #endif
 
     /* query %eax = 1 function */
@@ -192,8 +194,8 @@ jit_get_cpu(void)
   jit_cpu.avx         = ecx.bits.avx;
 
     /* query %eax = 0x80000001 function */
-  __asm__ volatile (
 #if __X64
+  __asm__ volatile (
 #  if __X64_32
                     "xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1"
 #  else
@@ -313,6 +315,12 @@ round_size_up_to_words(size_t bytes)
   return words * word_size;
 }
 
+static size_t
+jit_initial_frame_size (void)
+{
+  return __WORDSIZE / 8; // Saved return address is on stack.
+}
+
 static void
 reset_abi_arg_iterator(struct abi_arg_iterator *iter, size_t argc,
                        const jit_operand_t *args)
@@ -350,6 +358,16 @@ jit_flush(void *fptr, void *tptr)
 {
 }
 
+static inline size_t
+jit_stack_alignment(void)
+{
+#if __X64
+  return 16;
+#else
+  return 4;
+#endif
+}
+
 static void
 jit_try_shorten(jit_state_t *_jit, jit_reloc_t reloc, jit_pointer_t addr)
 {
diff --git a/libguile/lightening/lightening/x86.h b/libguile/lightening/lightening/x86.h
index de47df8a9..db5072273 100644
--- a/libguile/lightening/lightening/x86.h
+++ b/libguile/lightening/lightening/x86.h
@@ -20,14 +20,9 @@
 #ifndef _jit_x86_h
 #define _jit_x86_h
 
-#define JIT_HASH_CONSTS         1
-#define JIT_NUM_OPERANDS        2
-
 /*
  * Types
  */
-#define jit_sse2_p()            jit_cpu.sse2
-#define jit_x87_reg_p(reg)      ((reg) >= _ST0 && (reg) <= _ST6)
 #if __WORDSIZE == 32
 # if defined(__x86_64__)
 #  define __X64    1
@@ -138,6 +133,7 @@ jit_fpr_is_callee_save (jit_fpr_t reg)
 #  define JIT_V0   _RBX
 #  define JIT_V1   _RSI
 #  define JIT_V2   _RDI
+#  define JIT_VTMP _RBP
 #  define JIT_F0   _XMM0
 #  define JIT_F1   _XMM1
 #  define JIT_F2   _XMM2
@@ -210,48 +206,4 @@ jit_fpr_is_callee_save (jit_fpr_t reg)
 #  define JIT_FTMP _XMM15
 #endif
 
-typedef struct {
-  /* x87 present */
-  uint32_t fpu                : 1;
-  /* cmpxchg8b instruction */
-  uint32_t cmpxchg8b  : 1;
-  /* cmov and fcmov branchless conditional mov */
-  uint32_t cmov               : 1;
-  /* mmx registers/instructions available */
-  uint32_t mmx                : 1;
-  /* sse registers/instructions available */
-  uint32_t sse                : 1;
-  /* sse2 registers/instructions available */
-  uint32_t sse2               : 1;
-  /* sse3 instructions available */
-  uint32_t sse3               : 1;
-  /* pcmulqdq instruction */
-  uint32_t pclmulqdq  : 1;
-  /* ssse3 suplemental sse3 instructions available */
-  uint32_t ssse3              : 1;
-  /* fused multiply/add using ymm state */
-  uint32_t fma                : 1;
-  /* cmpxchg16b instruction */
-  uint32_t cmpxchg16b : 1;
-  /* sse4.1 instructions available */
-  uint32_t sse4_1             : 1;
-  /* sse4.2 instructions available */
-  uint32_t sse4_2             : 1;
-  /* movbe instruction available */
-  uint32_t movbe              : 1;
-  /* popcnt instruction available */
-  uint32_t popcnt             : 1;
-  /* aes instructions available */
-  uint32_t aes                : 1;
-  /* avx instructions available */
-  uint32_t avx                : 1;
-  /* lahf/sahf available in 64 bits mode */
-  uint32_t lahf               : 1;
-} jit_cpu_t;
-
-/*
- * Initialization
- */
-JIT_API jit_cpu_t               jit_cpu;
-
 #endif /* _jit_x86_h */
diff --git a/libguile/lightening/tests/Makefile b/libguile/lightening/tests/Makefile
index f068308c7..7b6bbd49d 100644
--- a/libguile/lightening/tests/Makefile
+++ b/libguile/lightening/tests/Makefile
@@ -27,7 +27,10 @@ test-native-%: %.c lightening-native.o test.h
 
 test-ia32-%: CC = $(CC_IA32)
 test-ia32-%: %.c lightening-ia32.o test.h
-	$(CC) -m32 $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening-ia32.o $<
+	$(CC) $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening-ia32.o $<
+
+.PRECIOUS: $(foreach TARGET,$(TARGETS),$(addprefix test-$(TARGET)-,$(TESTS)))
+.PRECIOUS: $(foreach TARGET,$(TARGETS),lightening-$(TARGET).o)
 
 clean:
 	rm -f $(foreach TARGET,$(TARGETS),$(addprefix test-$(TARGET)-,$(TESTS)))
diff --git a/libguile/lightening/tests/absr_d.c b/libguile/lightening/tests/absr_d.c
index 93b10b673..00b8fa460 100644
--- a/libguile/lightening/tests/absr_d.c
+++ b/libguile/lightening/tests/absr_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_absr_d(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(double) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/absr_f.c b/libguile/lightening/tests/absr_f.c
index 64463bf89..e019b5ff3 100644
--- a/libguile/lightening/tests/absr_f.c
+++ b/libguile/lightening/tests/absr_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_absr_f(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(float) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/addi.c b/libguile/lightening/tests/addi.c
index f0e632c94..756d07061 100644
--- a/libguile/lightening/tests/addi.c
+++ b/libguile/lightening/tests/addi.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_addi(j, JIT_R0, JIT_R0, 69);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/addr.c b/libguile/lightening/tests/addr.c
index 8894cc5dc..6ee76e291 100644
--- a/libguile/lightening/tests/addr.c
+++ b/libguile/lightening/tests/addr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_addr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/addr_d.c b/libguile/lightening/tests/addr_d.c
index 8c7be6298..11216202e 100644
--- a/libguile/lightening/tests/addr_d.c
+++ b/libguile/lightening/tests/addr_d.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_addr_d(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/addr_f.c b/libguile/lightening/tests/addr_f.c
index 1ed1f36b4..4317dfe3a 100644
--- a/libguile/lightening/tests/addr_f.c
+++ b/libguile/lightening/tests/addr_f.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_addr_f(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/addx.c b/libguile/lightening/tests/addx.c
index 6013e52c1..417cd1a26 100644
--- a/libguile/lightening/tests/addx.c
+++ b/libguile/lightening/tests/addx.c
@@ -4,18 +4,20 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_movi(j, JIT_R2, 0);
   jit_addcr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_addxi(j, JIT_R2, JIT_R2, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R2);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0, 0) == 0);
 
diff --git a/libguile/lightening/tests/andi.c b/libguile/lightening/tests/andi.c
index a1d3203c9..c6f39d7aa 100644
--- a/libguile/lightening/tests/andi.c
+++ b/libguile/lightening/tests/andi.c
@@ -4,15 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_andi(j, JIT_R0, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff) == 1);
   ASSERT(f(0x80000000) == 0);
diff --git a/libguile/lightening/tests/andr.c b/libguile/lightening/tests/andr.c
index 62cc61e8a..1114ef98f 100644
--- a/libguile/lightening/tests/andr.c
+++ b/libguile/lightening/tests/andr.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_andr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff, 1) == 1);
   ASSERT(f(1, 0x7fffffff) == 1);
diff --git a/libguile/lightening/tests/beqi.c b/libguile/lightening/tests/beqi.c
index 994147306..2fb2454c0 100644
--- a/libguile/lightening/tests/beqi.c
+++ b/libguile/lightening/tests/beqi.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_beqi(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 1);
   ASSERT(f(1) == 0);
diff --git a/libguile/lightening/tests/beqr.c b/libguile/lightening/tests/beqr.c
index 2bdeb24a9..d1d80b266 100644
--- a/libguile/lightening/tests/beqr.c
+++ b/libguile/lightening/tests/beqr.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_beqr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/beqr_d.c b/libguile/lightening/tests/beqr_d.c
index 628e80ce3..a84b6a76a 100644
--- a/libguile/lightening/tests/beqr_d.c
+++ b/libguile/lightening/tests/beqr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_beqr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/beqr_f.c b/libguile/lightening/tests/beqr_f.c
index dca60fa98..7b5cc2708 100644
--- a/libguile/lightening/tests/beqr_f.c
+++ b/libguile/lightening/tests/beqr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_beqr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bgei.c b/libguile/lightening/tests/bgei.c
index 7a847e699..b9a830b5d 100644
--- a/libguile/lightening/tests/bgei.c
+++ b/libguile/lightening/tests/bgei.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bgei(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 1);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/bgei_u.c b/libguile/lightening/tests/bgei_u.c
index 6847613c5..894c275e1 100644
--- a/libguile/lightening/tests/bgei_u.c
+++ b/libguile/lightening/tests/bgei_u.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bgei_u(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 1);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/bger.c b/libguile/lightening/tests/bger.c
index 68df65bdf..daab88c39 100644
--- a/libguile/lightening/tests/bger.c
+++ b/libguile/lightening/tests/bger.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bger(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bger_d.c b/libguile/lightening/tests/bger_d.c
index ab1190ea7..712b118ea 100644
--- a/libguile/lightening/tests/bger_d.c
+++ b/libguile/lightening/tests/bger_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bger_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bger_f.c b/libguile/lightening/tests/bger_f.c
index 07cf7f075..b9d547861 100644
--- a/libguile/lightening/tests/bger_f.c
+++ b/libguile/lightening/tests/bger_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bger_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bger_u.c b/libguile/lightening/tests/bger_u.c
index 806953c60..5c07f442d 100644
--- a/libguile/lightening/tests/bger_u.c
+++ b/libguile/lightening/tests/bger_u.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bger_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bgti.c b/libguile/lightening/tests/bgti.c
index e6e6c05db..4bfd36e1f 100644
--- a/libguile/lightening/tests/bgti.c
+++ b/libguile/lightening/tests/bgti.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bgti(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/bgti_u.c b/libguile/lightening/tests/bgti_u.c
index f604fed36..b4da14e01 100644
--- a/libguile/lightening/tests/bgti_u.c
+++ b/libguile/lightening/tests/bgti_u.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bgti_u(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/bgtr.c b/libguile/lightening/tests/bgtr.c
index de31bf876..dbf5fdd50 100644
--- a/libguile/lightening/tests/bgtr.c
+++ b/libguile/lightening/tests/bgtr.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bgtr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bgtr_d.c b/libguile/lightening/tests/bgtr_d.c
index 1cc8dd5eb..d3c24362a 100644
--- a/libguile/lightening/tests/bgtr_d.c
+++ b/libguile/lightening/tests/bgtr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bgtr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bgtr_f.c b/libguile/lightening/tests/bgtr_f.c
index 37d65f2b8..91cb8c046 100644
--- a/libguile/lightening/tests/bgtr_f.c
+++ b/libguile/lightening/tests/bgtr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bgtr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bgtr_u.c b/libguile/lightening/tests/bgtr_u.c
index 31202c455..2ed4d8eda 100644
--- a/libguile/lightening/tests/bgtr_u.c
+++ b/libguile/lightening/tests/bgtr_u.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bgtr_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/blei.c b/libguile/lightening/tests/blei.c
index c9317eab8..cb9eacb9c 100644
--- a/libguile/lightening/tests/blei.c
+++ b/libguile/lightening/tests/blei.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_blei(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 1);
   ASSERT(f(1) == 0);
diff --git a/libguile/lightening/tests/blei_u.c b/libguile/lightening/tests/blei_u.c
index 614ddf0be..efe0523c5 100644
--- a/libguile/lightening/tests/blei_u.c
+++ b/libguile/lightening/tests/blei_u.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_blei_u(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 1);
   ASSERT(f(1) == 0);
diff --git a/libguile/lightening/tests/bler.c b/libguile/lightening/tests/bler.c
index ba580b032..57371fb18 100644
--- a/libguile/lightening/tests/bler.c
+++ b/libguile/lightening/tests/bler.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bler(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bler_d.c b/libguile/lightening/tests/bler_d.c
index f11b92356..507dac506 100644
--- a/libguile/lightening/tests/bler_d.c
+++ b/libguile/lightening/tests/bler_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bler_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bler_f.c b/libguile/lightening/tests/bler_f.c
index 9c0a7f710..191b6492c 100644
--- a/libguile/lightening/tests/bler_f.c
+++ b/libguile/lightening/tests/bler_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bler_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bler_u.c b/libguile/lightening/tests/bler_u.c
index 036bb6420..4269fee10 100644
--- a/libguile/lightening/tests/bler_u.c
+++ b/libguile/lightening/tests/bler_u.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bler_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bltgtr_d.c b/libguile/lightening/tests/bltgtr_d.c
index 6d433e47b..3d8835dbd 100644
--- a/libguile/lightening/tests/bltgtr_d.c
+++ b/libguile/lightening/tests/bltgtr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bltgtr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bltgtr_f.c b/libguile/lightening/tests/bltgtr_f.c
index 711e51647..fbdbc3b30 100644
--- a/libguile/lightening/tests/bltgtr_f.c
+++ b/libguile/lightening/tests/bltgtr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bltgtr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/blti.c b/libguile/lightening/tests/blti.c
index a16ac0220..fcdeb15b4 100644
--- a/libguile/lightening/tests/blti.c
+++ b/libguile/lightening/tests/blti.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_blti(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 0);
diff --git a/libguile/lightening/tests/blti_u.c b/libguile/lightening/tests/blti_u.c
index 1a93f1d1e..e90f1938e 100644
--- a/libguile/lightening/tests/blti_u.c
+++ b/libguile/lightening/tests/blti_u.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_blti_u(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 0);
diff --git a/libguile/lightening/tests/bltr.c b/libguile/lightening/tests/bltr.c
index 7802fa82e..901f6c4b4 100644
--- a/libguile/lightening/tests/bltr.c
+++ b/libguile/lightening/tests/bltr.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bltr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bltr_d.c b/libguile/lightening/tests/bltr_d.c
index 11930eee2..2d6260931 100644
--- a/libguile/lightening/tests/bltr_d.c
+++ b/libguile/lightening/tests/bltr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bltr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bltr_f.c b/libguile/lightening/tests/bltr_f.c
index 4bb3ac48a..eebd3da0c 100644
--- a/libguile/lightening/tests/bltr_f.c
+++ b/libguile/lightening/tests/bltr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bltr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bltr_u.c b/libguile/lightening/tests/bltr_u.c
index c73949f6a..9df16fc1d 100644
--- a/libguile/lightening/tests/bltr_u.c
+++ b/libguile/lightening/tests/bltr_u.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bltr_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bmci.c b/libguile/lightening/tests/bmci.c
index 8846c9462..608d6667b 100644
--- a/libguile/lightening/tests/bmci.c
+++ b/libguile/lightening/tests/bmci.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bmci(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 1);
   ASSERT(f(1) == 0);
diff --git a/libguile/lightening/tests/bmcr.c b/libguile/lightening/tests/bmcr.c
index ba8b246c0..df7e04641 100644
--- a/libguile/lightening/tests/bmcr.c
+++ b/libguile/lightening/tests/bmcr.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bmcr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bmsi.c b/libguile/lightening/tests/bmsi.c
index 538575f8b..82c2ba7ea 100644
--- a/libguile/lightening/tests/bmsi.c
+++ b/libguile/lightening/tests/bmsi.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bmsi(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/bmsr.c b/libguile/lightening/tests/bmsr.c
index 3ac320ff9..8caa7e0e7 100644
--- a/libguile/lightening/tests/bmsr.c
+++ b/libguile/lightening/tests/bmsr.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bmsr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bnei.c b/libguile/lightening/tests/bnei.c
index f1ac741c8..73e38a7db 100644
--- a/libguile/lightening/tests/bnei.c
+++ b/libguile/lightening/tests/bnei.c
@@ -4,14 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bnei(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/bner.c b/libguile/lightening/tests/bner.c
index 1f8f05dbe..e6515865e 100644
--- a/libguile/lightening/tests/bner.c
+++ b/libguile/lightening/tests/bner.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bner(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bner_d.c b/libguile/lightening/tests/bner_d.c
index afe1a363f..079fda466 100644
--- a/libguile/lightening/tests/bner_d.c
+++ b/libguile/lightening/tests/bner_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bner_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bner_f.c b/libguile/lightening/tests/bner_f.c
index bc5782439..011df67b2 100644
--- a/libguile/lightening/tests/bner_f.c
+++ b/libguile/lightening/tests/bner_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bner_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/boaddi.c b/libguile/lightening/tests/boaddi.c
index 3ee3bef28..1e47297c4 100644
--- a/libguile/lightening/tests/boaddi.c
+++ b/libguile/lightening/tests/boaddi.c
@@ -1,20 +1,23 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_boaddi(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(-1) == 0);
   ASSERT(f(0) == 1);
diff --git a/libguile/lightening/tests/boaddi_u.c b/libguile/lightening/tests/boaddi_u.c
index c55c1f80b..21c71dfb9 100644
--- a/libguile/lightening/tests/boaddi_u.c
+++ b/libguile/lightening/tests/boaddi_u.c
@@ -1,20 +1,23 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_boaddi_u(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(-1) == overflowed);
   ASSERT(f(0) == 1);
diff --git a/libguile/lightening/tests/boaddr.c b/libguile/lightening/tests/boaddr.c
index 4c86c320d..8bab91ef1 100644
--- a/libguile/lightening/tests/boaddr.c
+++ b/libguile/lightening/tests/boaddr.c
@@ -1,21 +1,24 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_boaddr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(1, 1) == 2);
diff --git a/libguile/lightening/tests/boaddr_u.c b/libguile/lightening/tests/boaddr_u.c
index 9c610f54b..f4bacde65 100644
--- a/libguile/lightening/tests/boaddr_u.c
+++ b/libguile/lightening/tests/boaddr_u.c
@@ -1,21 +1,24 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_boaddr_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(1, 1) == 2);
@@ -24,7 +27,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   ASSERT(f(0xffffffff, 0xffffffff) == overflowed);
   ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
   ASSERT(f(0x7fffffff, 1) == 0x80000000);
-  ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffff + 0x7fffffff);
+  ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffu + 0x7fffffffu);
   ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
   ASSERT(f(0x80000000, 0x80000000) == overflowed);
 #else
diff --git a/libguile/lightening/tests/bordr_d.c b/libguile/lightening/tests/bordr_d.c
index 6e220d931..9227f2223 100644
--- a/libguile/lightening/tests/bordr_d.c
+++ b/libguile/lightening/tests/bordr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bordr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bordr_f.c b/libguile/lightening/tests/bordr_f.c
index 29bf8d4af..25808e51f 100644
--- a/libguile/lightening/tests/bordr_f.c
+++ b/libguile/lightening/tests/bordr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bordr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bosubi.c b/libguile/lightening/tests/bosubi.c
index ccf358175..f10d90a75 100644
--- a/libguile/lightening/tests/bosubi.c
+++ b/libguile/lightening/tests/bosubi.c
@@ -1,20 +1,23 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bosubi(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(-1) == -2);
   ASSERT(f(0) == -1);
diff --git a/libguile/lightening/tests/bosubi_u.c b/libguile/lightening/tests/bosubi_u.c
index 4b36b9086..50af6ad56 100644
--- a/libguile/lightening/tests/bosubi_u.c
+++ b/libguile/lightening/tests/bosubi_u.c
@@ -1,20 +1,23 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bosubi_u(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(-1) == -2);
   ASSERT(f(0) == overflowed);
diff --git a/libguile/lightening/tests/bosubr.c b/libguile/lightening/tests/bosubr.c
index f77d9bac9..cf68ad625 100644
--- a/libguile/lightening/tests/bosubr.c
+++ b/libguile/lightening/tests/bosubr.c
@@ -1,21 +1,24 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bosubr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == -1);
diff --git a/libguile/lightening/tests/bosubr_u.c b/libguile/lightening/tests/bosubr_u.c
index 2e9562c4e..b5e6b39a0 100644
--- a/libguile/lightening/tests/bosubr_u.c
+++ b/libguile/lightening/tests/bosubr_u.c
@@ -1,21 +1,24 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bosubr_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(1, 1) == 0);
diff --git a/libguile/lightening/tests/bswapr_ui.c b/libguile/lightening/tests/bswapr_ui.c
index 2046d7f21..c1eb9fdc0 100644
--- a/libguile/lightening/tests/bswapr_ui.c
+++ b/libguile/lightening/tests/bswapr_ui.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_bswapr_ui(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(0x12345678) == 0x78563412);
diff --git a/libguile/lightening/tests/bswapr_ul.c b/libguile/lightening/tests/bswapr_ul.c
index 1b712dbe9..a3a11b31e 100644
--- a/libguile/lightening/tests/bswapr_ul.c
+++ b/libguile/lightening/tests/bswapr_ul.c
@@ -5,12 +5,14 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_bswapr_ul(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(0x12345678) == 0x7856341200000000);
diff --git a/libguile/lightening/tests/bswapr_us.c b/libguile/lightening/tests/bswapr_us.c
index 44302bc02..0ff777e9e 100644
--- a/libguile/lightening/tests/bswapr_us.c
+++ b/libguile/lightening/tests/bswapr_us.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_bswapr_us(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(0x12345678) == 0x7856);
diff --git a/libguile/lightening/tests/buneqr_d.c b/libguile/lightening/tests/buneqr_d.c
index b24bb2b89..1d08e325e 100644
--- a/libguile/lightening/tests/buneqr_d.c
+++ b/libguile/lightening/tests/buneqr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_buneqr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/buneqr_f.c b/libguile/lightening/tests/buneqr_f.c
index 2c88bf043..49d9062ee 100644
--- a/libguile/lightening/tests/buneqr_f.c
+++ b/libguile/lightening/tests/buneqr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_buneqr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bunger_d.c b/libguile/lightening/tests/bunger_d.c
index 21f851ff6..57888af01 100644
--- a/libguile/lightening/tests/bunger_d.c
+++ b/libguile/lightening/tests/bunger_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bunger_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bunger_f.c b/libguile/lightening/tests/bunger_f.c
index 3ea27d408..f3103dc9a 100644
--- a/libguile/lightening/tests/bunger_f.c
+++ b/libguile/lightening/tests/bunger_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bunger_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bungtr_d.c b/libguile/lightening/tests/bungtr_d.c
index 1af89877d..649d61f30 100644
--- a/libguile/lightening/tests/bungtr_d.c
+++ b/libguile/lightening/tests/bungtr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bungtr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bungtr_f.c b/libguile/lightening/tests/bungtr_f.c
index f60337766..fea66dc60 100644
--- a/libguile/lightening/tests/bungtr_f.c
+++ b/libguile/lightening/tests/bungtr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bungtr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bunler_d.c b/libguile/lightening/tests/bunler_d.c
index d16a0dc97..e59382c5e 100644
--- a/libguile/lightening/tests/bunler_d.c
+++ b/libguile/lightening/tests/bunler_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bunler_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bunler_f.c b/libguile/lightening/tests/bunler_f.c
index 56680bab4..fddce6b94 100644
--- a/libguile/lightening/tests/bunler_f.c
+++ b/libguile/lightening/tests/bunler_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bunler_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 1);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bunltr_d.c b/libguile/lightening/tests/bunltr_d.c
index 30b157698..2ab00510b 100644
--- a/libguile/lightening/tests/bunltr_d.c
+++ b/libguile/lightening/tests/bunltr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bunltr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bunltr_f.c b/libguile/lightening/tests/bunltr_f.c
index 97c89a08c..ade228b7b 100644
--- a/libguile/lightening/tests/bunltr_f.c
+++ b/libguile/lightening/tests/bunltr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bunltr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 1);
diff --git a/libguile/lightening/tests/bunordr_d.c b/libguile/lightening/tests/bunordr_d.c
index 3c124f964..6b04f0ee1 100644
--- a/libguile/lightening/tests/bunordr_d.c
+++ b/libguile/lightening/tests/bunordr_d.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bunordr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(double, double) = jit_end(j, NULL);
+  jit_word_t (*f)(double, double) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bunordr_f.c b/libguile/lightening/tests/bunordr_f.c
index a1bd0a41c..ce4fc7bea 100644
--- a/libguile/lightening/tests/bunordr_f.c
+++ b/libguile/lightening/tests/bunordr_f.c
@@ -4,15 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bunordr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
-  intmax_t (*f)(float, float) = jit_end(j, NULL);
+  jit_word_t (*f)(float, float) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == 0);
diff --git a/libguile/lightening/tests/bxaddi.c b/libguile/lightening/tests/bxaddi.c
index 43894a294..6e872dace 100644
--- a/libguile/lightening/tests/bxaddi.c
+++ b/libguile/lightening/tests/bxaddi.c
@@ -1,19 +1,21 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bxaddi(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(-1) == 0);
   ASSERT(f(0) == 1);
diff --git a/libguile/lightening/tests/bxaddi_u.c b/libguile/lightening/tests/bxaddi_u.c
index c67d40d1d..e71aeb79d 100644
--- a/libguile/lightening/tests/bxaddi_u.c
+++ b/libguile/lightening/tests/bxaddi_u.c
@@ -1,19 +1,21 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bxaddi_u(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(-1) == overflowed);
   ASSERT(f(0) == 1);
diff --git a/libguile/lightening/tests/bxaddr.c b/libguile/lightening/tests/bxaddr.c
index 85af51d49..c1f6f2393 100644
--- a/libguile/lightening/tests/bxaddr.c
+++ b/libguile/lightening/tests/bxaddr.c
@@ -1,20 +1,22 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bxaddr(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(1, 1) == 2);
diff --git a/libguile/lightening/tests/bxaddr_u.c b/libguile/lightening/tests/bxaddr_u.c
index 517b03fa1..d674f8286 100644
--- a/libguile/lightening/tests/bxaddr_u.c
+++ b/libguile/lightening/tests/bxaddr_u.c
@@ -1,20 +1,22 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bxaddr_u(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(1, 1) == 2);
@@ -23,7 +25,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   ASSERT(f(0xffffffff, 0xffffffff) == overflowed);
   ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
   ASSERT(f(0x7fffffff, 1) == 0x80000000);
-  ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffff + 0x7fffffff);
+  ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffu + 0x7fffffffu);
   ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
   ASSERT(f(0x80000000, 0x80000000) == overflowed);
 #else
diff --git a/libguile/lightening/tests/bxsubi.c b/libguile/lightening/tests/bxsubi.c
index f6b66f8eb..1b642c711 100644
--- a/libguile/lightening/tests/bxsubi.c
+++ b/libguile/lightening/tests/bxsubi.c
@@ -1,19 +1,21 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bxsubi(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(-1) == -2);
   ASSERT(f(0) == -1);
diff --git a/libguile/lightening/tests/bxsubi_u.c b/libguile/lightening/tests/bxsubi_u.c
index 95a78df67..1345bd2bf 100644
--- a/libguile/lightening/tests/bxsubi_u.c
+++ b/libguile/lightening/tests/bxsubi_u.c
@@ -1,19 +1,21 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bxsubi_u(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(-1) == -2);
   ASSERT(f(0) == overflowed);
diff --git a/libguile/lightening/tests/bxsubr.c b/libguile/lightening/tests/bxsubr.c
index 9f9b79cad..d40d1821d 100644
--- a/libguile/lightening/tests/bxsubr.c
+++ b/libguile/lightening/tests/bxsubr.c
@@ -1,20 +1,22 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bxsubr(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(0, 1) == -1);
diff --git a/libguile/lightening/tests/bxsubr_u.c b/libguile/lightening/tests/bxsubr_u.c
index 0d505b0cf..54a8d2836 100644
--- a/libguile/lightening/tests/bxsubr_u.c
+++ b/libguile/lightening/tests/bxsubr_u.c
@@ -1,20 +1,22 @@
 #include "test.h"
 
-static const intmax_t overflowed = 0xcabba9e5;
+static const jit_word_t overflowed = 0xcabba9e5;
 
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bxsubr_u(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0, 0) == 0);
   ASSERT(f(1, 1) == 0);
diff --git a/libguile/lightening/tests/call_10.c b/libguile/lightening/tests/call_10.c
index 9c3c94358..d99bcb886 100644
--- a/libguile/lightening/tests/call_10.c
+++ b/libguile/lightening/tests/call_10.c
@@ -19,6 +19,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0));
 
   jit_operand_t args[10] = {
@@ -34,6 +35,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
     jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0, 9 * sizeof(int32_t))
   };
   jit_calli(j, f, 10, args);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/callee_9.c b/libguile/lightening/tests/callee_9.c
new file mode 100644
index 000000000..b7f1a466c
--- /dev/null
+++ b/libguile/lightening/tests/callee_9.c
@@ -0,0 +1,68 @@
+#include "test.h"
+
+struct args
+{
+  int8_t a;
+  int16_t b;
+  int32_t c;
+  jit_word_t d;
+  uint16_t e;
+  float f;
+  double g;
+  float h;
+};
+
+static void
+run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
+{
+  jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 3, 0, 0);
+
+  jit_operand_t args[9] = {
+    jit_operand_gpr(JIT_OPERAND_ABI_POINTER, JIT_R0),
+    jit_operand_gpr(JIT_OPERAND_ABI_INT8, JIT_R1),
+    jit_operand_gpr(JIT_OPERAND_ABI_INT16, JIT_R2),
+    jit_operand_gpr(JIT_OPERAND_ABI_INT32, JIT_V0),
+    jit_operand_gpr(JIT_OPERAND_ABI_WORD, JIT_V1),
+    jit_operand_gpr(JIT_OPERAND_ABI_UINT16, JIT_V2),
+    jit_operand_fpr(JIT_OPERAND_ABI_FLOAT, JIT_F0),
+    jit_operand_fpr(JIT_OPERAND_ABI_DOUBLE, JIT_F1),
+    jit_operand_fpr(JIT_OPERAND_ABI_FLOAT, JIT_F2),
+  };
+  jit_load_args(j, 9, args);
+  jit_stxi_c(j, offsetof(struct args, a), JIT_R0, JIT_R1); // a
+  jit_stxi_s(j, offsetof(struct args, b), JIT_R0, JIT_R2); // b
+  jit_stxi_i(j, offsetof(struct args, c), JIT_R0, JIT_V0); // c
+  jit_stxi(j,   offsetof(struct args, d), JIT_R0, JIT_V1); // d
+  jit_stxi_s(j, offsetof(struct args, e), JIT_R0, JIT_V2); // e
+  jit_stxi_f(j, offsetof(struct args, f), JIT_R0, JIT_F0); // f
+  jit_stxi_d(j, offsetof(struct args, g), JIT_R0, JIT_F1); // g
+  jit_stxi_f(j, offsetof(struct args, h), JIT_R0, JIT_F2); // h
+
+  jit_leave_jit_abi(j, 3, 0, align);
+  jit_retr(j, JIT_R0);
+
+  size_t size = 0;
+  void* ret = jit_end(j, &size);
+
+  struct args* (*f)(struct args*, int8_t, int16_t, int32_t, jit_word_t,
+                    uint16_t, float, double, float) = ret;
+
+  struct args in = { 0, 1, 2, 3, 4, 5, 6, 7 };
+  struct args out;
+  ASSERT(f(&out, in.a, in.b, in.c, in.d, in.e, in.f, in.g, in.h) == &out);
+  ASSERT(in.a == out.a);
+  ASSERT(in.b == out.b);
+  ASSERT(in.c == out.c);
+  ASSERT(in.d == out.d);
+  ASSERT(in.e == out.e);
+  ASSERT(in.f == out.f);
+  ASSERT(in.g == out.g);
+  ASSERT(in.h == out.h);
+}
+
+int
+main (int argc, char *argv[])
+{
+  return main_helper(argc, argv, run_test);
+}
diff --git a/libguile/lightening/tests/comr.c b/libguile/lightening/tests/comr.c
index 4b0151a5d..c2e7d1883 100644
--- a/libguile/lightening/tests/comr.c
+++ b/libguile/lightening/tests/comr.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_comr(j, JIT_R0, JIT_R0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
 #if __WORDSIZE == 32
   ASSERT(f(0) == 0xffffffff);
diff --git a/libguile/lightening/tests/divr.c b/libguile/lightening/tests/divr.c
index 4ca4904ef..399d70de1 100644
--- a/libguile/lightening/tests/divr.c
+++ b/libguile/lightening/tests/divr.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_divr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff, 1) == 0x7fffffff);
   ASSERT(f(1, 0x7fffffff) == 0);
diff --git a/libguile/lightening/tests/divr_d.c b/libguile/lightening/tests/divr_d.c
index d678c7370..9d21cb591 100644
--- a/libguile/lightening/tests/divr_d.c
+++ b/libguile/lightening/tests/divr_d.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_divr_d(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/divr_f.c b/libguile/lightening/tests/divr_f.c
index 0dcf8a618..de519dc75 100644
--- a/libguile/lightening/tests/divr_f.c
+++ b/libguile/lightening/tests/divr_f.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_divr_f(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/divr_u.c b/libguile/lightening/tests/divr_u.c
index c51bbc786..b8305f781 100644
--- a/libguile/lightening/tests/divr_u.c
+++ b/libguile/lightening/tests/divr_u.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_divr_u(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff, 1) == 0x7fffffff);
   ASSERT(f(1, 0x7fffffff) == 0);
diff --git a/libguile/lightening/tests/extr_c.c b/libguile/lightening/tests/extr_c.c
index 834777d69..043068d3f 100644
--- a/libguile/lightening/tests/extr_c.c
+++ b/libguile/lightening/tests/extr_c.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_c(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/extr_d.c b/libguile/lightening/tests/extr_d.c
index 40d20e6d1..af0fe9145 100644
--- a/libguile/lightening/tests/extr_d.c
+++ b/libguile/lightening/tests/extr_d.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_extr_d(j, JIT_F0, JIT_R0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
-  double (*f)(intmax_t) = jit_end(j, NULL);
+  double (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0.0);
   ASSERT(f(1) == 1.0);
diff --git a/libguile/lightening/tests/extr_d_f.c b/libguile/lightening/tests/extr_d_f.c
index 83f7a86f0..049eb5fb5 100644
--- a/libguile/lightening/tests/extr_d_f.c
+++ b/libguile/lightening/tests/extr_d_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_extr_d_f(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(double) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/extr_f.c b/libguile/lightening/tests/extr_f.c
index e84458c16..b57830cae 100644
--- a/libguile/lightening/tests/extr_f.c
+++ b/libguile/lightening/tests/extr_f.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_extr_f(j, JIT_F0, JIT_R0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
-  float (*f)(intmax_t) = jit_end(j, NULL);
+  float (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0.0f);
   ASSERT(f(1) == 1.0f);
diff --git a/libguile/lightening/tests/extr_f_d.c b/libguile/lightening/tests/extr_f_d.c
index 8f14ea4ff..5fa500772 100644
--- a/libguile/lightening/tests/extr_f_d.c
+++ b/libguile/lightening/tests/extr_f_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_extr_f_d(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(float) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/extr_i.c b/libguile/lightening/tests/extr_i.c
index 1a80b5e38..d26a576b5 100644
--- a/libguile/lightening/tests/extr_i.c
+++ b/libguile/lightening/tests/extr_i.c
@@ -5,12 +5,14 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_i(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/extr_s.c b/libguile/lightening/tests/extr_s.c
index e4d1f1eb1..5b39af392 100644
--- a/libguile/lightening/tests/extr_s.c
+++ b/libguile/lightening/tests/extr_s.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_s(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/extr_uc.c b/libguile/lightening/tests/extr_uc.c
index d9890c788..a42e603a9 100644
--- a/libguile/lightening/tests/extr_uc.c
+++ b/libguile/lightening/tests/extr_uc.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_uc(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/extr_ui.c b/libguile/lightening/tests/extr_ui.c
index 6aa6024bb..37964da16 100644
--- a/libguile/lightening/tests/extr_ui.c
+++ b/libguile/lightening/tests/extr_ui.c
@@ -5,12 +5,14 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_ui(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/extr_us.c b/libguile/lightening/tests/extr_us.c
index c10567b4f..38a7c390a 100644
--- a/libguile/lightening/tests/extr_us.c
+++ b/libguile/lightening/tests/extr_us.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_us(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
   ASSERT(f(1) == 1);
diff --git a/libguile/lightening/tests/jmpr.c b/libguile/lightening/tests/jmpr.c
index e81a02759..884089702 100644
--- a/libguile/lightening/tests/jmpr.c
+++ b/libguile/lightening/tests/jmpr.c
@@ -6,7 +6,9 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0));
+  jit_leave_jit_abi(j, 0, 0, align);
 
   jit_jmpr(j, JIT_R0);
 
diff --git a/libguile/lightening/tests/ldi_c.c b/libguile/lightening/tests/ldi_c.c
index e08231596..9d5de8226 100644
--- a/libguile/lightening/tests/ldi_c.c
+++ b/libguile/lightening/tests/ldi_c.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_c(j, JIT_R0, &data[0]);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void) = jit_end(j, NULL);
+  jit_uword_t (*f)(void) = jit_end(j, NULL);
 
   ASSERT(f() == -1);
 }
diff --git a/libguile/lightening/tests/ldi_d.c b/libguile/lightening/tests/ldi_d.c
index 562e35d99..b72cdda61 100644
--- a/libguile/lightening/tests/ldi_d.c
+++ b/libguile/lightening/tests/ldi_d.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_d(j, JIT_F0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(void) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/ldi_f.c b/libguile/lightening/tests/ldi_f.c
index ff9abd006..13e5fd427 100644
--- a/libguile/lightening/tests/ldi_f.c
+++ b/libguile/lightening/tests/ldi_f.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_f(j, JIT_F0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(void) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/ldi_i.c b/libguile/lightening/tests/ldi_i.c
index 7270cbcf0..e38978802 100644
--- a/libguile/lightening/tests/ldi_i.c
+++ b/libguile/lightening/tests/ldi_i.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_i(j, JIT_R0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void) = jit_end(j, NULL);
+  jit_uword_t (*f)(void) = jit_end(j, NULL);
 
   ASSERT(f() == -1);
 }
diff --git a/libguile/lightening/tests/ldi_l.c b/libguile/lightening/tests/ldi_l.c
index 299987049..f3fa729cb 100644
--- a/libguile/lightening/tests/ldi_l.c
+++ b/libguile/lightening/tests/ldi_l.c
@@ -1,17 +1,19 @@
 #include "test.h"
 
-static uint64_t data = 0xffffffffffffffff;
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint64_t data = 0xffffffffffffffff;
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_l(j, JIT_R0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void) = jit_end(j, NULL);
+  jit_uword_t (*f)(void) = jit_end(j, NULL);
 
   ASSERT(f() == -1);
 #endif
diff --git a/libguile/lightening/tests/ldi_s.c b/libguile/lightening/tests/ldi_s.c
index 5713370fa..d9d1c4725 100644
--- a/libguile/lightening/tests/ldi_s.c
+++ b/libguile/lightening/tests/ldi_s.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_s(j, JIT_R0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void) = jit_end(j, NULL);
+  jit_uword_t (*f)(void) = jit_end(j, NULL);
 
   ASSERT(f() == -1);
 }
diff --git a/libguile/lightening/tests/ldi_uc.c b/libguile/lightening/tests/ldi_uc.c
index a99af0eda..12f18bf17 100644
--- a/libguile/lightening/tests/ldi_uc.c
+++ b/libguile/lightening/tests/ldi_uc.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_uc(j, JIT_R0, data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void) = jit_end(j, NULL);
+  jit_uword_t (*f)(void) = jit_end(j, NULL);
 
   ASSERT(f() == 0xff);
 }
diff --git a/libguile/lightening/tests/ldi_ui.c b/libguile/lightening/tests/ldi_ui.c
index c0458a7cb..d233694c6 100644
--- a/libguile/lightening/tests/ldi_ui.c
+++ b/libguile/lightening/tests/ldi_ui.c
@@ -1,17 +1,19 @@
 #include "test.h"
 
-static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_ui(j, JIT_R0, data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void) = jit_end(j, NULL);
+  jit_uword_t (*f)(void) = jit_end(j, NULL);
 
   ASSERT(f() == data[0]);
 #endif
diff --git a/libguile/lightening/tests/ldi_us.c b/libguile/lightening/tests/ldi_us.c
index 3c9ca5122..70eb4a093 100644
--- a/libguile/lightening/tests/ldi_us.c
+++ b/libguile/lightening/tests/ldi_us.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_us(j, JIT_R0, data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void) = jit_end(j, NULL);
+  jit_uword_t (*f)(void) = jit_end(j, NULL);
 
   ASSERT(f() == data[0]);
 }
diff --git a/libguile/lightening/tests/ldr_c.c b/libguile/lightening/tests/ldr_c.c
index 0d50d4d59..07a59314b 100644
--- a/libguile/lightening/tests/ldr_c.c
+++ b/libguile/lightening/tests/ldr_c.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_c(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*) = jit_end(j, NULL);
 
   ASSERT(f(&data[0]) == -1);
   ASSERT(f(&data[1]) == 0);
diff --git a/libguile/lightening/tests/ldr_d.c b/libguile/lightening/tests/ldr_d.c
index 5f3073ada..37c75f096 100644
--- a/libguile/lightening/tests/ldr_d.c
+++ b/libguile/lightening/tests/ldr_d.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_d(j, JIT_F0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(void*) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/ldr_f.c b/libguile/lightening/tests/ldr_f.c
index c0776b6d3..bb6827848 100644
--- a/libguile/lightening/tests/ldr_f.c
+++ b/libguile/lightening/tests/ldr_f.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_f(j, JIT_F0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(void*) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/ldr_i.c b/libguile/lightening/tests/ldr_i.c
index ed8784a40..3de9e5f2c 100644
--- a/libguile/lightening/tests/ldr_i.c
+++ b/libguile/lightening/tests/ldr_i.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_i(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*) = jit_end(j, NULL);
 
   ASSERT(f(&data[0]) == -1);
   ASSERT(f(&data[1]) == 0);
diff --git a/libguile/lightening/tests/ldr_l.c b/libguile/lightening/tests/ldr_l.c
index d71f3e47e..15f00801e 100644
--- a/libguile/lightening/tests/ldr_l.c
+++ b/libguile/lightening/tests/ldr_l.c
@@ -1,18 +1,20 @@
 #include "test.h"
 
-static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_l(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*) = jit_end(j, NULL);
 
   ASSERT(f(&data[0]) == -1);
   ASSERT(f(&data[1]) == 0);
diff --git a/libguile/lightening/tests/ldr_s.c b/libguile/lightening/tests/ldr_s.c
index af83dc7e6..cf668d5b3 100644
--- a/libguile/lightening/tests/ldr_s.c
+++ b/libguile/lightening/tests/ldr_s.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_s(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*) = jit_end(j, NULL);
 
   ASSERT(f(&data[0]) == -1);
   ASSERT(f(&data[1]) == 0);
diff --git a/libguile/lightening/tests/ldr_uc.c b/libguile/lightening/tests/ldr_uc.c
index 54a207531..a48f37056 100644
--- a/libguile/lightening/tests/ldr_uc.c
+++ b/libguile/lightening/tests/ldr_uc.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_uc(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*) = jit_end(j, NULL);
 
   ASSERT(f(&data[0]) == 0xff);
   ASSERT(f(&data[1]) == 0);
diff --git a/libguile/lightening/tests/ldr_ui.c b/libguile/lightening/tests/ldr_ui.c
index 1867812b4..7668778b5 100644
--- a/libguile/lightening/tests/ldr_ui.c
+++ b/libguile/lightening/tests/ldr_ui.c
@@ -1,18 +1,20 @@
 #include "test.h"
 
-static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_ui(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*) = jit_end(j, NULL);
 
   ASSERT(f(&data[0]) == data[0]);
   ASSERT(f(&data[1]) == data[1]);
diff --git a/libguile/lightening/tests/ldr_us.c b/libguile/lightening/tests/ldr_us.c
index 5387882a6..bb9928bf0 100644
--- a/libguile/lightening/tests/ldr_us.c
+++ b/libguile/lightening/tests/ldr_us.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_us(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*) = jit_end(j, NULL);
 
   ASSERT(f(&data[0]) == data[0]);
   ASSERT(f(&data[1]) == data[1]);
diff --git a/libguile/lightening/tests/ldxi_c.c b/libguile/lightening/tests/ldxi_c.c
index 58d1de9d4..4271f9753 100644
--- a/libguile/lightening/tests/ldxi_c.c
+++ b/libguile/lightening/tests/ldxi_c.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_c(j, JIT_R0, JIT_R0, (uintptr_t)&data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == -1);
   ASSERT(f(1) == 0);
diff --git a/libguile/lightening/tests/ldxi_d.c b/libguile/lightening/tests/ldxi_d.c
index c74992069..6bcf632cc 100644
--- a/libguile/lightening/tests/ldxi_d.c
+++ b/libguile/lightening/tests/ldxi_d.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_d(j, JIT_F0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
-  double (*f)(uintmax_t) = jit_end(j, NULL);
+  double (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == data[0]);
   ASSERT(f(8) == data[1]);
diff --git a/libguile/lightening/tests/ldxi_f.c b/libguile/lightening/tests/ldxi_f.c
index 33206debb..9e65321d8 100644
--- a/libguile/lightening/tests/ldxi_f.c
+++ b/libguile/lightening/tests/ldxi_f.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_f(j, JIT_F0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
-  float (*f)(uintmax_t) = jit_end(j, NULL);
+  float (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == data[0]);
   ASSERT(f(4) == data[1]);
diff --git a/libguile/lightening/tests/ldxi_i.c b/libguile/lightening/tests/ldxi_i.c
index f51bb5cfd..d1f7b5605 100644
--- a/libguile/lightening/tests/ldxi_i.c
+++ b/libguile/lightening/tests/ldxi_i.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0));
 
   jit_ldxi_i(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == -1);
   ASSERT(f(4) == 0);
diff --git a/libguile/lightening/tests/ldxi_l.c b/libguile/lightening/tests/ldxi_l.c
index 9bdc6559c..bb1a8b257 100644
--- a/libguile/lightening/tests/ldxi_l.c
+++ b/libguile/lightening/tests/ldxi_l.c
@@ -1,18 +1,20 @@
 #include "test.h"
 
-static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
+
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_l(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == -1);
   ASSERT(f(8) == 0);
diff --git a/libguile/lightening/tests/ldxi_s.c b/libguile/lightening/tests/ldxi_s.c
index 4c75cc2b1..c9376d0fb 100644
--- a/libguile/lightening/tests/ldxi_s.c
+++ b/libguile/lightening/tests/ldxi_s.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_s(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == -1);
   ASSERT(f(2) == 0);
diff --git a/libguile/lightening/tests/ldxi_uc.c b/libguile/lightening/tests/ldxi_uc.c
index ebe91b46a..31d7b73d3 100644
--- a/libguile/lightening/tests/ldxi_uc.c
+++ b/libguile/lightening/tests/ldxi_uc.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_uc(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0xff);
   ASSERT(f(1) == 0);
diff --git a/libguile/lightening/tests/ldxi_ui.c b/libguile/lightening/tests/ldxi_ui.c
index ad1599f65..4f7e304a6 100644
--- a/libguile/lightening/tests/ldxi_ui.c
+++ b/libguile/lightening/tests/ldxi_ui.c
@@ -1,18 +1,20 @@
 #include "test.h"
 
-static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
+
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_ui(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == data[0]);
   ASSERT(f(4) == data[1]);
diff --git a/libguile/lightening/tests/ldxi_us.c b/libguile/lightening/tests/ldxi_us.c
index a50e4edc1..81c984f1f 100644
--- a/libguile/lightening/tests/ldxi_us.c
+++ b/libguile/lightening/tests/ldxi_us.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_us(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == data[0]);
   ASSERT(f(2) == data[1]);
diff --git a/libguile/lightening/tests/ldxr_c.c b/libguile/lightening/tests/ldxr_c.c
index dd3df16ff..366f5b2f3 100644
--- a/libguile/lightening/tests/ldxr_c.c
+++ b/libguile/lightening/tests/ldxr_c.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_c(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == -1);
   ASSERT(f(data, 1) == 0);
diff --git a/libguile/lightening/tests/ldxr_d.c b/libguile/lightening/tests/ldxr_d.c
index 28543b7c6..38a12fdd5 100644
--- a/libguile/lightening/tests/ldxr_d.c
+++ b/libguile/lightening/tests/ldxr_d.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_d(j, JIT_F0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
-  double (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  double (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == data[0]);
   ASSERT(f(data, 8) == data[1]);
diff --git a/libguile/lightening/tests/ldxr_f.c b/libguile/lightening/tests/ldxr_f.c
index a87f15acd..c48b11f8f 100644
--- a/libguile/lightening/tests/ldxr_f.c
+++ b/libguile/lightening/tests/ldxr_f.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_f(j, JIT_F0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
-  float (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  float (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == data[0]);
   ASSERT(f(data, 4) == data[1]);
diff --git a/libguile/lightening/tests/ldxr_i.c b/libguile/lightening/tests/ldxr_i.c
index 65ed0395b..e4149aade 100644
--- a/libguile/lightening/tests/ldxr_i.c
+++ b/libguile/lightening/tests/ldxr_i.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_i(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == -1);
   ASSERT(f(data, 4) == 0);
diff --git a/libguile/lightening/tests/ldxr_l.c b/libguile/lightening/tests/ldxr_l.c
index d8afce547..ee9f156a7 100644
--- a/libguile/lightening/tests/ldxr_l.c
+++ b/libguile/lightening/tests/ldxr_l.c
@@ -1,19 +1,21 @@
 #include "test.h"
 
-static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_l(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == -1);
   ASSERT(f(data, 8) == 0);
diff --git a/libguile/lightening/tests/ldxr_s.c b/libguile/lightening/tests/ldxr_s.c
index 7f0724c27..fbb5c090c 100644
--- a/libguile/lightening/tests/ldxr_s.c
+++ b/libguile/lightening/tests/ldxr_s.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_s(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == -1);
   ASSERT(f(data, 2) == 0);
diff --git a/libguile/lightening/tests/ldxr_uc.c b/libguile/lightening/tests/ldxr_uc.c
index d6dcaf979..846c552c2 100644
--- a/libguile/lightening/tests/ldxr_uc.c
+++ b/libguile/lightening/tests/ldxr_uc.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_uc(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == 0xff);
   ASSERT(f(data, 1) == 0);
diff --git a/libguile/lightening/tests/ldxr_ui.c b/libguile/lightening/tests/ldxr_ui.c
index 4e2d773be..cd774d355 100644
--- a/libguile/lightening/tests/ldxr_ui.c
+++ b/libguile/lightening/tests/ldxr_ui.c
@@ -1,19 +1,21 @@
 #include "test.h"
 
-static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_ui(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == data[0]);
   ASSERT(f(data, 4) == data[1]);
diff --git a/libguile/lightening/tests/ldxr_us.c b/libguile/lightening/tests/ldxr_us.c
index 78d38f5ef..b7e408bb9 100644
--- a/libguile/lightening/tests/ldxr_us.c
+++ b/libguile/lightening/tests/ldxr_us.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_us(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  uintmax_t (*f)(void*, uintmax_t) = jit_end(j, NULL);
+  jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
 
   ASSERT(f(data, 0) == data[0]);
   ASSERT(f(data, 2) == data[1]);
diff --git a/libguile/lightening/tests/lshi.c b/libguile/lightening/tests/lshi.c
index 183aed9ff..e721af58b 100644
--- a/libguile/lightening/tests/lshi.c
+++ b/libguile/lightening/tests/lshi.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_lshi(j, JIT_R0, JIT_R0, 31);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
 #if __WORDSIZE == 32
   ASSERT(f(-0x7f) == 0x80000000);
diff --git a/libguile/lightening/tests/lshr.c b/libguile/lightening/tests/lshr.c
index 5f3d5b96e..f81aa690a 100644
--- a/libguile/lightening/tests/lshr.c
+++ b/libguile/lightening/tests/lshr.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_lshr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7f, 1) == 0xfe);
   ASSERT(f(0x7fff, 2) == 0x1fffc);
diff --git a/libguile/lightening/tests/mov_addr.c b/libguile/lightening/tests/mov_addr.c
index 0d7d9e071..b4a9aaae1 100644
--- a/libguile/lightening/tests/mov_addr.c
+++ b/libguile/lightening/tests/mov_addr.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_patch_there(j, jit_mov_addr(j, JIT_R0), &thing);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   void* (*f)(void) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/movi_d.c b/libguile/lightening/tests/movi_d.c
index 58ec949fc..cb9e63d47 100644
--- a/libguile/lightening/tests/movi_d.c
+++ b/libguile/lightening/tests/movi_d.c
@@ -4,8 +4,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_movi_d(j, JIT_F0, 3.14159);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(void) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/movi_f.c b/libguile/lightening/tests/movi_f.c
index 0b92f9242..944f61589 100644
--- a/libguile/lightening/tests/movi_f.c
+++ b/libguile/lightening/tests/movi_f.c
@@ -4,8 +4,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_movi_f(j, JIT_F0, 3.14159f);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(void) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/mulr.c b/libguile/lightening/tests/mulr.c
index 943b31e01..452e35dcb 100644
--- a/libguile/lightening/tests/mulr.c
+++ b/libguile/lightening/tests/mulr.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_mulr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff, 1) == 0x7fffffff);
   ASSERT(f(1, 0x7fffffff) == 0x7fffffff);
diff --git a/libguile/lightening/tests/mulr_d.c b/libguile/lightening/tests/mulr_d.c
index 460b14baf..945f1527d 100644
--- a/libguile/lightening/tests/mulr_d.c
+++ b/libguile/lightening/tests/mulr_d.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_mulr_d(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/mulr_f.c b/libguile/lightening/tests/mulr_f.c
index 6189be263..2d0dd4ffa 100644
--- a/libguile/lightening/tests/mulr_f.c
+++ b/libguile/lightening/tests/mulr_f.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_mulr_f(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/negr.c b/libguile/lightening/tests/negr.c
index 974d3f0e9..18e27cbbb 100644
--- a/libguile/lightening/tests/negr.c
+++ b/libguile/lightening/tests/negr.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_negr(j, JIT_R0, JIT_R0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
   ASSERT(f(0) == 0);
 #if __WORDSIZE == 32
diff --git a/libguile/lightening/tests/negr_d.c b/libguile/lightening/tests/negr_d.c
index 566061c46..d0e168b8c 100644
--- a/libguile/lightening/tests/negr_d.c
+++ b/libguile/lightening/tests/negr_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_negr_d(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(double) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/negr_f.c b/libguile/lightening/tests/negr_f.c
index 24b509f41..26110d560 100644
--- a/libguile/lightening/tests/negr_f.c
+++ b/libguile/lightening/tests/negr_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_negr_f(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(float) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/nop.c b/libguile/lightening/tests/nop.c
index 16c5c8a7e..c029954d2 100644
--- a/libguile/lightening/tests/nop.c
+++ b/libguile/lightening/tests/nop.c
@@ -4,6 +4,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   size_t total = 0;
   char *start = jit_address(j);
@@ -11,9 +12,10 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
     jit_nop(j, i);
   char *end = jit_address(j);
   ASSERT(end - start == total);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 42);
 
-  intmax_t (*f)(void) = jit_end(j, NULL);
+  jit_word_t (*f)(void) = jit_end(j, NULL);
   ASSERT(f() == 42);
 }
 
diff --git a/libguile/lightening/tests/ori.c b/libguile/lightening/tests/ori.c
index ad555769d..631018527 100644
--- a/libguile/lightening/tests/ori.c
+++ b/libguile/lightening/tests/ori.c
@@ -4,15 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ori(j, JIT_R0, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff) == 0x7fffffff);
   ASSERT(f(0x80000000) == 0x80000001);
diff --git a/libguile/lightening/tests/orr.c b/libguile/lightening/tests/orr.c
index 10b7c3d17..5a9087a3d 100644
--- a/libguile/lightening/tests/orr.c
+++ b/libguile/lightening/tests/orr.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_orr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff, 1) == 0x7fffffff);
   ASSERT(f(1, 0x7fffffff) == 0x7fffffff);
diff --git a/libguile/lightening/tests/pushpop.c b/libguile/lightening/tests/pushpop.c
index d2a4ab7bb..cd2420bdd 100644
--- a/libguile/lightening/tests/pushpop.c
+++ b/libguile/lightening/tests/pushpop.c
@@ -7,13 +7,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   const jit_fpr_t fpr[] = { JIT_F0, JIT_F1, JIT_F2 };
 
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 3, 0, 0);
 
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
-  for (int i=0; i<6; i++)
-    jit_pushr(j, gpr[i]);
-  for (int i=0; i<3; i++)
-    jit_pushr_d(j, fpr[i]);
+  jit_pushr(j, JIT_R0);
 
   // Stomple registers.
   for (int i=0; i<6; i++)
@@ -21,14 +19,12 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   for (int i=0; i<3; i++)
     jit_extr_d(j, fpr[i], gpr[i]);
 
-  for (int i=2; i>=0; i--)
-    jit_popr_d(j, fpr[i]);
-  for (int i=5; i>=0; i--)
-    jit_popr(j, gpr[i]);
+  jit_popr(j, JIT_R0);
 
+  jit_leave_jit_abi(j, 3, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
   ASSERT(f(42) == 42);
 }
 
diff --git a/libguile/lightening/tests/qdivr.c b/libguile/lightening/tests/qdivr.c
index b4dd8f637..665053c56 100644
--- a/libguile/lightening/tests/qdivr.c
+++ b/libguile/lightening/tests/qdivr.c
@@ -1,52 +1,34 @@
 #include "test.h"
 
 static void
-maybe_save(jit_state_t *j, jit_gpr_t 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 (reg))
-    jit_popr(j, reg);
-}    
-
-static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  maybe_save(j, JIT_V0);
-  maybe_save(j, JIT_V1);
-  maybe_save(j, JIT_V2);
+  size_t align = jit_enter_jit_abi(j, 3, 0, 0);
 
   jit_operand_t args[] =
     { jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
       jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1),
-      jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
-      jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_V0) };
+      jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
+      jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_V0) };
   jit_load_args(j, 4, args);
 
   jit_qdivr(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
   jit_str(j, JIT_R0, JIT_V1);
   jit_str(j, JIT_R1, JIT_V2);
 
-  maybe_restore(j, JIT_V2);
-  maybe_restore(j, JIT_V1);
-  maybe_restore(j, JIT_V0);
+  jit_leave_jit_abi(j, 3, 0, align);
 
   jit_ret(j);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  void (*f)(intmax_t*, intmax_t*, intmax_t, intmax_t) = ret;
+  void (*f)(jit_word_t*, jit_word_t*, jit_word_t, jit_word_t) = ret;
 
 #define QDIV(a, b, c, d) \
   do { \
-    intmax_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); ASSERT(D == d); \
+    jit_word_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); ASSERT(D == d); \
   } while (0)
   
   QDIV(10, 3, 3, 1);
diff --git a/libguile/lightening/tests/qdivr_u.c b/libguile/lightening/tests/qdivr_u.c
index 30849bd54..e2601933c 100644
--- a/libguile/lightening/tests/qdivr_u.c
+++ b/libguile/lightening/tests/qdivr_u.c
@@ -1,53 +1,34 @@
 #include "test.h"
 
 static void
-maybe_save(jit_state_t *j, jit_gpr_t 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 (reg))
-    jit_popr(j, reg);
-}    
-
-static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
 
-  maybe_save(j, JIT_V0);
-  maybe_save(j, JIT_V1);
-  maybe_save(j, JIT_V2);
+  size_t align = jit_enter_jit_abi(j, 3, 0, 0);
 
   jit_operand_t args[] =
     { jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
       jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1),
-      jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
-      jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_V0) };
+      jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
+      jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_V0) };
   jit_load_args(j, 4, args);
 
   jit_qdivr_u(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
   jit_str(j, JIT_R0, JIT_V1);
   jit_str(j, JIT_R1, JIT_V2);
 
-  maybe_restore(j, JIT_V2);
-  maybe_restore(j, JIT_V1);
-  maybe_restore(j, JIT_V0);
+  jit_leave_jit_abi(j, 3, 0, align);
 
   jit_ret(j);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  void (*f)(intmax_t*, intmax_t*, intmax_t, intmax_t) = ret;
-
+  void (*f)(jit_word_t*, jit_word_t*, jit_word_t, jit_word_t) = ret;
 #define QDIV(a, b, c, d) \
   do { \
-    intmax_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); ASSERT(D == d); \
+    jit_word_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); ASSERT(D == d); \
   } while (0)
   
   QDIV(-1, -2, 1, 1);
diff --git a/libguile/lightening/tests/qmulr.c b/libguile/lightening/tests/qmulr.c
index 9d0b2324e..1645f5a9f 100644
--- a/libguile/lightening/tests/qmulr.c
+++ b/libguile/lightening/tests/qmulr.c
@@ -1,53 +1,35 @@
 #include "test.h"
 
 static void
-maybe_save(jit_state_t *j, jit_gpr_t 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 (reg))
-    jit_popr(j, reg);
-}    
-
-static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
 
-  maybe_save(j, JIT_V0);
-  maybe_save(j, JIT_V1);
-  maybe_save(j, JIT_V2);
+  size_t align = jit_enter_jit_abi(j, 3, 0, 0);
 
   jit_operand_t args[] =
     { jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
       jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1),
-      jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
-      jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_V0) };
+      jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
+      jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_V0) };
   jit_load_args(j, 4, args);
 
   jit_qmulr(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
   jit_str(j, JIT_R0, JIT_V1);
   jit_str(j, JIT_R1, JIT_V2);
 
-  maybe_restore(j, JIT_V2);
-  maybe_restore(j, JIT_V1);
-  maybe_restore(j, JIT_V0);
+  jit_leave_jit_abi(j, 3, 0, align);
 
   jit_ret(j);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  void (*f)(intmax_t*, intmax_t*, intmax_t, intmax_t) = ret;
+  void (*f)(jit_word_t*, jit_word_t*, jit_word_t, jit_word_t) = ret;
 
 #define QMUL(a, b, c, d) \
   do { \
-    intmax_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); ASSERT(D == d); \
+    jit_word_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); ASSERT(D == d); \
   } while (0)
   
   QMUL(-2, -1, 2, 0);
diff --git a/libguile/lightening/tests/qmulr_u.c b/libguile/lightening/tests/qmulr_u.c
index 741ea8175..bb1d50d17 100644
--- a/libguile/lightening/tests/qmulr_u.c
+++ b/libguile/lightening/tests/qmulr_u.c
@@ -1,53 +1,35 @@
 #include "test.h"
 
 static void
-maybe_save(jit_state_t *j, jit_gpr_t 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 (reg))
-    jit_popr(j, reg);
-}    
-
-static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
 
-  maybe_save(j, JIT_V0);
-  maybe_save(j, JIT_V1);
-  maybe_save(j, JIT_V2);
+  size_t align = jit_enter_jit_abi(j, 3, 0, 0);
 
   jit_operand_t args[] =
     { jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
       jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1),
-      jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
-      jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_V0) };
+      jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
+      jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_V0) };
   jit_load_args(j, 4, args);
 
   jit_qmulr_u(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
   jit_str(j, JIT_R0, JIT_V1);
   jit_str(j, JIT_R1, JIT_V2);
 
-  maybe_restore(j, JIT_V2);
-  maybe_restore(j, JIT_V1);
-  maybe_restore(j, JIT_V0);
+  jit_leave_jit_abi(j, 3, 0, align);
 
   jit_ret(j);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  void (*f)(intmax_t*, intmax_t*, intmax_t, intmax_t) = ret;
+  void (*f)(jit_word_t*, jit_word_t*, jit_word_t, jit_word_t) = ret;
 
 #define UQMUL(a, b, c, d) \
   do { \
-    intmax_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); ASSERT(D == d); \
+    jit_word_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); ASSERT(D == d); \
   } while (0)
   
 #if __WORDSIZE == 32
diff --git a/libguile/lightening/tests/remr.c b/libguile/lightening/tests/remr.c
index 3c61384b6..805d6fbf9 100644
--- a/libguile/lightening/tests/remr.c
+++ b/libguile/lightening/tests/remr.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_remr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff, 1) == 0);
   ASSERT(f(1, 0x7fffffff) == 1);
diff --git a/libguile/lightening/tests/remr_u.c b/libguile/lightening/tests/remr_u.c
index 01113dbef..a9a01789a 100644
--- a/libguile/lightening/tests/remr_u.c
+++ b/libguile/lightening/tests/remr_u.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_remr_u(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff, 1) == 0);
   ASSERT(f(1, 0x7fffffff) == 1);
diff --git a/libguile/lightening/tests/rshi.c b/libguile/lightening/tests/rshi.c
index 1f1ed6d94..c536055dc 100644
--- a/libguile/lightening/tests/rshi.c
+++ b/libguile/lightening/tests/rshi.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_rshi(j, JIT_R0, JIT_R0, 31);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
 #if __WORDSIZE == 32
   ASSERT(f(0x80000000) == -1);
diff --git a/libguile/lightening/tests/rshi_u.c b/libguile/lightening/tests/rshi_u.c
index e78a205b8..8f6dbd4e3 100644
--- a/libguile/lightening/tests/rshi_u.c
+++ b/libguile/lightening/tests/rshi_u.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_rshi_u(j, JIT_R0, JIT_R0, 31);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
-  intmax_t (*f)(intmax_t) = jit_end(j, NULL);
+  jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
 
 #if __WORDSIZE == 32
   ASSERT(f(0x80000000) == 1);
diff --git a/libguile/lightening/tests/rshr.c b/libguile/lightening/tests/rshr.c
index 1a32bfd03..b4b568907 100644
--- a/libguile/lightening/tests/rshr.c
+++ b/libguile/lightening/tests/rshr.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_rshr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0xfe, 1) == 0x7f);
   ASSERT(f(0x1fffc, 2) == 0x7fff);
diff --git a/libguile/lightening/tests/rshr_u.c b/libguile/lightening/tests/rshr_u.c
index 644e71728..64c59fddb 100644
--- a/libguile/lightening/tests/rshr_u.c
+++ b/libguile/lightening/tests/rshr_u.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_rshr_u(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0xfe, 1) == 0x7f);
   ASSERT(f(0x1fffc, 2) == 0x7fff);
diff --git a/libguile/lightening/tests/sqrtr_d.c b/libguile/lightening/tests/sqrtr_d.c
index 35e2230a7..873deb919 100644
--- a/libguile/lightening/tests/sqrtr_d.c
+++ b/libguile/lightening/tests/sqrtr_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_sqrtr_d(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(double) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/sqrtr_f.c b/libguile/lightening/tests/sqrtr_f.c
index 0c3737337..66db83139 100644
--- a/libguile/lightening/tests/sqrtr_f.c
+++ b/libguile/lightening/tests/sqrtr_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_sqrtr_f(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(float) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/sti_c.c b/libguile/lightening/tests/sti_c.c
index 61ae9b69d..ff6e6d563 100644
--- a/libguile/lightening/tests/sti_c.c
+++ b/libguile/lightening/tests/sti_c.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_sti_c(j, &data[1], JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(int8_t) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/sti_d.c b/libguile/lightening/tests/sti_d.c
index c10b7b7dd..8a703e6b6 100644
--- a/libguile/lightening/tests/sti_d.c
+++ b/libguile/lightening/tests/sti_d.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_sti_d(j, &data[1], JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(double) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/sti_f.c b/libguile/lightening/tests/sti_f.c
index 240152654..e0271925b 100644
--- a/libguile/lightening/tests/sti_f.c
+++ b/libguile/lightening/tests/sti_f.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_sti_f(j, &data[1], JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(float) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/sti_i.c b/libguile/lightening/tests/sti_i.c
index c8bb72e73..4a233c657 100644
--- a/libguile/lightening/tests/sti_i.c
+++ b/libguile/lightening/tests/sti_i.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_sti_i(j, &data[1], JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(int32_t) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/sti_l.c b/libguile/lightening/tests/sti_l.c
index 5bd4ed19f..fce9180b2 100644
--- a/libguile/lightening/tests/sti_l.c
+++ b/libguile/lightening/tests/sti_l.c
@@ -1,15 +1,17 @@
 #include "test.h"
 
-static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT64, JIT_R1));
 
   jit_sti_l(j, &data[1], JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(int64_t) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/sti_s.c b/libguile/lightening/tests/sti_s.c
index 4d4b27212..daab0bda2 100644
--- a/libguile/lightening/tests/sti_s.c
+++ b/libguile/lightening/tests/sti_s.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_sti_s(j, &data[1], JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(int16_t) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/str_c.c b/libguile/lightening/tests/str_c.c
index f8d7d7543..b894b8281 100644
--- a/libguile/lightening/tests/str_c.c
+++ b/libguile/lightening/tests/str_c.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_str_c(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, int8_t) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/str_d.c b/libguile/lightening/tests/str_d.c
index 817fd64a2..2f992a66a 100644
--- a/libguile/lightening/tests/str_d.c
+++ b/libguile/lightening/tests/str_d.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_str_d(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, double) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/str_f.c b/libguile/lightening/tests/str_f.c
index 22af0d580..fdad3c244 100644
--- a/libguile/lightening/tests/str_f.c
+++ b/libguile/lightening/tests/str_f.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_str_f(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, float) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/str_i.c b/libguile/lightening/tests/str_i.c
index 3872ed771..968f0ce91 100644
--- a/libguile/lightening/tests/str_i.c
+++ b/libguile/lightening/tests/str_i.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_str_i(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, int32_t) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/str_l.c b/libguile/lightening/tests/str_l.c
index 0b4755c24..450885b39 100644
--- a/libguile/lightening/tests/str_l.c
+++ b/libguile/lightening/tests/str_l.c
@@ -1,16 +1,18 @@
 #include "test.h"
 
-static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT64, JIT_R1));
 
   jit_str_l(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, int64_t) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/str_s.c b/libguile/lightening/tests/str_s.c
index 0044d8286..3e228edc7 100644
--- a/libguile/lightening/tests/str_s.c
+++ b/libguile/lightening/tests/str_s.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_str_s(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, int16_t) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/stxi_c.c b/libguile/lightening/tests/stxi_c.c
index c38e5292e..d76d814f5 100644
--- a/libguile/lightening/tests/stxi_c.c
+++ b/libguile/lightening/tests/stxi_c.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_stxi_c(j, (uintptr_t)data, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(intmax_t, int8_t) = jit_end(j, NULL);
+  void (*f)(jit_word_t, int8_t) = jit_end(j, NULL);
 
   ASSERT(data[0] == 0x12);
   ASSERT(data[1] == 0x00);
diff --git a/libguile/lightening/tests/stxi_d.c b/libguile/lightening/tests/stxi_d.c
index cf68704cc..3933c5692 100644
--- a/libguile/lightening/tests/stxi_d.c
+++ b/libguile/lightening/tests/stxi_d.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_stxi_d(j, (uintptr_t)data, JIT_R2, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(intmax_t, double) = jit_end(j, NULL);
+  void (*f)(jit_word_t, double) = jit_end(j, NULL);
 
   ASSERT(data[0] == -1.0);
   ASSERT(data[1] == 0.0);
diff --git a/libguile/lightening/tests/stxi_f.c b/libguile/lightening/tests/stxi_f.c
index cec7fba69..aea6756cc 100644
--- a/libguile/lightening/tests/stxi_f.c
+++ b/libguile/lightening/tests/stxi_f.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_stxi_f(j, (uintptr_t)data, JIT_R2, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(intmax_t, float) = jit_end(j, NULL);
+  void (*f)(jit_word_t, float) = jit_end(j, NULL);
 
   ASSERT(data[0] == -1.0f);
   ASSERT(data[1] == 0.0f);
diff --git a/libguile/lightening/tests/stxi_i.c b/libguile/lightening/tests/stxi_i.c
index d0aef1116..79dab03c4 100644
--- a/libguile/lightening/tests/stxi_i.c
+++ b/libguile/lightening/tests/stxi_i.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_stxi_i(j, (uintptr_t)data, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(intmax_t, int32_t) = jit_end(j, NULL);
+  void (*f)(jit_word_t, int32_t) = jit_end(j, NULL);
 
   ASSERT(data[0] == 0x12121212);
   ASSERT(data[1] == 0x00);
diff --git a/libguile/lightening/tests/stxi_l.c b/libguile/lightening/tests/stxi_l.c
index f731ee49b..8a6824136 100644
--- a/libguile/lightening/tests/stxi_l.c
+++ b/libguile/lightening/tests/stxi_l.c
@@ -1,19 +1,21 @@
 #include "test.h"
 
-static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
+
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT64, JIT_R1));
 
   jit_stxi_l(j, (uintptr_t)data, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(intmax_t, int64_t) = jit_end(j, NULL);
+  void (*f)(jit_word_t, int64_t) = jit_end(j, NULL);
 
   ASSERT(data[0] == 0x1212121212121212);
   ASSERT(data[1] == 0x00);
diff --git a/libguile/lightening/tests/stxi_s.c b/libguile/lightening/tests/stxi_s.c
index 4deb826e6..64bda5d6c 100644
--- a/libguile/lightening/tests/stxi_s.c
+++ b/libguile/lightening/tests/stxi_s.c
@@ -6,13 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_stxi_s(j, (uintptr_t)data, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(intmax_t, int16_t) = jit_end(j, NULL);
+  void (*f)(jit_word_t, int16_t) = jit_end(j, NULL);
 
   ASSERT(data[0] == 0x1212);
   ASSERT(data[1] == 0);
diff --git a/libguile/lightening/tests/stxr_c.c b/libguile/lightening/tests/stxr_c.c
index bcebb3530..887685542 100644
--- a/libguile/lightening/tests/stxr_c.c
+++ b/libguile/lightening/tests/stxr_c.c
@@ -6,14 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_stxr_c(j, JIT_R0, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(void*, intmax_t, int8_t) = jit_end(j, NULL);
+  void (*f)(void*, jit_word_t, int8_t) = jit_end(j, NULL);
 
   ASSERT(data[0] == 0x12);
   ASSERT(data[1] == 0x00);
diff --git a/libguile/lightening/tests/stxr_d.c b/libguile/lightening/tests/stxr_d.c
index ba4988a8d..e87688aa1 100644
--- a/libguile/lightening/tests/stxr_d.c
+++ b/libguile/lightening/tests/stxr_d.c
@@ -6,14 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_stxr_d(j, JIT_R0, JIT_R2, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(void*, intmax_t, double) = jit_end(j, NULL);
+  void (*f)(void*, jit_word_t, double) = jit_end(j, NULL);
 
   ASSERT(data[0] == -1.0);
   ASSERT(data[1] == 0.0);
diff --git a/libguile/lightening/tests/stxr_f.c b/libguile/lightening/tests/stxr_f.c
index 30c1e92de..bf0c47625 100644
--- a/libguile/lightening/tests/stxr_f.c
+++ b/libguile/lightening/tests/stxr_f.c
@@ -6,14 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_stxr_f(j, JIT_R0, JIT_R2, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(void*, intmax_t, float) = jit_end(j, NULL);
+  void (*f)(void*, jit_word_t, float) = jit_end(j, NULL);
 
   ASSERT(data[0] == -1.0f);
   ASSERT(data[1] == 0.0f);
diff --git a/libguile/lightening/tests/stxr_i.c b/libguile/lightening/tests/stxr_i.c
index 247cab215..82604627b 100644
--- a/libguile/lightening/tests/stxr_i.c
+++ b/libguile/lightening/tests/stxr_i.c
@@ -6,14 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_stxr_i(j, JIT_R0, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(void*, intmax_t, int32_t) = jit_end(j, NULL);
+  void (*f)(void*, jit_word_t, int32_t) = jit_end(j, NULL);
 
   ASSERT(data[0] == 0x12121212);
   ASSERT(data[1] == 0x00);
diff --git a/libguile/lightening/tests/stxr_l.c b/libguile/lightening/tests/stxr_l.c
index e680238c5..fa6bb1fbb 100644
--- a/libguile/lightening/tests/stxr_l.c
+++ b/libguile/lightening/tests/stxr_l.c
@@ -1,20 +1,22 @@
 #include "test.h"
 
-static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
-
 static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
+  static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
+
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT64, JIT_R1));
 
   jit_stxr_l(j, JIT_R0, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(void*, intmax_t, int64_t) = jit_end(j, NULL);
+  void (*f)(void*, jit_word_t, int64_t) = jit_end(j, NULL);
 
   ASSERT(data[0] == 0x1212121212121212);
   ASSERT(data[1] == 0x00);
diff --git a/libguile/lightening/tests/stxr_s.c b/libguile/lightening/tests/stxr_s.c
index 02d848382..a93ccd9e9 100644
--- a/libguile/lightening/tests/stxr_s.c
+++ b/libguile/lightening/tests/stxr_s.c
@@ -6,14 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_stxr_s(j, JIT_R0, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
-  void (*f)(void*, intmax_t, int16_t) = jit_end(j, NULL);
+  void (*f)(void*, jit_word_t, int16_t) = jit_end(j, NULL);
 
   ASSERT(data[0] == 0x1212);
   ASSERT(data[1] == 0);
diff --git a/libguile/lightening/tests/subr.c b/libguile/lightening/tests/subr.c
index 0ed2e320b..57cf950c7 100644
--- a/libguile/lightening/tests/subr.c
+++ b/libguile/lightening/tests/subr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_subr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/subr_d.c b/libguile/lightening/tests/subr_d.c
index 71259a8e3..bc611c52e 100644
--- a/libguile/lightening/tests/subr_d.c
+++ b/libguile/lightening/tests/subr_d.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_subr_d(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/subr_f.c b/libguile/lightening/tests/subr_f.c
index 410dc265d..a7befecfa 100644
--- a/libguile/lightening/tests/subr_f.c
+++ b/libguile/lightening/tests/subr_f.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_subr_f(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   size_t size = 0;
diff --git a/libguile/lightening/tests/subx.c b/libguile/lightening/tests/subx.c
index 91f1f9565..b88bcbdb1 100644
--- a/libguile/lightening/tests/subx.c
+++ b/libguile/lightening/tests/subx.c
@@ -4,18 +4,20 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_movi(j, JIT_R2, 0);
   jit_subcr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_subxi(j, JIT_R2, JIT_R2, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R2);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0, 0) == 0);
 
diff --git a/libguile/lightening/tests/truncr_d_i.c b/libguile/lightening/tests/truncr_d_i.c
index 12aaa917d..b21280f77 100644
--- a/libguile/lightening/tests/truncr_d_i.c
+++ b/libguile/lightening/tests/truncr_d_i.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_truncr_d_i(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   int (*f)(double) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/truncr_d_l.c b/libguile/lightening/tests/truncr_d_l.c
index 1f5dc995e..189617afb 100644
--- a/libguile/lightening/tests/truncr_d_l.c
+++ b/libguile/lightening/tests/truncr_d_l.c
@@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_truncr_d_l(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   int64_t (*f)(double) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/truncr_f_i.c b/libguile/lightening/tests/truncr_f_i.c
index 077d7bec8..3dbf63050 100644
--- a/libguile/lightening/tests/truncr_f_i.c
+++ b/libguile/lightening/tests/truncr_f_i.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_truncr_f_i(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   int (*f)(float) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/truncr_f_l.c b/libguile/lightening/tests/truncr_f_l.c
index c5a86f89b..7369ae3ad 100644
--- a/libguile/lightening/tests/truncr_f_l.c
+++ b/libguile/lightening/tests/truncr_f_l.c
@@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_truncr_f_l(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   int64_t (*f)(float) = jit_end(j, NULL);
diff --git a/libguile/lightening/tests/xori.c b/libguile/lightening/tests/xori.c
index 5884025d6..4bb2ad1d8 100644
--- a/libguile/lightening/tests/xori.c
+++ b/libguile/lightening/tests/xori.c
@@ -4,15 +4,17 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_xori(j, JIT_R0, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff) == 0x7ffffffe);
   ASSERT(f(0x80000000) == 0x80000001);
diff --git a/libguile/lightening/tests/xorr.c b/libguile/lightening/tests/xorr.c
index c24946638..dd5a3905c 100644
--- a/libguile/lightening/tests/xorr.c
+++ b/libguile/lightening/tests/xorr.c
@@ -4,16 +4,18 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
-                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_xorr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
   void* ret = jit_end(j, &size);
 
-  intmax_t (*f)(intmax_t, intmax_t) = ret;
+  jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
 
   ASSERT(f(0x7fffffff, 1) == 0x7ffffffe);
   ASSERT(f(1, 0x7fffffff) == 0x7ffffffe);