Merge from upstream lightening

184 files changed, 661 insertions, 1508 deletions

diff --git a/libguile/lightening/lightening.h b/libguile/lightening/lightening.h
index ba56513f6..20a14412b 100644
--- a/libguile/lightening/lightening.h
+++ b/libguile/lightening/lightening.h
@@ -123,33 +123,36 @@ jit_same_fprs (jit_fpr_t a, jit_fpr_t b)
 }
 
 typedef struct jit_state	jit_state_t;
-enum jit_arg_loc
+
+enum jit_operand_abi
 {
-  JIT_ARG_LOC_IMM,
-  JIT_ARG_LOC_GPR,
-  JIT_ARG_LOC_FPR,
-  JIT_ARG_LOC_MEM
+  JIT_OPERAND_ABI_UINT8,
+  JIT_OPERAND_ABI_INT8,
+  JIT_OPERAND_ABI_UINT16,
+  JIT_OPERAND_ABI_INT16,
+  JIT_OPERAND_ABI_UINT32,
+  JIT_OPERAND_ABI_INT32,
+  JIT_OPERAND_ABI_UINT64,
+  JIT_OPERAND_ABI_INT64,
+  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)
 };
 
-typedef enum jit_arg_abi
+enum jit_operand_kind
 {
-  JIT_ARG_ABI_UINT8,
-  JIT_ARG_ABI_INT8,
-  JIT_ARG_ABI_UINT16,
-  JIT_ARG_ABI_INT16,
-  JIT_ARG_ABI_UINT32,
-  JIT_ARG_ABI_INT32,
-  JIT_ARG_ABI_UINT64,
-  JIT_ARG_ABI_INT64,
-  JIT_ARG_ABI_POINTER,
-  JIT_ARG_ABI_FLOAT,
-  JIT_ARG_ABI_DOUBLE,
-  JIT_ARG_ABI_INTMAX = CHOOSE_32_64(JIT_ARG_ABI_INT32, JIT_ARG_ABI_INT64)
-} jit_arg_abi_t;
-
-typedef struct jit_arg
+  JIT_OPERAND_KIND_IMM,
+  JIT_OPERAND_KIND_GPR,
+  JIT_OPERAND_KIND_FPR,
+  JIT_OPERAND_KIND_MEM
+};
+
+typedef struct jit_operand
 {
-  enum jit_arg_loc kind;
+  enum jit_operand_abi abi;
+  enum jit_operand_kind kind;
   union
   {
     intptr_t imm;
@@ -157,7 +160,31 @@ typedef struct jit_arg
     jit_fpr_t fpr;
     struct { jit_gpr_t base; ptrdiff_t offset; } mem;
   } loc;
-} jit_arg_t;
+} jit_operand_t;
+
+static inline jit_operand_t
+jit_operand_imm (enum jit_operand_abi abi, intptr_t imm)
+{
+  return (jit_operand_t){ abi, JIT_OPERAND_KIND_IMM, { .imm = imm } };
+}
+
+static inline jit_operand_t
+jit_operand_gpr (enum jit_operand_abi abi, jit_gpr_t gpr)
+{
+  return (jit_operand_t){ abi, JIT_OPERAND_KIND_GPR, { .gpr = gpr } };
+}
+
+static inline jit_operand_t
+jit_operand_fpr (enum jit_operand_abi abi, jit_fpr_t fpr)
+{
+  return (jit_operand_t){ abi, JIT_OPERAND_KIND_FPR, { .fpr = fpr } };
+}
+
+static inline jit_operand_t
+jit_operand_mem (enum jit_operand_abi abi, jit_gpr_t base, ptrdiff_t offset)
+{
+  return (jit_operand_t){ abi, JIT_OPERAND_KIND_MEM, { .mem = { base, offset } } };
+}
 
 typedef union jit_anyreg
 {
@@ -185,19 +212,93 @@ JIT_API void jit_patch_there(jit_state_t*, jit_reloc_t, jit_pointer_t);
 JIT_API jit_bool_t jit_gpr_is_callee_save (jit_state_t*, jit_gpr_t);
 JIT_API jit_bool_t jit_fpr_is_callee_save (jit_state_t*, jit_fpr_t);
 
-/* Note that all functions that take jit_arg_t args[] use the args as scratch
-   space while shuffling values into position.  */
+/* 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,
-                       size_t argc, const jit_arg_abi_t abi[],
-                       jit_arg_t args[]);
+                       size_t argc, jit_operand_t args[]);
 JIT_API void jit_callr(jit_state_t *, jit_gpr_t f,
-                       size_t argc, const jit_arg_abi_t abi[],
-                       jit_arg_t args[]);
-JIT_API void jit_receive(jit_state_t*, size_t argc,
-                         const jit_arg_abi_t abi[], jit_arg_t args[]);
-JIT_API void jit_load_args(jit_state_t *_jit, size_t argc,
-                           const jit_arg_abi_t abi[], jit_arg_t args[],
-                           const jit_anyreg_t regs[]);
+                       size_t argc, jit_operand_t args[]);
+JIT_API void jit_locate_args(jit_state_t*, size_t argc, jit_operand_t args[]);
+JIT_API void jit_load_args(jit_state_t*, size_t argc, jit_operand_t dst[]);
+
+static inline void
+jit_calli_0(jit_state_t *_jit, jit_pointer_t f)
+{
+  return jit_calli(_jit, f, 0, NULL);
+}
+
+static inline void
+jit_calli_1(jit_state_t *_jit, jit_pointer_t f, jit_operand_t arg)
+{
+  jit_operand_t args[] = { arg };
+  return jit_calli(_jit, f, 1, args);
+}
+
+static inline void
+jit_calli_2(jit_state_t *_jit, jit_pointer_t f, jit_operand_t a,
+            jit_operand_t b)
+{
+  jit_operand_t args[] = { a, b };
+  return jit_calli(_jit, f, 2, args);
+}
+
+static inline void
+jit_calli_3(jit_state_t *_jit, jit_pointer_t f, jit_operand_t a,
+            jit_operand_t b, jit_operand_t c)
+{
+  jit_operand_t args[] = { a, b, c };
+  return jit_calli(_jit, f, 3, args);
+}
+
+static inline void
+jit_callr_0(jit_state_t *_jit, jit_gpr_t f)
+{
+  return jit_callr(_jit, f, 0, NULL);
+}
+
+static inline void
+jit_callr_1(jit_state_t *_jit, jit_gpr_t f, jit_operand_t arg)
+{
+  jit_operand_t args[] = { arg };
+  return jit_callr(_jit, f, 1, args);
+}
+
+static inline void
+jit_callr_2(jit_state_t *_jit, jit_gpr_t f, jit_operand_t a, jit_operand_t b)
+{
+  jit_operand_t args[] = { a, b };
+  return jit_callr(_jit, f, 2, args);
+}
+
+static inline void
+jit_callr_3(jit_state_t *_jit, jit_gpr_t f, jit_operand_t a, jit_operand_t b,
+            jit_operand_t c)
+{
+  jit_operand_t args[] = { a, b, c };
+  return jit_callr(_jit, f, 3, args);
+}
+
+static inline void
+jit_load_args_1(jit_state_t *_jit, jit_operand_t a)
+{
+  jit_operand_t args[] = { a };
+  return jit_load_args(_jit, 1, args);
+}
+
+static inline void
+jit_load_args_2(jit_state_t *_jit, jit_operand_t a, jit_operand_t b)
+{
+  jit_operand_t args[] = { a, b };
+  return jit_load_args(_jit, 2, args);
+}
+
+static inline void
+jit_load_args_3(jit_state_t *_jit, jit_operand_t a, jit_operand_t b,
+                jit_operand_t c)
+{
+  jit_operand_t args[] = { a, b, c };
+  return jit_load_args(_jit, 3, args);
+}
 
 #define JIT_PROTO_0(stem, ret) \
   ret jit_##stem (jit_state_t* _jit)
diff --git a/libguile/lightening/lightening/lightening.c b/libguile/lightening/lightening/lightening.c
index 14c8426cb..d3494fd14 100644
--- a/libguile/lightening/lightening/lightening.c
+++ b/libguile/lightening/lightening/lightening.c
@@ -192,7 +192,10 @@ jit_new_state(void* (*alloc_fn)(size_t), void (*free_fn)(void*))
   _jit->alloc = alloc_fn;
   _jit->free = free_fn;
 
-  if (!jit_init (_jit));
+  if (!jit_init (_jit)) {
+    free_fn (_jit);
+    return NULL;
+  }
 
   return _jit;
 }
diff --git a/libguile/lightening/lightening/x86.c b/libguile/lightening/lightening/x86.c
index 0ec8c2f84..b8d1150d9 100644
--- a/libguile/lightening/lightening/x86.c
+++ b/libguile/lightening/lightening/x86.c
@@ -348,22 +348,22 @@ jit_epilog(jit_state_t *_jit)
 }
 
 static jit_bool_t
-is_fpr_arg(jit_arg_abi_t arg)
+is_fpr_arg(enum jit_operand_abi arg)
 {
   switch (arg)
     {
-    case JIT_ARG_ABI_UINT8:
-    case JIT_ARG_ABI_INT8:
-    case JIT_ARG_ABI_UINT16:
-    case JIT_ARG_ABI_INT16:
-    case JIT_ARG_ABI_UINT32:
-    case JIT_ARG_ABI_INT32:
-    case JIT_ARG_ABI_UINT64:
-    case JIT_ARG_ABI_INT64:
-    case JIT_ARG_ABI_POINTER:
+    case JIT_OPERAND_ABI_UINT8:
+    case JIT_OPERAND_ABI_INT8:
+    case JIT_OPERAND_ABI_UINT16:
+    case JIT_OPERAND_ABI_INT16:
+    case JIT_OPERAND_ABI_UINT32:
+    case JIT_OPERAND_ABI_INT32:
+    case JIT_OPERAND_ABI_UINT64:
+    case JIT_OPERAND_ABI_INT64:
+    case JIT_OPERAND_ABI_POINTER:
       return 0;
-    case JIT_ARG_ABI_FLOAT:
-    case JIT_ARG_ABI_DOUBLE:
+    case JIT_OPERAND_ABI_FLOAT:
+    case JIT_OPERAND_ABI_DOUBLE:
       return 1;
     default:
       abort();
@@ -371,7 +371,7 @@ is_fpr_arg(jit_arg_abi_t arg)
 }
 
 static jit_bool_t
-is_gpr_arg(jit_arg_abi_t arg)
+is_gpr_arg(enum jit_operand_abi arg)
 {
   return !is_fpr_arg(arg);
 }
@@ -401,7 +401,7 @@ static const int abi_fpr_arg_count = sizeof(abi_fpr_args) / sizeof(abi_fpr_args[
 
 struct abi_arg_iterator
 {
-  const jit_arg_abi_t *abi;
+  const jit_operand_t *args;
   size_t argc;
 
   size_t arg_idx;
@@ -411,26 +411,26 @@ struct abi_arg_iterator
 };
 
 static size_t
-jit_arg_abi_sizeof(jit_arg_abi_t abi)
+jit_operand_abi_sizeof(enum jit_operand_abi abi)
 {
   switch (abi) {
-  case JIT_ARG_ABI_UINT8:
-  case JIT_ARG_ABI_INT8:
+  case JIT_OPERAND_ABI_UINT8:
+  case JIT_OPERAND_ABI_INT8:
     return 1;
-  case JIT_ARG_ABI_UINT16:
-  case JIT_ARG_ABI_INT16:
+  case JIT_OPERAND_ABI_UINT16:
+  case JIT_OPERAND_ABI_INT16:
     return 2;
-  case JIT_ARG_ABI_UINT32:
-  case JIT_ARG_ABI_INT32:
+  case JIT_OPERAND_ABI_UINT32:
+  case JIT_OPERAND_ABI_INT32:
     return 4;
-  case JIT_ARG_ABI_UINT64:
-  case JIT_ARG_ABI_INT64:
+  case JIT_OPERAND_ABI_UINT64:
+  case JIT_OPERAND_ABI_INT64:
     return 8;
-  case JIT_ARG_ABI_POINTER:
+  case JIT_OPERAND_ABI_POINTER:
     return CHOOSE_32_64(4, 8);
-  case JIT_ARG_ABI_FLOAT:
+  case JIT_OPERAND_ABI_FLOAT:
     return 4;
-  case JIT_ARG_ABI_DOUBLE:
+  case JIT_OPERAND_ABI_DOUBLE:
     return 8;
   default:
     abort();
@@ -447,85 +447,71 @@ round_size_up_to_words(size_t bytes)
 
 static void
 reset_abi_arg_iterator(struct abi_arg_iterator *iter, size_t argc,
-                       const jit_arg_abi_t *abi)
+                       const jit_operand_t *args)
 {
   memset(iter, 0, sizeof *iter);
   iter->argc = argc;
-  iter->abi = abi;
+  iter->args = args;
 }
 
 static void
-next_abi_arg(struct abi_arg_iterator *iter, jit_arg_t *arg)
+next_abi_arg(struct abi_arg_iterator *iter, jit_operand_t *arg)
 {
   ASSERT(iter->arg_idx < iter->argc);
-  jit_arg_abi_t abi = iter->abi[iter->arg_idx];
-  if (is_gpr_arg(abi)) {
-    if (iter->gpr_idx < abi_gpr_arg_count) {
-      arg->kind = JIT_ARG_LOC_GPR;
-      arg->loc.gpr = abi_gpr_args[iter->gpr_idx++];
+  enum jit_operand_abi abi = iter->args[iter->arg_idx].abi;
+  if (is_gpr_arg(abi) && iter->gpr_idx < abi_gpr_arg_count) {
+    *arg = jit_operand_gpr (abi, abi_gpr_args[iter->gpr_idx++]);
 #ifdef __CYGWIN__
-      iter->fpr_idx++;
+    iter->fpr_idx++;
 #endif
-    } else {
-      arg->kind = JIT_ARG_LOC_MEM;
-      arg->loc.mem.base = JIT_GPR(_RSP);
-      arg->loc.mem.offset = iter->stack_size;
-      size_t bytes = jit_arg_abi_sizeof (abi);
-      iter->stack_size += round_size_up_to_words (bytes);
-    }
-  } else {
-    ASSERT(is_fpr_arg(abi));
-    if (iter->fpr_idx < abi_fpr_arg_count) {
-      arg->kind = JIT_ARG_LOC_FPR;
-      arg->loc.fpr = abi_fpr_args[iter->fpr_idx++];
+  } else if (is_fpr_arg(abi) && iter->fpr_idx < abi_fpr_arg_count) {
+    *arg = jit_operand_fpr (abi, abi_fpr_args[iter->fpr_idx++]);
 #ifdef __CYGWIN__
-      iter->gpr_idx++;
+    iter->gpr_idx++;
 #endif
-    } else {
-      arg->kind = JIT_ARG_LOC_MEM;
-      arg->loc.mem.base = JIT_GPR(_RSP);
-      arg->loc.mem.offset = iter->stack_size;
-      size_t bytes = jit_arg_abi_sizeof (abi);
-      iter->stack_size += round_size_up_to_words (bytes);
-    }
+  } else {
+    *arg = jit_operand_mem (abi, JIT_GPR(_RSP), iter->stack_size);
+    size_t bytes = jit_operand_abi_sizeof (abi);
+    iter->stack_size += round_size_up_to_words (bytes);
   }
   iter->arg_idx++;
 }
 
 static void
-abi_imm_to_gpr(jit_state_t *_jit, jit_arg_abi_t abi, jit_gpr_t dst, intptr_t imm)
+abi_imm_to_gpr(jit_state_t *_jit, enum jit_operand_abi abi, jit_gpr_t dst,
+               intptr_t imm)
 {
   switch (abi) {
-  case JIT_ARG_ABI_UINT8:
+  case JIT_OPERAND_ABI_UINT8:
     ASSERT(0 <= imm);
     ASSERT(imm <= UINT8_MAX);
     break;
-  case JIT_ARG_ABI_INT8:
+  case JIT_OPERAND_ABI_INT8:
     ASSERT(INT8_MIN <= imm);
     ASSERT(imm <= INT8_MAX);
     break;
-  case JIT_ARG_ABI_UINT16:
+  case JIT_OPERAND_ABI_UINT16:
     ASSERT(0 <= imm);
     ASSERT(imm <= UINT16_MAX);
     break;
-  case JIT_ARG_ABI_INT16:
+  case JIT_OPERAND_ABI_INT16:
     ASSERT(INT16_MIN <= imm);
     ASSERT(imm <= INT16_MAX);
     break;
-  case JIT_ARG_ABI_UINT32:
+  case JIT_OPERAND_ABI_UINT32:
     ASSERT(0 <= imm);
     ASSERT(imm <= UINT32_MAX);
     break;
-  case JIT_ARG_ABI_INT32:
+  case JIT_OPERAND_ABI_INT32:
     ASSERT(INT32_MIN <= imm);
     ASSERT(imm <= INT32_MAX);
     break;
 #if __WORDSIZE > 32
-  case JIT_ARG_ABI_UINT64:
-  case JIT_ARG_ABI_INT64:
+  case JIT_OPERAND_ABI_UINT64:
+  case JIT_OPERAND_ABI_INT64:
     break;
 #endif
-  case JIT_ARG_ABI_POINTER:
+  case JIT_OPERAND_ABI_POINTER:
     break;
   default:
     abort();
@@ -534,29 +520,29 @@ abi_imm_to_gpr(jit_state_t *_jit, jit_arg_abi_t abi, jit_gpr_t dst, intptr_t imm
 }
 
 static void
-abi_gpr_to_mem(jit_state_t *_jit, jit_arg_abi_t abi,
+abi_gpr_to_mem(jit_state_t *_jit, enum jit_operand_abi abi,
                jit_gpr_t src, jit_gpr_t base, ptrdiff_t offset)
 {
   switch (abi) {
-  case JIT_ARG_ABI_UINT8:
-  case JIT_ARG_ABI_INT8:
+  case JIT_OPERAND_ABI_UINT8:
+  case JIT_OPERAND_ABI_INT8:
     jit_stxi_c(_jit, offset, base, src);
     break;
-  case JIT_ARG_ABI_UINT16:
-  case JIT_ARG_ABI_INT16:
+  case JIT_OPERAND_ABI_UINT16:
+  case JIT_OPERAND_ABI_INT16:
     jit_stxi_s(_jit, offset, base, src);
     break;
-  case JIT_ARG_ABI_UINT32:
-  case JIT_ARG_ABI_INT32:
+  case JIT_OPERAND_ABI_UINT32:
+  case JIT_OPERAND_ABI_INT32:
 #if __WORDSIZE == 32
-  case JIT_ARG_ABI_POINTER:
+  case JIT_OPERAND_ABI_POINTER:
 #endif
     jit_stxi_i(_jit, offset, base, src);
     break;
 #if __WORDSIZE == 64
-  case JIT_ARG_ABI_UINT64:
-  case JIT_ARG_ABI_INT64:
-  case JIT_ARG_ABI_POINTER:
+  case JIT_OPERAND_ABI_UINT64:
+  case JIT_OPERAND_ABI_INT64:
+  case JIT_OPERAND_ABI_POINTER:
     jit_stxi_l(_jit, offset, base, src);
     break;
 #endif
@@ -566,14 +552,14 @@ abi_gpr_to_mem(jit_state_t *_jit, jit_arg_abi_t abi,
 }
 
 static void
-abi_fpr_to_mem(jit_state_t *_jit, jit_arg_abi_t abi,
+abi_fpr_to_mem(jit_state_t *_jit, enum jit_operand_abi abi,
                jit_fpr_t src, jit_gpr_t base, ptrdiff_t offset)
 {
   switch (abi) {
-  case JIT_ARG_ABI_FLOAT:
+  case JIT_OPERAND_ABI_FLOAT:
     jit_stxi_f(_jit, offset, base, src);
     break;
-  case JIT_ARG_ABI_DOUBLE:
+  case JIT_OPERAND_ABI_DOUBLE:
     jit_stxi_d(_jit, offset, base, src);
     break;
   default:
@@ -582,35 +568,35 @@ abi_fpr_to_mem(jit_state_t *_jit, jit_arg_abi_t abi,
 }
 
 static void
-abi_mem_to_gpr(jit_state_t *_jit, jit_arg_abi_t abi,
+abi_mem_to_gpr(jit_state_t *_jit, enum jit_operand_abi abi,
                jit_gpr_t dst, jit_gpr_t base, ptrdiff_t offset)
 {
   switch (abi) {
-  case JIT_ARG_ABI_UINT8:
+  case JIT_OPERAND_ABI_UINT8:
     jit_ldxi_uc(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_INT8:
+  case JIT_OPERAND_ABI_INT8:
     jit_ldxi_c(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_UINT16:
+  case JIT_OPERAND_ABI_UINT16:
     jit_ldxi_us(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_INT16:
+  case JIT_OPERAND_ABI_INT16:
     jit_ldxi_s(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_UINT32:
+  case JIT_OPERAND_ABI_UINT32:
     jit_ldxi_ui(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_INT32:
+  case JIT_OPERAND_ABI_INT32:
     jit_ldxi_i(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_UINT64:
+  case JIT_OPERAND_ABI_UINT64:
     jit_ldxi_l(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_INT64:
+  case JIT_OPERAND_ABI_INT64:
     jit_ldxi_l(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_POINTER:
+  case JIT_OPERAND_ABI_POINTER:
     jit_ldxi_l(_jit, dst, base, offset);
     break;
   default:
@@ -619,14 +605,14 @@ abi_mem_to_gpr(jit_state_t *_jit, jit_arg_abi_t abi,
 }
 
 static void
-abi_mem_to_fpr(jit_state_t *_jit, jit_arg_abi_t abi,
+abi_mem_to_fpr(jit_state_t *_jit, enum jit_operand_abi abi,
                jit_fpr_t dst, jit_gpr_t base, ptrdiff_t offset)
 {
   switch (abi) {
-  case JIT_ARG_ABI_FLOAT:
+  case JIT_OPERAND_ABI_FLOAT:
     jit_ldxi_f(_jit, dst, base, offset);
     break;
-  case JIT_ARG_ABI_DOUBLE:
+  case JIT_OPERAND_ABI_DOUBLE:
     jit_ldxi_d(_jit, dst, base, offset);
     break;
   default:
@@ -635,37 +621,39 @@ abi_mem_to_fpr(jit_state_t *_jit, jit_arg_abi_t abi,
 }
 
 static void
-store_mem_abi_arg(jit_state_t *_jit, jit_arg_abi_t abi,
-                  jit_arg_t *arg, jit_gpr_t base, ptrdiff_t offset)
+store_mem_abi_arg(jit_state_t *_jit, jit_operand_t *arg, jit_gpr_t base,
+                  ptrdiff_t offset)
 {
   switch (arg->kind) {
-  case JIT_ARG_LOC_GPR:
-    abi_gpr_to_mem(_jit, abi, arg->loc.gpr, base, offset);
+  case JIT_OPERAND_KIND_GPR:
+    abi_gpr_to_mem(_jit, arg->abi, arg->loc.gpr, base, offset);
     break;
 
-  case JIT_ARG_LOC_FPR:
-    abi_fpr_to_mem(_jit, abi, arg->loc.fpr, base, offset);
+  case JIT_OPERAND_KIND_FPR:
+    abi_fpr_to_mem(_jit, arg->abi, arg->loc.fpr, base, offset);
     break;
 
-  case JIT_ARG_LOC_MEM:
-    if (is_gpr_arg(abi)) {
+  case JIT_OPERAND_KIND_MEM:
+    if (is_gpr_arg(arg->abi)) {
       jit_gpr_t tmp = get_temp_gpr(_jit);
-      abi_mem_to_gpr(_jit, abi, tmp, arg->loc.mem.base, arg->loc.mem.offset);
-      abi_gpr_to_mem(_jit, abi, tmp, base, offset);
+      abi_mem_to_gpr(_jit, arg->abi, tmp, arg->loc.mem.base,
+                     arg->loc.mem.offset);
+      abi_gpr_to_mem(_jit, arg->abi, tmp, base, offset);
       unget_temp_gpr(_jit);
     } else {
       jit_fpr_t tmp = get_temp_xpr(_jit);
-      abi_mem_to_fpr(_jit, abi, tmp, arg->loc.mem.base, arg->loc.mem.offset);
-      abi_fpr_to_mem(_jit, abi, tmp, base, offset);
+      abi_mem_to_fpr(_jit, arg->abi, tmp, arg->loc.mem.base,
+                     arg->loc.mem.offset);
+      abi_fpr_to_mem(_jit, arg->abi, tmp, base, offset);
       unget_temp_xpr(_jit);
     }
     break;
 
-  case JIT_ARG_LOC_IMM: {
-    if (is_gpr_arg(abi)) {
+  case JIT_OPERAND_KIND_IMM: {
+    if (is_gpr_arg(arg->abi)) {
       jit_gpr_t tmp = get_temp_gpr(_jit);
-      abi_imm_to_gpr(_jit, abi, tmp, arg->loc.imm);
-      abi_gpr_to_mem(_jit, abi, tmp, base, offset);
+      abi_imm_to_gpr(_jit, arg->abi, tmp, arg->loc.imm);
+      abi_gpr_to_mem(_jit, arg->abi, tmp, base, offset);
       unget_temp_gpr(_jit);
     } else {
       /* Floating-point immediates not supported yet.  */
@@ -678,16 +666,16 @@ store_mem_abi_arg(jit_state_t *_jit, jit_arg_abi_t abi,
     abort();
   }
 
-  arg->kind = JIT_ARG_LOC_MEM;
+  arg->kind = JIT_OPERAND_KIND_MEM;
   arg->loc.mem.base = base;
   arg->loc.mem.offset = offset;
 }
 
 static void
 shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
-                jit_arg_t *args, size_t idx)
+                jit_operand_t *args, size_t idx)
 {
-  ASSERT(args[idx].kind == JIT_ARG_LOC_GPR);
+  ASSERT(args[idx].kind == JIT_OPERAND_KIND_GPR);
 
   if (rn(args[idx].loc.gpr) == rn(dst))
     return;
@@ -695,7 +683,7 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
   /* Arg in a reg but it's not the right one.  See if this reg
      holds some other arg, and swap if so.  */
   for (size_t j=idx+1; j<argc; j++)
-    if (args[j].kind == JIT_ARG_LOC_GPR && rn(args[j].loc.gpr) == rn(dst))
+    if (args[j].kind == JIT_OPERAND_KIND_GPR && rn(args[j].loc.gpr) == rn(dst))
       {
         xchgr(_jit, rn(args[idx].loc.gpr), rn(dst));
         args[j].loc.gpr = args[idx].loc.gpr;
@@ -703,7 +691,7 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
         /* Could be this register holds a value for more than one argument;
            update subsequent args if any.  */
         for (size_t k=j+1; k<argc; k++)
-          if (args[k].kind == JIT_ARG_LOC_GPR && rn(args[k].loc.gpr) == rn(dst))
+          if (args[k].kind == JIT_OPERAND_KIND_GPR && rn(args[k].loc.gpr) == rn(dst))
             args[k].loc.gpr = args[j].loc.gpr;
         return;
       }
@@ -716,9 +704,9 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
 
 static void
 shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
-                jit_arg_t *args, size_t idx)
+                jit_operand_t *args, size_t idx)
 {
-  ASSERT(args[idx].kind == JIT_ARG_LOC_FPR);
+  ASSERT(args[idx].kind == JIT_OPERAND_KIND_FPR);
 
   if (rn(args[idx].loc.fpr) == rn(dst))
     return;
@@ -726,7 +714,7 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
   /* Arg in a reg but it's not the right one.  See if this reg
      holds some other arg, and swap if so.  */
   for (size_t j=idx+1; j<argc; j++)
-    if (args[j].kind == JIT_ARG_LOC_FPR && rn(args[j].loc.fpr) == rn(dst))
+    if (args[j].kind == JIT_OPERAND_KIND_FPR && rn(args[j].loc.fpr) == rn(dst))
       {
         jit_fpr_t tmp = get_temp_xpr(_jit);
         jit_movr_d (_jit, tmp, args[idx].loc.fpr);
@@ -738,7 +726,7 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
         /* Could be this register holds a value for more than one argument;
            update subsequent args if any.  */
         for (size_t k=j+1; k<argc; k++)
-          if (args[k].kind == JIT_ARG_LOC_FPR && rn(args[k].loc.fpr) == rn(dst))
+          if (args[k].kind == JIT_OPERAND_KIND_FPR && rn(args[k].loc.fpr) == rn(dst))
             args[k].loc.fpr = args[j].loc.fpr;
         return;
       }
@@ -750,14 +738,13 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
 }
 
 static void
-prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
-             jit_arg_t args[])
+prepare_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
 {
-  jit_arg_t scratch;
+  jit_operand_t scratch;
   struct abi_arg_iterator iter;
   
   // Compute stack arg size.
-  reset_abi_arg_iterator(&iter, argc, abi);
+  reset_abi_arg_iterator(&iter, argc, args);
   for (size_t i = 0; i < argc; i++)
     next_abi_arg(&iter, &scratch);
 
@@ -767,12 +754,12 @@ prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
     {
       size_t stack_size = iter.stack_size;
       subi(_jit, _RSP_REGNO, _RSP_REGNO, stack_size);
-      reset_abi_arg_iterator(&iter, argc, abi);
+      reset_abi_arg_iterator(&iter, argc, args);
       for (size_t i = 0; i < argc; i++) {
         next_abi_arg(&iter, &scratch);
-        if (scratch.kind == JIT_ARG_LOC_MEM)
-          store_mem_abi_arg(_jit, abi[i], &args[i],
-                            scratch.loc.mem.base, scratch.loc.mem.offset);
+        if (scratch.kind == JIT_OPERAND_KIND_MEM)
+          store_mem_abi_arg(_jit, &args[i], scratch.loc.mem.base,
+                            scratch.loc.mem.offset);
       }
     }
 
@@ -781,18 +768,18 @@ prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
   // register for the correponding ABI argument.  Note that there may be ABI
   // register arguments whose values are still in memory or as immediates; we
   // will load them later.
-  reset_abi_arg_iterator(&iter, argc, abi);
+  reset_abi_arg_iterator(&iter, argc, args);
   for (size_t i = 0; i < argc; i++)
     {
       next_abi_arg(&iter, &scratch);
       switch (scratch.kind) {
-      case JIT_ARG_LOC_GPR:
-        if (args[i].kind == JIT_ARG_LOC_GPR)
+      case JIT_OPERAND_KIND_GPR:
+        if (args[i].kind == JIT_OPERAND_KIND_GPR)
           shuffle_gpr_arg(_jit, scratch.loc.gpr, argc, args, i);
         break;
         
-      case JIT_ARG_LOC_FPR:
-        if (args[i].kind == JIT_ARG_LOC_FPR)
+      case JIT_OPERAND_KIND_FPR:
+        if (args[i].kind == JIT_OPERAND_KIND_FPR)
           shuffle_fpr_arg(_jit, scratch.loc.fpr, argc, args, i);
         break;
 
@@ -803,31 +790,31 @@ prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
   
   // The only thing that's left is ABI register arguments whose values are still
   // in memory or immediates; load them now.
-  reset_abi_arg_iterator(&iter, argc, abi);
+  reset_abi_arg_iterator(&iter, argc, args);
   for (size_t i = 0; i < argc; i++)
     {
       next_abi_arg(&iter, &scratch);
       switch (scratch.kind) {
-      case JIT_ARG_LOC_GPR:
-        if (args[i].kind == JIT_ARG_LOC_MEM) {
-          abi_mem_to_gpr(_jit, abi[i], scratch.loc.gpr, args[i].loc.mem.base,
-                         args[i].loc.mem.offset);
-          args[i].kind = JIT_ARG_LOC_GPR;
+      case JIT_OPERAND_KIND_GPR:
+        if (args[i].kind == JIT_OPERAND_KIND_MEM) {
+          abi_mem_to_gpr(_jit, args[i].abi, scratch.loc.gpr,
+                         args[i].loc.mem.base, args[i].loc.mem.offset);
+          args[i].kind = JIT_OPERAND_KIND_GPR;
           args[i].loc.gpr = scratch.loc.gpr;
-        } else if (args[i].kind == JIT_ARG_LOC_IMM) {
-          abi_imm_to_gpr(_jit, abi[i], scratch.loc.gpr, args[i].loc.imm);
-          args[i].kind = JIT_ARG_LOC_GPR;
+        } else if (args[i].kind == JIT_OPERAND_KIND_IMM) {
+          abi_imm_to_gpr(_jit, args[i].abi, scratch.loc.gpr, args[i].loc.imm);
+          args[i].kind = JIT_OPERAND_KIND_GPR;
           args[i].loc.gpr = scratch.loc.gpr;
         }
         break;
         
-      case JIT_ARG_LOC_FPR:
-        if (args[i].kind == JIT_ARG_LOC_MEM) {
-          abi_mem_to_fpr(_jit, abi[i], scratch.loc.fpr, args[i].loc.mem.base,
-                         args[i].loc.mem.offset);
-          args[i].kind = JIT_ARG_LOC_FPR;
+      case JIT_OPERAND_KIND_FPR:
+        if (args[i].kind == JIT_OPERAND_KIND_MEM) {
+          abi_mem_to_fpr(_jit, args[i].abi, scratch.loc.fpr,
+                         args[i].loc.mem.base, args[i].loc.mem.offset);
+          args[i].kind = JIT_OPERAND_KIND_FPR;
           args[i].loc.fpr = scratch.loc.fpr;
-        } else if (args[i].kind == JIT_ARG_LOC_IMM) {
+        } else if (args[i].kind == JIT_OPERAND_KIND_IMM) {
           /* Currently unsupported.  */
           abort ();
         }
@@ -841,13 +828,13 @@ prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
 
 static void
 cleanup_stack_after_call(jit_state_t *_jit, size_t argc,
-                         const jit_arg_abi_t abi[])
+                         const jit_operand_t args[])
 {
-  jit_arg_t scratch;
+  jit_operand_t scratch;
   struct abi_arg_iterator iter;
 
   // Compute stack arg size.
-  reset_abi_arg_iterator(&iter, argc, abi);
+  reset_abi_arg_iterator(&iter, argc, args);
   for (size_t i = 0; i < argc; i++)
     next_abi_arg(&iter, &scratch);
 
@@ -856,71 +843,105 @@ cleanup_stack_after_call(jit_state_t *_jit, size_t argc,
 }
 
 void
-jit_calli(jit_state_t *_jit, jit_pointer_t f,
-          size_t argc, const jit_arg_abi_t abi[], jit_arg_t args[])
+jit_calli(jit_state_t *_jit, jit_pointer_t f, size_t argc, jit_operand_t args[])
 {
-  prepare_args(_jit, argc, abi, args);
+  prepare_args(_jit, argc, args);
 
   calli(_jit, (jit_word_t)f);
 
-  cleanup_stack_after_call(_jit, argc, abi);
+  cleanup_stack_after_call(_jit, argc, args);
 }
 
 void
-jit_callr(jit_state_t *_jit, jit_gpr_t f,
-          size_t argc, const jit_arg_abi_t abi[], jit_arg_t args[])
+jit_callr(jit_state_t *_jit, jit_gpr_t f, size_t argc, jit_operand_t args[])
 {
-  prepare_args(_jit, argc, abi, args);
+  prepare_args(_jit, argc, args);
 
   callr(_jit, rn(f));
 
-  cleanup_stack_after_call(_jit, argc, abi);
+  cleanup_stack_after_call(_jit, argc, args);
 }
 
 void
-jit_receive(jit_state_t *_jit,
-            size_t argc, const jit_arg_abi_t abi[], jit_arg_t args[])
+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, abi);
+  reset_abi_arg_iterator(&iter, argc, args);
   for (size_t i = 0; i < argc; i++)
     next_abi_arg(&iter, &args[i]);
 }
 
+/* Precondition: args are distinct locations.  No JIT_OPERAND_KIND_MEM
+   element of args aliases stack-spilled args.  */
 void
-jit_load_args(jit_state_t *_jit, size_t argc,
-              const jit_arg_abi_t abi[], jit_arg_t args[],
-              const jit_anyreg_t regs[])
+jit_load_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
 {
+  jit_operand_t scratch[argc];
+
+  memcpy(scratch, args, sizeof(scratch[0]) * argc);
+
+  jit_locate_args(_jit, argc, scratch);
+
   /* First shuffle any arguments that are already in registers into
      position.  */
   for (size_t i = 0; i < argc; i++) {
-    switch (args[i].kind) {
-    case JIT_ARG_LOC_IMM:
+    switch (scratch[i].kind) {
+    case JIT_OPERAND_KIND_IMM:
       abort();
-    case JIT_ARG_LOC_GPR:
-      shuffle_gpr_arg(_jit, regs[i].gpr, argc, args, i);
+    case JIT_OPERAND_KIND_GPR:
+      switch (args[i].kind) {
+      case JIT_OPERAND_KIND_GPR:
+        shuffle_gpr_arg(_jit, args[i].loc.gpr, argc, scratch, i);
+        break;
+      case JIT_OPERAND_KIND_MEM:
+        store_mem_abi_arg(_jit, &scratch[i], args[i].loc.mem.base,
+                          args[i].loc.mem.offset);
+        break;
+      default:
+        abort();
+      }
       break;
-    case JIT_ARG_LOC_FPR:
-      shuffle_fpr_arg(_jit, regs[i].fpr, argc, args, i);
+    case JIT_OPERAND_KIND_FPR:
+      switch (args[i].kind) {
+      case JIT_OPERAND_KIND_FPR:
+        shuffle_fpr_arg(_jit, args[i].loc.fpr, argc, scratch, i);
+        break;
+      case JIT_OPERAND_KIND_MEM:
+        store_mem_abi_arg(_jit, &scratch[i], args[i].loc.mem.base,
+                          args[i].loc.mem.offset);
+        break;
+      default:
+        abort();
+      }
       break;
-    case JIT_ARG_LOC_MEM:
+    case JIT_OPERAND_KIND_MEM:
       break;
     default:
       abort();
     }
   }
 
-  /* Now load spilled arguments from memory into registers.  */
+  /* Now shuffle spilled arguments from memory into place (memory or
+     registers).  */
   for (size_t i = 0; i < argc; i++) {
-    if (args[i].kind == JIT_ARG_LOC_MEM) {
-      if (is_gpr_arg(abi[i]))
-        abi_mem_to_gpr(_jit, abi[i], regs[i].gpr, args[i].loc.mem.base,
-                       args[i].loc.mem.offset);
-      else
-        abi_mem_to_fpr(_jit, abi[i], regs[i].fpr, args[i].loc.mem.base,
-                       args[i].loc.mem.offset);
+    if (args[i].kind == JIT_OPERAND_KIND_MEM) {
+      switch (args[i].kind)  {
+      case JIT_OPERAND_KIND_GPR:
+        abi_mem_to_gpr(_jit, args[i].kind, args[i].loc.gpr,
+                       scratch[i].loc.mem.base, scratch[i].loc.mem.offset);
+        break;
+      case JIT_OPERAND_KIND_FPR:
+        abi_mem_to_fpr(_jit, args[i].kind, args[i].loc.fpr,
+                       scratch[i].loc.mem.base, scratch[i].loc.mem.offset);
+        break;
+      case JIT_OPERAND_KIND_MEM:
+        store_mem_abi_arg(_jit, &scratch[i], args[i].loc.mem.base,
+                          args[i].loc.mem.offset);
+        break;
+      default:
+        abort();
+      }
     }
   }
 }
diff --git a/libguile/lightening/tests/Makefile b/libguile/lightening/tests/Makefile
index e94c6fdee..f068308c7 100644
--- a/libguile/lightening/tests/Makefile
+++ b/libguile/lightening/tests/Makefile
@@ -1,24 +1,34 @@
 TESTS=$(sort $(basename $(wildcard *.c)))
+TARGETS=native
 
 CC = gcc
+CC_IA32 = gcc -m32
 CFLAGS = -Wall -O0 -g
 
-all: $(addprefix test-,$(TESTS))
+all: $(foreach TARGET,$(TARGETS),$(addprefix test-$(TARGET)-,$(TESTS)))
 
-check: all
+check: $(addprefix test-$(TARGET),$(TARGETS))
+
+test-%: $(addprefix test-%-,$(TESTS))
 	@echo "Running unit tests..."
-	@set -e; for test in $(TESTS); do \
+	@set -e; for test in $?; do \
 	  echo "Testing: $$test"; \
-	  ./test-$$test; \
+	  ./$$test; \
 	done
 	@echo "Success."
 
-lightening.o: ../lightening.h ../lightening/*.c
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I.. -o lightening.o -c ../lightening/lightening.c
+.PHONY: test check
+
+lightening-%.o: ../lightening.h ../lightening/*.c
+	$(CC) $(CFLAGS) $(CPPFLAGS) -I.. -o $@ -c ../lightening/lightening.c
+
+test-native-%: %.c lightening-native.o test.h
+	$(CC) $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening-native.o $<
 
-test-%: %.c lightening.o test.h
-	$(CC) $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening.o $<
+test-ia32-%: CC = $(CC_IA32)
+test-ia32-%: %.c lightening-ia32.o test.h
+	$(CC) -m32 $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening-ia32.o $<
 
 clean:
-	rm -f $(addprefix test-,$(TESTS))
-	rm -f lightening.o
+	rm -f $(foreach TARGET,$(TARGETS),$(addprefix test-$(TARGET)-,$(TESTS)))
+	rm -f $(foreach TARGET,$(TARGETS),lightening-$(TARGET).o)
diff --git a/libguile/lightening/tests/absr_d.c b/libguile/lightening/tests/absr_d.c
index 5671c4f7b..93b10b673 100644
--- a/libguile/lightening/tests/absr_d.c
+++ b/libguile/lightening/tests/absr_d.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_absr_d(j, JIT_F0, JIT_F0);
   jit_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/absr_f.c b/libguile/lightening/tests/absr_f.c
index e93fb4993..64463bf89 100644
--- a/libguile/lightening/tests/absr_f.c
+++ b/libguile/lightening/tests/absr_f.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_absr_f(j, JIT_F0, JIT_F0);
   jit_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/addi.c b/libguile/lightening/tests/addi.c
index 9b1a82b0c..f0e632c94 100644
--- a/libguile/lightening/tests/addi.c
+++ b/libguile/lightening/tests/addi.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_addi(j, JIT_R0, JIT_R0, 69);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/addr.c b/libguile/lightening/tests/addr.c
index 236fcd18a..8894cc5dc 100644
--- a/libguile/lightening/tests/addr.c
+++ b/libguile/lightening/tests/addr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_addr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/addr_d.c b/libguile/lightening/tests/addr_d.c
index e89663eb0..8c7be6298 100644
--- a/libguile/lightening/tests/addr_d.c
+++ b/libguile/lightening/tests/addr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/addr_f.c b/libguile/lightening/tests/addr_f.c
index ce918fd0f..1ed1f36b4 100644
--- a/libguile/lightening/tests/addr_f.c
+++ b/libguile/lightening/tests/addr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/addx.c b/libguile/lightening/tests/addx.c
index 664c13998..6013e52c1 100644
--- a/libguile/lightening/tests/addx.c
+++ b/libguile/lightening/tests/addx.c
@@ -4,13 +4,9 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_movi(j, JIT_R2, 0);
   jit_addcr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_addxi(j, JIT_R2, JIT_R2, 0);
diff --git a/libguile/lightening/tests/andi.c b/libguile/lightening/tests/andi.c
index 781b7d0e0..a1d3203c9 100644
--- a/libguile/lightening/tests/andi.c
+++ b/libguile/lightening/tests/andi.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_andi(j, JIT_R0, JIT_R0, 1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/andr.c b/libguile/lightening/tests/andr.c
index 4c549e8ef..62cc61e8a 100644
--- a/libguile/lightening/tests/andr.c
+++ b/libguile/lightening/tests/andr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_andr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/beqi.c b/libguile/lightening/tests/beqi.c
index d65d48d7f..994147306 100644
--- a/libguile/lightening/tests/beqi.c
+++ b/libguile/lightening/tests/beqi.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_beqi(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/beqr.c b/libguile/lightening/tests/beqr.c
index 6df434d02..2bdeb24a9 100644
--- a/libguile/lightening/tests/beqr.c
+++ b/libguile/lightening/tests/beqr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_beqr(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/beqr_d.c b/libguile/lightening/tests/beqr_d.c
index 408f0dfb0..628e80ce3 100644
--- a/libguile/lightening/tests/beqr_d.c
+++ b/libguile/lightening/tests/beqr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/beqr_f.c b/libguile/lightening/tests/beqr_f.c
index 2e91105b2..dca60fa98 100644
--- a/libguile/lightening/tests/beqr_f.c
+++ b/libguile/lightening/tests/beqr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bgei.c b/libguile/lightening/tests/bgei.c
index 25fe2ee42..7a847e699 100644
--- a/libguile/lightening/tests/bgei.c
+++ b/libguile/lightening/tests/bgei.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_bgei(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bgei_u.c b/libguile/lightening/tests/bgei_u.c
index f2b5a53ad..6847613c5 100644
--- a/libguile/lightening/tests/bgei_u.c
+++ b/libguile/lightening/tests/bgei_u.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_bgei_u(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bger.c b/libguile/lightening/tests/bger.c
index 0bff98a64..68df65bdf 100644
--- a/libguile/lightening/tests/bger.c
+++ b/libguile/lightening/tests/bger.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bger(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bger_d.c b/libguile/lightening/tests/bger_d.c
index 74786ad9f..ab1190ea7 100644
--- a/libguile/lightening/tests/bger_d.c
+++ b/libguile/lightening/tests/bger_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bger_f.c b/libguile/lightening/tests/bger_f.c
index 03dde27d5..07cf7f075 100644
--- a/libguile/lightening/tests/bger_f.c
+++ b/libguile/lightening/tests/bger_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bger_u.c b/libguile/lightening/tests/bger_u.c
index 890aec995..806953c60 100644
--- a/libguile/lightening/tests/bger_u.c
+++ b/libguile/lightening/tests/bger_u.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bger_u(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bgti.c b/libguile/lightening/tests/bgti.c
index fa1e7aa7d..e6e6c05db 100644
--- a/libguile/lightening/tests/bgti.c
+++ b/libguile/lightening/tests/bgti.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_bgti(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bgti_u.c b/libguile/lightening/tests/bgti_u.c
index 2d01728db..f604fed36 100644
--- a/libguile/lightening/tests/bgti_u.c
+++ b/libguile/lightening/tests/bgti_u.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_bgti_u(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bgtr.c b/libguile/lightening/tests/bgtr.c
index 779b32063..de31bf876 100644
--- a/libguile/lightening/tests/bgtr.c
+++ b/libguile/lightening/tests/bgtr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bgtr(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bgtr_d.c b/libguile/lightening/tests/bgtr_d.c
index f5ea7a254..1cc8dd5eb 100644
--- a/libguile/lightening/tests/bgtr_d.c
+++ b/libguile/lightening/tests/bgtr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bgtr_f.c b/libguile/lightening/tests/bgtr_f.c
index e1aec3a12..37d65f2b8 100644
--- a/libguile/lightening/tests/bgtr_f.c
+++ b/libguile/lightening/tests/bgtr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bgtr_u.c b/libguile/lightening/tests/bgtr_u.c
index cec4d17dc..31202c455 100644
--- a/libguile/lightening/tests/bgtr_u.c
+++ b/libguile/lightening/tests/bgtr_u.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bgtr_u(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/blei.c b/libguile/lightening/tests/blei.c
index 1d0a91eb6..c9317eab8 100644
--- a/libguile/lightening/tests/blei.c
+++ b/libguile/lightening/tests/blei.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_blei(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/blei_u.c b/libguile/lightening/tests/blei_u.c
index fcfde3acb..614ddf0be 100644
--- a/libguile/lightening/tests/blei_u.c
+++ b/libguile/lightening/tests/blei_u.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_blei_u(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bler.c b/libguile/lightening/tests/bler.c
index b4ec03442..ba580b032 100644
--- a/libguile/lightening/tests/bler.c
+++ b/libguile/lightening/tests/bler.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bler(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bler_d.c b/libguile/lightening/tests/bler_d.c
index 8d189a872..f11b92356 100644
--- a/libguile/lightening/tests/bler_d.c
+++ b/libguile/lightening/tests/bler_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bler_f.c b/libguile/lightening/tests/bler_f.c
index 74cc65ceb..9c0a7f710 100644
--- a/libguile/lightening/tests/bler_f.c
+++ b/libguile/lightening/tests/bler_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bler_u.c b/libguile/lightening/tests/bler_u.c
index 006f84b5e..036bb6420 100644
--- a/libguile/lightening/tests/bler_u.c
+++ b/libguile/lightening/tests/bler_u.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bler_u(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bltgtr_d.c b/libguile/lightening/tests/bltgtr_d.c
index 79ef13943..6d433e47b 100644
--- a/libguile/lightening/tests/bltgtr_d.c
+++ b/libguile/lightening/tests/bltgtr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bltgtr_f.c b/libguile/lightening/tests/bltgtr_f.c
index 8cbf83e60..711e51647 100644
--- a/libguile/lightening/tests/bltgtr_f.c
+++ b/libguile/lightening/tests/bltgtr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/blti.c b/libguile/lightening/tests/blti.c
index 8c3cd34ef..a16ac0220 100644
--- a/libguile/lightening/tests/blti.c
+++ b/libguile/lightening/tests/blti.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_blti(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/blti_u.c b/libguile/lightening/tests/blti_u.c
index b7af89d80..1a93f1d1e 100644
--- a/libguile/lightening/tests/blti_u.c
+++ b/libguile/lightening/tests/blti_u.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_blti_u(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bltr.c b/libguile/lightening/tests/bltr.c
index 56b0d68ee..7802fa82e 100644
--- a/libguile/lightening/tests/bltr.c
+++ b/libguile/lightening/tests/bltr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bltr(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bltr_d.c b/libguile/lightening/tests/bltr_d.c
index 9ce78b666..11930eee2 100644
--- a/libguile/lightening/tests/bltr_d.c
+++ b/libguile/lightening/tests/bltr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bltr_f.c b/libguile/lightening/tests/bltr_f.c
index 177a5869a..4bb3ac48a 100644
--- a/libguile/lightening/tests/bltr_f.c
+++ b/libguile/lightening/tests/bltr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bltr_u.c b/libguile/lightening/tests/bltr_u.c
index e87a946ae..c73949f6a 100644
--- a/libguile/lightening/tests/bltr_u.c
+++ b/libguile/lightening/tests/bltr_u.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bltr_u(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bmci.c b/libguile/lightening/tests/bmci.c
index 0ffe41541..8846c9462 100644
--- a/libguile/lightening/tests/bmci.c
+++ b/libguile/lightening/tests/bmci.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_bmci(j, JIT_R0, 1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bmcr.c b/libguile/lightening/tests/bmcr.c
index 03591fc65..ba8b246c0 100644
--- a/libguile/lightening/tests/bmcr.c
+++ b/libguile/lightening/tests/bmcr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bmcr(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bmsi.c b/libguile/lightening/tests/bmsi.c
index 21f986ff3..538575f8b 100644
--- a/libguile/lightening/tests/bmsi.c
+++ b/libguile/lightening/tests/bmsi.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_bmsi(j, JIT_R0, 1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bmsr.c b/libguile/lightening/tests/bmsr.c
index cd5895198..3ac320ff9 100644
--- a/libguile/lightening/tests/bmsr.c
+++ b/libguile/lightening/tests/bmsr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bmsr(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bnei.c b/libguile/lightening/tests/bnei.c
index a34a3ad23..f1ac741c8 100644
--- a/libguile/lightening/tests/bnei.c
+++ b/libguile/lightening/tests/bnei.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_reloc_t r = jit_bnei(j, JIT_R0, 0);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bner.c b/libguile/lightening/tests/bner.c
index c0253a6c1..1f8f05dbe 100644
--- a/libguile/lightening/tests/bner.c
+++ b/libguile/lightening/tests/bner.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_reloc_t r = jit_bner(j, JIT_R0, JIT_R1);
   jit_reti(j, 0);
diff --git a/libguile/lightening/tests/bner_d.c b/libguile/lightening/tests/bner_d.c
index d106ef51e..afe1a363f 100644
--- a/libguile/lightening/tests/bner_d.c
+++ b/libguile/lightening/tests/bner_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bner_f.c b/libguile/lightening/tests/bner_f.c
index 7c3753da0..bc5782439 100644
--- a/libguile/lightening/tests/bner_f.c
+++ b/libguile/lightening/tests/bner_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/boaddi.c b/libguile/lightening/tests/boaddi.c
index 717c4c1a7..3ee3bef28 100644
--- a/libguile/lightening/tests/boaddi.c
+++ b/libguile/lightening/tests/boaddi.c
@@ -6,13 +6,8 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
   jit_reloc_t r = jit_boaddi(j, JIT_R0, 1);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/boaddi_u.c b/libguile/lightening/tests/boaddi_u.c
index 66b261b3f..c55c1f80b 100644
--- a/libguile/lightening/tests/boaddi_u.c
+++ b/libguile/lightening/tests/boaddi_u.c
@@ -6,13 +6,8 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
   jit_reloc_t r = jit_boaddi_u(j, JIT_R0, 1);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/boaddr.c b/libguile/lightening/tests/boaddr.c
index 95fb6244f..4c86c320d 100644
--- a/libguile/lightening/tests/boaddr.c
+++ b/libguile/lightening/tests/boaddr.c
@@ -6,13 +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);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_reloc_t r = jit_boaddr(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/boaddr_u.c b/libguile/lightening/tests/boaddr_u.c
index b9b2b4585..9c610f54b 100644
--- a/libguile/lightening/tests/boaddr_u.c
+++ b/libguile/lightening/tests/boaddr_u.c
@@ -6,13 +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);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_reloc_t r = jit_boaddr_u(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bordr_d.c b/libguile/lightening/tests/bordr_d.c
index 24f42148c..6e220d931 100644
--- a/libguile/lightening/tests/bordr_d.c
+++ b/libguile/lightening/tests/bordr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bordr_f.c b/libguile/lightening/tests/bordr_f.c
index 827da92a7..29bf8d4af 100644
--- a/libguile/lightening/tests/bordr_f.c
+++ b/libguile/lightening/tests/bordr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bosubi.c b/libguile/lightening/tests/bosubi.c
index b64514070..ccf358175 100644
--- a/libguile/lightening/tests/bosubi.c
+++ b/libguile/lightening/tests/bosubi.c
@@ -6,13 +6,8 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
   jit_reloc_t r = jit_bosubi(j, JIT_R0, 1);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bosubi_u.c b/libguile/lightening/tests/bosubi_u.c
index 76a7d6726..4b36b9086 100644
--- a/libguile/lightening/tests/bosubi_u.c
+++ b/libguile/lightening/tests/bosubi_u.c
@@ -6,13 +6,8 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
   jit_reloc_t r = jit_bosubi_u(j, JIT_R0, 1);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bosubr.c b/libguile/lightening/tests/bosubr.c
index e79c10bb2..f77d9bac9 100644
--- a/libguile/lightening/tests/bosubr.c
+++ b/libguile/lightening/tests/bosubr.c
@@ -6,13 +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);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_reloc_t r = jit_bosubr(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bosubr_u.c b/libguile/lightening/tests/bosubr_u.c
index ad55af386..2e9562c4e 100644
--- a/libguile/lightening/tests/bosubr_u.c
+++ b/libguile/lightening/tests/bosubr_u.c
@@ -6,13 +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);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_reloc_t r = jit_bosubr_u(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bswapr_ui.c b/libguile/lightening/tests/bswapr_ui.c
index f566ad486..2046d7f21 100644
--- a/libguile/lightening/tests/bswapr_ui.c
+++ b/libguile/lightening/tests/bswapr_ui.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_bswapr_ui(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/bswapr_ul.c b/libguile/lightening/tests/bswapr_ul.c
index 28a2f0390..1b712dbe9 100644
--- a/libguile/lightening/tests/bswapr_ul.c
+++ b/libguile/lightening/tests/bswapr_ul.c
@@ -5,13 +5,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_bswapr_ul(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/bswapr_us.c b/libguile/lightening/tests/bswapr_us.c
index 10028dfb7..44302bc02 100644
--- a/libguile/lightening/tests/bswapr_us.c
+++ b/libguile/lightening/tests/bswapr_us.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_bswapr_us(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/buneqr_d.c b/libguile/lightening/tests/buneqr_d.c
index 887a3ddc2..b24bb2b89 100644
--- a/libguile/lightening/tests/buneqr_d.c
+++ b/libguile/lightening/tests/buneqr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/buneqr_f.c b/libguile/lightening/tests/buneqr_f.c
index 0671daeb1..2c88bf043 100644
--- a/libguile/lightening/tests/buneqr_f.c
+++ b/libguile/lightening/tests/buneqr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bunger_d.c b/libguile/lightening/tests/bunger_d.c
index 3a22336ca..21f851ff6 100644
--- a/libguile/lightening/tests/bunger_d.c
+++ b/libguile/lightening/tests/bunger_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bunger_f.c b/libguile/lightening/tests/bunger_f.c
index a4bd7f0df..3ea27d408 100644
--- a/libguile/lightening/tests/bunger_f.c
+++ b/libguile/lightening/tests/bunger_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bungtr_d.c b/libguile/lightening/tests/bungtr_d.c
index 780e8d0b2..1af89877d 100644
--- a/libguile/lightening/tests/bungtr_d.c
+++ b/libguile/lightening/tests/bungtr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bungtr_f.c b/libguile/lightening/tests/bungtr_f.c
index 4debed9f7..f60337766 100644
--- a/libguile/lightening/tests/bungtr_f.c
+++ b/libguile/lightening/tests/bungtr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bunler_d.c b/libguile/lightening/tests/bunler_d.c
index 868001eb2..d16a0dc97 100644
--- a/libguile/lightening/tests/bunler_d.c
+++ b/libguile/lightening/tests/bunler_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bunler_f.c b/libguile/lightening/tests/bunler_f.c
index 10c5d4abd..56680bab4 100644
--- a/libguile/lightening/tests/bunler_f.c
+++ b/libguile/lightening/tests/bunler_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bunltr_d.c b/libguile/lightening/tests/bunltr_d.c
index 79b96a1c7..30b157698 100644
--- a/libguile/lightening/tests/bunltr_d.c
+++ b/libguile/lightening/tests/bunltr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bunltr_f.c b/libguile/lightening/tests/bunltr_f.c
index 3fdd4bb15..97c89a08c 100644
--- a/libguile/lightening/tests/bunltr_f.c
+++ b/libguile/lightening/tests/bunltr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bunordr_d.c b/libguile/lightening/tests/bunordr_d.c
index ef3818d51..3c124f964 100644
--- a/libguile/lightening/tests/bunordr_d.c
+++ b/libguile/lightening/tests/bunordr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bunordr_f.c b/libguile/lightening/tests/bunordr_f.c
index 3af023862..a1bd0a41c 100644
--- a/libguile/lightening/tests/bunordr_f.c
+++ b/libguile/lightening/tests/bunordr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_reti(j, 0);
diff --git a/libguile/lightening/tests/bxaddi.c b/libguile/lightening/tests/bxaddi.c
index 16d405524..43894a294 100644
--- a/libguile/lightening/tests/bxaddi.c
+++ b/libguile/lightening/tests/bxaddi.c
@@ -6,13 +6,8 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
   jit_reloc_t r = jit_bxaddi(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bxaddi_u.c b/libguile/lightening/tests/bxaddi_u.c
index 6c3257876..c67d40d1d 100644
--- a/libguile/lightening/tests/bxaddi_u.c
+++ b/libguile/lightening/tests/bxaddi_u.c
@@ -6,13 +6,8 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
   jit_reloc_t r = jit_bxaddi_u(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bxaddr.c b/libguile/lightening/tests/bxaddr.c
index a73a0d8eb..85af51d49 100644
--- a/libguile/lightening/tests/bxaddr.c
+++ b/libguile/lightening/tests/bxaddr.c
@@ -6,13 +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);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_reloc_t r = jit_bxaddr(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bxaddr_u.c b/libguile/lightening/tests/bxaddr_u.c
index ba54c0391..517b03fa1 100644
--- a/libguile/lightening/tests/bxaddr_u.c
+++ b/libguile/lightening/tests/bxaddr_u.c
@@ -6,13 +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);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_reloc_t r = jit_bxaddr_u(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bxsubi.c b/libguile/lightening/tests/bxsubi.c
index 83669ac12..f6b66f8eb 100644
--- a/libguile/lightening/tests/bxsubi.c
+++ b/libguile/lightening/tests/bxsubi.c
@@ -6,13 +6,8 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
   jit_reloc_t r = jit_bxsubi(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bxsubi_u.c b/libguile/lightening/tests/bxsubi_u.c
index 5d0972706..95a78df67 100644
--- a/libguile/lightening/tests/bxsubi_u.c
+++ b/libguile/lightening/tests/bxsubi_u.c
@@ -6,13 +6,8 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
   jit_reloc_t r = jit_bxsubi_u(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bxsubr.c b/libguile/lightening/tests/bxsubr.c
index aa99db9c4..9f9b79cad 100644
--- a/libguile/lightening/tests/bxsubr.c
+++ b/libguile/lightening/tests/bxsubr.c
@@ -6,13 +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);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_reloc_t r = jit_bxsubr(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/bxsubr_u.c b/libguile/lightening/tests/bxsubr_u.c
index f476c247a..0d505b0cf 100644
--- a/libguile/lightening/tests/bxsubr_u.c
+++ b/libguile/lightening/tests/bxsubr_u.c
@@ -6,13 +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);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_reloc_t r = jit_bxsubr_u(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
diff --git a/libguile/lightening/tests/comr.c b/libguile/lightening/tests/comr.c
index 608c374c1..4b0151a5d 100644
--- a/libguile/lightening/tests/comr.c
+++ b/libguile/lightening/tests/comr.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_comr(j, JIT_R0, JIT_R0);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/divr.c b/libguile/lightening/tests/divr.c
index 389a69d15..4ca4904ef 100644
--- a/libguile/lightening/tests/divr.c
+++ b/libguile/lightening/tests/divr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_divr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/divr_d.c b/libguile/lightening/tests/divr_d.c
index 8597fdda0..d678c7370 100644
--- a/libguile/lightening/tests/divr_d.c
+++ b/libguile/lightening/tests/divr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/divr_f.c b/libguile/lightening/tests/divr_f.c
index dd2c63317..0dcf8a618 100644
--- a/libguile/lightening/tests/divr_f.c
+++ b/libguile/lightening/tests/divr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/divr_u.c b/libguile/lightening/tests/divr_u.c
index 177c6098c..c51bbc786 100644
--- a/libguile/lightening/tests/divr_u.c
+++ b/libguile/lightening/tests/divr_u.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_divr_u(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/extr_c.c b/libguile/lightening/tests/extr_c.c
index f4390a789..834777d69 100644
--- a/libguile/lightening/tests/extr_c.c
+++ b/libguile/lightening/tests/extr_c.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_extr_c(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/extr_d.c b/libguile/lightening/tests/extr_d.c
index 35d0ab3b7..40d20e6d1 100644
--- a/libguile/lightening/tests/extr_d.c
+++ b/libguile/lightening/tests/extr_d.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_extr_d(j, JIT_F0, JIT_R0);
   jit_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/extr_d_f.c b/libguile/lightening/tests/extr_d_f.c
index 570bae814..83f7a86f0 100644
--- a/libguile/lightening/tests/extr_d_f.c
+++ b/libguile/lightening/tests/extr_d_f.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_extr_d_f(j, JIT_F0, JIT_F0);
   jit_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/extr_f.c b/libguile/lightening/tests/extr_f.c
index f16cd8ca3..e84458c16 100644
--- a/libguile/lightening/tests/extr_f.c
+++ b/libguile/lightening/tests/extr_f.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_extr_f(j, JIT_F0, JIT_R0);
   jit_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/extr_f_d.c b/libguile/lightening/tests/extr_f_d.c
index 5e90be41b..8f14ea4ff 100644
--- a/libguile/lightening/tests/extr_f_d.c
+++ b/libguile/lightening/tests/extr_f_d.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_extr_f_d(j, JIT_F0, JIT_F0);
   jit_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/extr_i.c b/libguile/lightening/tests/extr_i.c
index a0ec07916..1a80b5e38 100644
--- a/libguile/lightening/tests/extr_i.c
+++ b/libguile/lightening/tests/extr_i.c
@@ -5,13 +5,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_extr_i(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/extr_s.c b/libguile/lightening/tests/extr_s.c
index c12adb722..e4d1f1eb1 100644
--- a/libguile/lightening/tests/extr_s.c
+++ b/libguile/lightening/tests/extr_s.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_extr_s(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/extr_uc.c b/libguile/lightening/tests/extr_uc.c
index fb700bd36..d9890c788 100644
--- a/libguile/lightening/tests/extr_uc.c
+++ b/libguile/lightening/tests/extr_uc.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_extr_uc(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/extr_ui.c b/libguile/lightening/tests/extr_ui.c
index 30706f093..6aa6024bb 100644
--- a/libguile/lightening/tests/extr_ui.c
+++ b/libguile/lightening/tests/extr_ui.c
@@ -5,13 +5,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_extr_ui(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/extr_us.c b/libguile/lightening/tests/extr_us.c
index a10f6e916..c10567b4f 100644
--- a/libguile/lightening/tests/extr_us.c
+++ b/libguile/lightening/tests/extr_us.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_extr_us(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/jmpr.c b/libguile/lightening/tests/jmpr.c
index 32a771791..e81a02759 100644
--- a/libguile/lightening/tests/jmpr.c
+++ b/libguile/lightening/tests/jmpr.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0));
 
   jit_jmpr(j, JIT_R0);
 
diff --git a/libguile/lightening/tests/ldr_c.c b/libguile/lightening/tests/ldr_c.c
index d653dea3b..0d50d4d59 100644
--- a/libguile/lightening/tests/ldr_c.c
+++ b/libguile/lightening/tests/ldr_c.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_c(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldr_d.c b/libguile/lightening/tests/ldr_d.c
index 8488fb30f..5f3073ada 100644
--- a/libguile/lightening/tests/ldr_d.c
+++ b/libguile/lightening/tests/ldr_d.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_d(j, JIT_F0, JIT_R1);
   jit_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/ldr_f.c b/libguile/lightening/tests/ldr_f.c
index 160af85a4..c0776b6d3 100644
--- a/libguile/lightening/tests/ldr_f.c
+++ b/libguile/lightening/tests/ldr_f.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_f(j, JIT_F0, JIT_R1);
   jit_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/ldr_i.c b/libguile/lightening/tests/ldr_i.c
index 956d254ac..ed8784a40 100644
--- a/libguile/lightening/tests/ldr_i.c
+++ b/libguile/lightening/tests/ldr_i.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_i(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldr_l.c b/libguile/lightening/tests/ldr_l.c
index a1a554a57..d71f3e47e 100644
--- a/libguile/lightening/tests/ldr_l.c
+++ b/libguile/lightening/tests/ldr_l.c
@@ -7,13 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_l(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldr_s.c b/libguile/lightening/tests/ldr_s.c
index 4384c5e00..af83dc7e6 100644
--- a/libguile/lightening/tests/ldr_s.c
+++ b/libguile/lightening/tests/ldr_s.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_s(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldr_uc.c b/libguile/lightening/tests/ldr_uc.c
index 41dad79ca..54a207531 100644
--- a/libguile/lightening/tests/ldr_uc.c
+++ b/libguile/lightening/tests/ldr_uc.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_uc(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldr_ui.c b/libguile/lightening/tests/ldr_ui.c
index 7f684f685..1867812b4 100644
--- a/libguile/lightening/tests/ldr_ui.c
+++ b/libguile/lightening/tests/ldr_ui.c
@@ -7,13 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_ui(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldr_us.c b/libguile/lightening/tests/ldr_us.c
index e813d650d..5387882a6 100644
--- a/libguile/lightening/tests/ldr_us.c
+++ b/libguile/lightening/tests/ldr_us.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_us(j, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxi_c.c b/libguile/lightening/tests/ldxi_c.c
index fd208cd58..58d1de9d4 100644
--- a/libguile/lightening/tests/ldxi_c.c
+++ b/libguile/lightening/tests/ldxi_c.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ldxi_c(j, JIT_R0, JIT_R0, (uintptr_t)&data);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxi_d.c b/libguile/lightening/tests/ldxi_d.c
index 61529233d..c74992069 100644
--- a/libguile/lightening/tests/ldxi_d.c
+++ b/libguile/lightening/tests/ldxi_d.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ldxi_d(j, JIT_F0, JIT_R0, (uintptr_t)data);
   jit_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/ldxi_f.c b/libguile/lightening/tests/ldxi_f.c
index 47afc3bed..33206debb 100644
--- a/libguile/lightening/tests/ldxi_f.c
+++ b/libguile/lightening/tests/ldxi_f.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ldxi_f(j, JIT_F0, JIT_R0, (uintptr_t)data);
   jit_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/ldxi_i.c b/libguile/lightening/tests/ldxi_i.c
index 005471838..f51bb5cfd 100644
--- a/libguile/lightening/tests/ldxi_i.c
+++ b/libguile/lightening/tests/ldxi_i.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  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_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxi_l.c b/libguile/lightening/tests/ldxi_l.c
index c9d07c4c9..9bdc6559c 100644
--- a/libguile/lightening/tests/ldxi_l.c
+++ b/libguile/lightening/tests/ldxi_l.c
@@ -7,13 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ldxi_l(j, JIT_R0, JIT_R0, (uintptr_t)data);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxi_s.c b/libguile/lightening/tests/ldxi_s.c
index 1639f6c22..4c75cc2b1 100644
--- a/libguile/lightening/tests/ldxi_s.c
+++ b/libguile/lightening/tests/ldxi_s.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ldxi_s(j, JIT_R0, JIT_R0, (uintptr_t)data);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxi_uc.c b/libguile/lightening/tests/ldxi_uc.c
index 744768b99..ebe91b46a 100644
--- a/libguile/lightening/tests/ldxi_uc.c
+++ b/libguile/lightening/tests/ldxi_uc.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ldxi_uc(j, JIT_R0, JIT_R0, (uintptr_t)data);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxi_ui.c b/libguile/lightening/tests/ldxi_ui.c
index a25b1b998..ad1599f65 100644
--- a/libguile/lightening/tests/ldxi_ui.c
+++ b/libguile/lightening/tests/ldxi_ui.c
@@ -7,13 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ldxi_ui(j, JIT_R0, JIT_R0, (uintptr_t)data);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxi_us.c b/libguile/lightening/tests/ldxi_us.c
index 1523727ec..a50e4edc1 100644
--- a/libguile/lightening/tests/ldxi_us.c
+++ b/libguile/lightening/tests/ldxi_us.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ldxi_us(j, JIT_R0, JIT_R0, (uintptr_t)data);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxr_c.c b/libguile/lightening/tests/ldxr_c.c
index 238e441cf..dd3df16ff 100644
--- a/libguile/lightening/tests/ldxr_c.c
+++ b/libguile/lightening/tests/ldxr_c.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_c(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxr_d.c b/libguile/lightening/tests/ldxr_d.c
index b79363730..28543b7c6 100644
--- a/libguile/lightening/tests/ldxr_d.c
+++ b/libguile/lightening/tests/ldxr_d.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_d(j, JIT_F0, JIT_R0, JIT_R1);
   jit_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/ldxr_f.c b/libguile/lightening/tests/ldxr_f.c
index 8c865a9b2..a87f15acd 100644
--- a/libguile/lightening/tests/ldxr_f.c
+++ b/libguile/lightening/tests/ldxr_f.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_f(j, JIT_F0, JIT_R0, JIT_R1);
   jit_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/ldxr_i.c b/libguile/lightening/tests/ldxr_i.c
index fb003204b..65ed0395b 100644
--- a/libguile/lightening/tests/ldxr_i.c
+++ b/libguile/lightening/tests/ldxr_i.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_i(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxr_l.c b/libguile/lightening/tests/ldxr_l.c
index f139e8e00..d8afce547 100644
--- a/libguile/lightening/tests/ldxr_l.c
+++ b/libguile/lightening/tests/ldxr_l.c
@@ -7,13 +7,8 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_l(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxr_s.c b/libguile/lightening/tests/ldxr_s.c
index 8ba44c1ff..7f0724c27 100644
--- a/libguile/lightening/tests/ldxr_s.c
+++ b/libguile/lightening/tests/ldxr_s.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_s(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxr_uc.c b/libguile/lightening/tests/ldxr_uc.c
index b6a3cb142..d6dcaf979 100644
--- a/libguile/lightening/tests/ldxr_uc.c
+++ b/libguile/lightening/tests/ldxr_uc.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_uc(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxr_ui.c b/libguile/lightening/tests/ldxr_ui.c
index 04fcb7d77..4e2d773be 100644
--- a/libguile/lightening/tests/ldxr_ui.c
+++ b/libguile/lightening/tests/ldxr_ui.c
@@ -7,13 +7,8 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_ui(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/ldxr_us.c b/libguile/lightening/tests/ldxr_us.c
index 12c4d9ca1..78d38f5ef 100644
--- a/libguile/lightening/tests/ldxr_us.c
+++ b/libguile/lightening/tests/ldxr_us.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_ldxr_us(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/lshi.c b/libguile/lightening/tests/lshi.c
index 41c079a33..183aed9ff 100644
--- a/libguile/lightening/tests/lshi.c
+++ b/libguile/lightening/tests/lshi.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_lshi(j, JIT_R0, JIT_R0, 31);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/lshr.c b/libguile/lightening/tests/lshr.c
index 80edae3b3..5f3d5b96e 100644
--- a/libguile/lightening/tests/lshr.c
+++ b/libguile/lightening/tests/lshr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_lshr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/mulr.c b/libguile/lightening/tests/mulr.c
index 4cd28e618..943b31e01 100644
--- a/libguile/lightening/tests/mulr.c
+++ b/libguile/lightening/tests/mulr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_mulr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/mulr_d.c b/libguile/lightening/tests/mulr_d.c
index 0b4fa18ad..460b14baf 100644
--- a/libguile/lightening/tests/mulr_d.c
+++ b/libguile/lightening/tests/mulr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/mulr_f.c b/libguile/lightening/tests/mulr_f.c
index ed716fa5f..6189be263 100644
--- a/libguile/lightening/tests/mulr_f.c
+++ b/libguile/lightening/tests/mulr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/negr.c b/libguile/lightening/tests/negr.c
index 5a5c5c1d2..974d3f0e9 100644
--- a/libguile/lightening/tests/negr.c
+++ b/libguile/lightening/tests/negr.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_negr(j, JIT_R0, JIT_R0);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/negr_d.c b/libguile/lightening/tests/negr_d.c
index 1af229be6..566061c46 100644
--- a/libguile/lightening/tests/negr_d.c
+++ b/libguile/lightening/tests/negr_d.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_negr_d(j, JIT_F0, JIT_F0);
   jit_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/negr_f.c b/libguile/lightening/tests/negr_f.c
index cdc1ccdcc..24b509f41 100644
--- a/libguile/lightening/tests/negr_f.c
+++ b/libguile/lightening/tests/negr_f.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_negr_f(j, JIT_F0, JIT_F0);
   jit_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/ori.c b/libguile/lightening/tests/ori.c
index 59e91b95a..ad555769d 100644
--- a/libguile/lightening/tests/ori.c
+++ b/libguile/lightening/tests/ori.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_ori(j, JIT_R0, JIT_R0, 1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/orr.c b/libguile/lightening/tests/orr.c
index 6c98544b4..10b7c3d17 100644
--- a/libguile/lightening/tests/orr.c
+++ b/libguile/lightening/tests/orr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_orr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/pushpop.c b/libguile/lightening/tests/pushpop.c
index 9a464c3ed..d2a4ab7bb 100644
--- a/libguile/lightening/tests/pushpop.c
+++ b/libguile/lightening/tests/pushpop.c
@@ -8,12 +8,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 
   jit_begin(j, arena_base, arena_size);
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   for (int i=0; i<6; i++)
     jit_pushr(j, gpr[i]);
diff --git a/libguile/lightening/tests/qdivr.c b/libguile/lightening/tests/qdivr.c
index d6e967c13..d54c3c181 100644
--- a/libguile/lightening/tests/qdivr.c
+++ b/libguile/lightening/tests/qdivr.c
@@ -18,23 +18,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = {
-    JIT_ARG_ABI_POINTER, JIT_ARG_ABI_POINTER,
-    JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX
-  };
-  jit_arg_t args[4];
-  const jit_anyreg_t regs[] = {
-    { .gpr=JIT_R0 }, { .gpr=JIT_R1 },
-    { .gpr=JIT_R2 }, { .gpr=JIT_V0 }
-  };
-
   maybe_save(j, JIT_V0);
   maybe_save(j, JIT_V1);
   maybe_save(j, JIT_V2);
 
-  jit_receive(j, 4, abi, args);
-  jit_load_args(j, 4, abi, args, regs);
+  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_load_args(j, 4, args);
 
   jit_qdivr(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
   jit_str(j, JIT_R0, JIT_V1);
diff --git a/libguile/lightening/tests/qdivr_u.c b/libguile/lightening/tests/qdivr_u.c
index 8b2f63ee3..0471e9ed2 100644
--- a/libguile/lightening/tests/qdivr_u.c
+++ b/libguile/lightening/tests/qdivr_u.c
@@ -19,22 +19,16 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
 
-  const jit_arg_abi_t abi[] = {
-    JIT_ARG_ABI_POINTER, JIT_ARG_ABI_POINTER,
-    JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX
-  };
-  jit_arg_t args[4];
-  const jit_anyreg_t regs[] = {
-    { .gpr=JIT_R0 }, { .gpr=JIT_R1 },
-    { .gpr=JIT_R2 }, { .gpr=JIT_V0 }
-  };
-
   maybe_save(j, JIT_V0);
   maybe_save(j, JIT_V1);
   maybe_save(j, JIT_V2);
 
-  jit_receive(j, 4, abi, args);
-  jit_load_args(j, 4, abi, args, regs);
+  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_load_args(j, 4, args);
 
   jit_qdivr_u(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
   jit_str(j, JIT_R0, JIT_V1);
diff --git a/libguile/lightening/tests/qmulr.c b/libguile/lightening/tests/qmulr.c
index a683cc4e0..68a2f40dd 100644
--- a/libguile/lightening/tests/qmulr.c
+++ b/libguile/lightening/tests/qmulr.c
@@ -19,22 +19,16 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
 
-  const jit_arg_abi_t abi[] = {
-    JIT_ARG_ABI_POINTER, JIT_ARG_ABI_POINTER,
-    JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX
-  };
-  jit_arg_t args[4];
-  const jit_anyreg_t regs[] = {
-    { .gpr=JIT_R0 }, { .gpr=JIT_R1 },
-    { .gpr=JIT_R2 }, { .gpr=JIT_V0 }
-  };
-
   maybe_save(j, JIT_V0);
   maybe_save(j, JIT_V1);
   maybe_save(j, JIT_V2);
 
-  jit_receive(j, 4, abi, args);
-  jit_load_args(j, 4, abi, args, regs);
+  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_load_args(j, 4, args);
 
   jit_qmulr(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
   jit_str(j, JIT_R0, JIT_V1);
diff --git a/libguile/lightening/tests/qmulr_u.c b/libguile/lightening/tests/qmulr_u.c
index e5e727788..f3724e543 100644
--- a/libguile/lightening/tests/qmulr_u.c
+++ b/libguile/lightening/tests/qmulr_u.c
@@ -19,22 +19,16 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
 
-  const jit_arg_abi_t abi[] = {
-    JIT_ARG_ABI_POINTER, JIT_ARG_ABI_POINTER,
-    JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX
-  };
-  jit_arg_t args[4];
-  const jit_anyreg_t regs[] = {
-    { .gpr=JIT_R0 }, { .gpr=JIT_R1 },
-    { .gpr=JIT_R2 }, { .gpr=JIT_V0 }
-  };
-
   maybe_save(j, JIT_V0);
   maybe_save(j, JIT_V1);
   maybe_save(j, JIT_V2);
 
-  jit_receive(j, 4, abi, args);
-  jit_load_args(j, 4, abi, args, regs);
+  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_load_args(j, 4, args);
 
   jit_qmulr_u(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
   jit_str(j, JIT_R0, JIT_V1);
diff --git a/libguile/lightening/tests/remr.c b/libguile/lightening/tests/remr.c
index a06e2407f..3c61384b6 100644
--- a/libguile/lightening/tests/remr.c
+++ b/libguile/lightening/tests/remr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_remr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/remr_u.c b/libguile/lightening/tests/remr_u.c
index 025018142..01113dbef 100644
--- a/libguile/lightening/tests/remr_u.c
+++ b/libguile/lightening/tests/remr_u.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_remr_u(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/rshi.c b/libguile/lightening/tests/rshi.c
index 0f2cdfda7..1f1ed6d94 100644
--- a/libguile/lightening/tests/rshi.c
+++ b/libguile/lightening/tests/rshi.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_rshi(j, JIT_R0, JIT_R0, 31);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/rshi_u.c b/libguile/lightening/tests/rshi_u.c
index 141c41c09..e78a205b8 100644
--- a/libguile/lightening/tests/rshi_u.c
+++ b/libguile/lightening/tests/rshi_u.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_rshi_u(j, JIT_R0, JIT_R0, 31);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/rshr.c b/libguile/lightening/tests/rshr.c
index ef702b630..1a32bfd03 100644
--- a/libguile/lightening/tests/rshr.c
+++ b/libguile/lightening/tests/rshr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_rshr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/rshr_u.c b/libguile/lightening/tests/rshr_u.c
index 268117fe5..644e71728 100644
--- a/libguile/lightening/tests/rshr_u.c
+++ b/libguile/lightening/tests/rshr_u.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_rshr_u(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/sqrtr_d.c b/libguile/lightening/tests/sqrtr_d.c
index cb17b56ac..35e2230a7 100644
--- a/libguile/lightening/tests/sqrtr_d.c
+++ b/libguile/lightening/tests/sqrtr_d.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_sqrtr_d(j, JIT_F0, JIT_F0);
   jit_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/sqrtr_f.c b/libguile/lightening/tests/sqrtr_f.c
index ffa9211af..0c3737337 100644
--- a/libguile/lightening/tests/sqrtr_f.c
+++ b/libguile/lightening/tests/sqrtr_f.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_sqrtr_f(j, JIT_F0, JIT_F0);
   jit_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/sti_c.c b/libguile/lightening/tests/sti_c.c
index 10b7b6a91..61ae9b69d 100644
--- a/libguile/lightening/tests/sti_c.c
+++ b/libguile/lightening/tests/sti_c.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INT8 };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_sti_c(j, &data[1], JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/sti_d.c b/libguile/lightening/tests/sti_d.c
index 2c51827f5..c10b7b7dd 100644
--- a/libguile/lightening/tests/sti_d.c
+++ b/libguile/lightening/tests/sti_d.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_sti_d(j, &data[1], JIT_F0);
   jit_ret(j);
diff --git a/libguile/lightening/tests/sti_f.c b/libguile/lightening/tests/sti_f.c
index 1e3674a4f..240152654 100644
--- a/libguile/lightening/tests/sti_f.c
+++ b/libguile/lightening/tests/sti_f.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_sti_f(j, &data[1], JIT_F0);
   jit_ret(j);
diff --git a/libguile/lightening/tests/sti_i.c b/libguile/lightening/tests/sti_i.c
index b0e6d83f7..c8bb72e73 100644
--- a/libguile/lightening/tests/sti_i.c
+++ b/libguile/lightening/tests/sti_i.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INT32 };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_sti_i(j, &data[1], JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/sti_l.c b/libguile/lightening/tests/sti_l.c
index e997b014f..5bd4ed19f 100644
--- a/libguile/lightening/tests/sti_l.c
+++ b/libguile/lightening/tests/sti_l.c
@@ -7,13 +7,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INT64 };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT64, JIT_R1));
 
   jit_sti_l(j, &data[1], JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/sti_s.c b/libguile/lightening/tests/sti_s.c
index 95cfd3396..4d4b27212 100644
--- a/libguile/lightening/tests/sti_s.c
+++ b/libguile/lightening/tests/sti_s.c
@@ -6,13 +6,7 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INT16 };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_sti_s(j, &data[1], JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/str_c.c b/libguile/lightening/tests/str_c.c
index eb04a85df..f8d7d7543 100644
--- a/libguile/lightening/tests/str_c.c
+++ b/libguile/lightening/tests/str_c.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INT8 };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_ret(j);
diff --git a/libguile/lightening/tests/str_d.c b/libguile/lightening/tests/str_d.c
index 04e5aed57..817fd64a2 100644
--- a/libguile/lightening/tests/str_d.c
+++ b/libguile/lightening/tests/str_d.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .fpr=JIT_F0 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_ret(j);
diff --git a/libguile/lightening/tests/str_f.c b/libguile/lightening/tests/str_f.c
index 167fac038..22af0d580 100644
--- a/libguile/lightening/tests/str_f.c
+++ b/libguile/lightening/tests/str_f.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .fpr=JIT_F0 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_ret(j);
diff --git a/libguile/lightening/tests/str_i.c b/libguile/lightening/tests/str_i.c
index 7dd6d8c78..3872ed771 100644
--- a/libguile/lightening/tests/str_i.c
+++ b/libguile/lightening/tests/str_i.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INT32 };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_ret(j);
diff --git a/libguile/lightening/tests/str_l.c b/libguile/lightening/tests/str_l.c
index 8a1b905ea..0b4755c24 100644
--- a/libguile/lightening/tests/str_l.c
+++ b/libguile/lightening/tests/str_l.c
@@ -7,13 +7,8 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INT64 };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_ret(j);
diff --git a/libguile/lightening/tests/str_s.c b/libguile/lightening/tests/str_s.c
index 97932ad31..0044d8286 100644
--- a/libguile/lightening/tests/str_s.c
+++ b/libguile/lightening/tests/str_s.c
@@ -6,13 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INT16 };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_ret(j);
diff --git a/libguile/lightening/tests/stxi_c.c b/libguile/lightening/tests/stxi_c.c
index 1a877434f..c38e5292e 100644
--- a/libguile/lightening/tests/stxi_c.c
+++ b/libguile/lightening/tests/stxi_c.c
@@ -6,15 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INT8 };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R2 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_stxi_c(j, (uintptr_t)data, JIT_R2, JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxi_d.c b/libguile/lightening/tests/stxi_d.c
index a9de3d23d..cf68704cc 100644
--- a/libguile/lightening/tests/stxi_d.c
+++ b/libguile/lightening/tests/stxi_d.c
@@ -6,15 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R2 }, { .fpr=JIT_F0 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_stxi_d(j, (uintptr_t)data, JIT_R2, JIT_F0);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxi_f.c b/libguile/lightening/tests/stxi_f.c
index a348249ea..cec7fba69 100644
--- a/libguile/lightening/tests/stxi_f.c
+++ b/libguile/lightening/tests/stxi_f.c
@@ -6,15 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R2 }, { .fpr=JIT_F0 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_stxi_f(j, (uintptr_t)data, JIT_R2, JIT_F0);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxi_i.c b/libguile/lightening/tests/stxi_i.c
index c39adc2cd..d0aef1116 100644
--- a/libguile/lightening/tests/stxi_i.c
+++ b/libguile/lightening/tests/stxi_i.c
@@ -6,15 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INT32 };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R2 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_stxi_i(j, (uintptr_t)data, JIT_R2, JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxi_l.c b/libguile/lightening/tests/stxi_l.c
index b280c4d72..f731ee49b 100644
--- a/libguile/lightening/tests/stxi_l.c
+++ b/libguile/lightening/tests/stxi_l.c
@@ -7,15 +7,8 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INT64 };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R2 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INT64, JIT_R1));
 
   jit_stxi_l(j, (uintptr_t)data, JIT_R2, JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxi_s.c b/libguile/lightening/tests/stxi_s.c
index 09af31ea6..4deb826e6 100644
--- a/libguile/lightening/tests/stxi_s.c
+++ b/libguile/lightening/tests/stxi_s.c
@@ -6,15 +6,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INT16 };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R2 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R2),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_stxi_s(j, (uintptr_t)data, JIT_R2, JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxr_c.c b/libguile/lightening/tests/stxr_c.c
index 14e40c787..bcebb3530 100644
--- a/libguile/lightening/tests/stxr_c.c
+++ b/libguile/lightening/tests/stxr_c.c
@@ -6,15 +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);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INT8 };
-  jit_arg_t args[3];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R0 }, { .gpr=JIT_R2 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 3, abi, args);
-  jit_load_args(j, 3, abi, args, regs);
+  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_INT8, JIT_R1));
 
   jit_stxr_c(j, JIT_R0, JIT_R2, JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxr_d.c b/libguile/lightening/tests/stxr_d.c
index 8f1d957d7..ba4988a8d 100644
--- a/libguile/lightening/tests/stxr_d.c
+++ b/libguile/lightening/tests/stxr_d.c
@@ -6,15 +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);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[3];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R0 }, { .gpr=JIT_R2 }, { .fpr=JIT_F0 } };
-
-  jit_receive(j, 3, abi, args);
-  jit_load_args(j, 3, abi, args, regs);
+  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_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_stxr_d(j, JIT_R0, JIT_R2, JIT_F0);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxr_f.c b/libguile/lightening/tests/stxr_f.c
index 7de57715c..30c1e92de 100644
--- a/libguile/lightening/tests/stxr_f.c
+++ b/libguile/lightening/tests/stxr_f.c
@@ -6,15 +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);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[3];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R0 }, { .gpr=JIT_R2 }, { .fpr=JIT_F0 } };
-
-  jit_receive(j, 3, abi, args);
-  jit_load_args(j, 3, abi, args, regs);
+  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_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_stxr_f(j, JIT_R0, JIT_R2, JIT_F0);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxr_i.c b/libguile/lightening/tests/stxr_i.c
index b613ec00a..247cab215 100644
--- a/libguile/lightening/tests/stxr_i.c
+++ b/libguile/lightening/tests/stxr_i.c
@@ -6,15 +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);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INT32 };
-  jit_arg_t args[3];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R0 }, { .gpr=JIT_R2 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 3, abi, args);
-  jit_load_args(j, 3, abi, args, regs);
+  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_INT32, JIT_R1));
 
   jit_stxr_i(j, JIT_R0, JIT_R2, JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxr_l.c b/libguile/lightening/tests/stxr_l.c
index 0fd239cc7..e680238c5 100644
--- a/libguile/lightening/tests/stxr_l.c
+++ b/libguile/lightening/tests/stxr_l.c
@@ -7,15 +7,9 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INT64 };
-  jit_arg_t args[3];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R0 }, { .gpr=JIT_R2 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 3, abi, args);
-  jit_load_args(j, 3, abi, args, regs);
+  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_INT64, JIT_R1));
 
   jit_stxr_l(j, JIT_R0, JIT_R2, JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/stxr_s.c b/libguile/lightening/tests/stxr_s.c
index 926da5694..02d848382 100644
--- a/libguile/lightening/tests/stxr_s.c
+++ b/libguile/lightening/tests/stxr_s.c
@@ -6,15 +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);
-
-  const jit_arg_abi_t abi[] =
-    { JIT_ARG_ABI_POINTER, JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INT16 };
-  jit_arg_t args[3];
-  const jit_anyreg_t regs[] =
-    { { .gpr=JIT_R0 }, { .gpr=JIT_R2 }, { .gpr=JIT_R1 } };
-
-  jit_receive(j, 3, abi, args);
-  jit_load_args(j, 3, abi, args, regs);
+  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_INT16, JIT_R1));
 
   jit_stxr_s(j, JIT_R0, JIT_R2, JIT_R1);
   jit_ret(j);
diff --git a/libguile/lightening/tests/subr.c b/libguile/lightening/tests/subr.c
index a375dff93..0ed2e320b 100644
--- a/libguile/lightening/tests/subr.c
+++ b/libguile/lightening/tests/subr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_subr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/subr_d.c b/libguile/lightening/tests/subr_d.c
index 94c5ea477..71259a8e3 100644
--- a/libguile/lightening/tests/subr_d.c
+++ b/libguile/lightening/tests/subr_d.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_retr_d(j, JIT_F0);
diff --git a/libguile/lightening/tests/subr_f.c b/libguile/lightening/tests/subr_f.c
index fd6b37777..410dc265d 100644
--- a/libguile/lightening/tests/subr_f.c
+++ b/libguile/lightening/tests/subr_f.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  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_retr_f(j, JIT_F0);
diff --git a/libguile/lightening/tests/subx.c b/libguile/lightening/tests/subx.c
index f28739965..91f1f9565 100644
--- a/libguile/lightening/tests/subx.c
+++ b/libguile/lightening/tests/subx.c
@@ -4,13 +4,9 @@ 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));
 
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
   jit_movi(j, JIT_R2, 0);
   jit_subcr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_subxi(j, JIT_R2, JIT_R2, 0);
diff --git a/libguile/lightening/tests/truncr_d_i.c b/libguile/lightening/tests/truncr_d_i.c
index c703ae8ba..12aaa917d 100644
--- a/libguile/lightening/tests/truncr_d_i.c
+++ b/libguile/lightening/tests/truncr_d_i.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_truncr_d_i(j, JIT_R0, JIT_F0);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/truncr_d_l.c b/libguile/lightening/tests/truncr_d_l.c
index 752a76fa0..1f5dc995e 100644
--- a/libguile/lightening/tests/truncr_d_l.c
+++ b/libguile/lightening/tests/truncr_d_l.c
@@ -5,13 +5,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_truncr_d_l(j, JIT_R0, JIT_F0);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/truncr_f_i.c b/libguile/lightening/tests/truncr_f_i.c
index 32fd71fdf..077d7bec8 100644
--- a/libguile/lightening/tests/truncr_f_i.c
+++ b/libguile/lightening/tests/truncr_f_i.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_truncr_f_i(j, JIT_R0, JIT_F0);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/truncr_f_l.c b/libguile/lightening/tests/truncr_f_l.c
index af3a1168e..c5a86f89b 100644
--- a/libguile/lightening/tests/truncr_f_l.c
+++ b/libguile/lightening/tests/truncr_f_l.c
@@ -5,13 +5,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_truncr_f_l(j, JIT_R0, JIT_F0);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/xori.c b/libguile/lightening/tests/xori.c
index 59859fc29..5884025d6 100644
--- a/libguile/lightening/tests/xori.c
+++ b/libguile/lightening/tests/xori.c
@@ -4,13 +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);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[1];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
-
-  jit_receive(j, 1, abi, args);
-  jit_load_args(j, 1, abi, args, regs);
+  jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
 
   jit_xori(j, JIT_R0, JIT_R0, 1);
   jit_retr(j, JIT_R0);
diff --git a/libguile/lightening/tests/xorr.c b/libguile/lightening/tests/xorr.c
index 1be654b09..c24946638 100644
--- a/libguile/lightening/tests/xorr.c
+++ b/libguile/lightening/tests/xorr.c
@@ -4,13 +4,8 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
-
-  const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
-  jit_arg_t args[2];
-  const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
-
-  jit_receive(j, 2, abi, args);
-  jit_load_args(j, 2, abi, args, regs);
+  jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
+                  jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
 
   jit_xorr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_retr(j, JIT_R0);