[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Guile-commits] 04/09: Simplify API for loading call arguments
|
From: |
Andy Wingo |
|
Subject: |
[Guile-commits] 04/09: Simplify API for loading call arguments |
|
Date: |
Wed, 24 Apr 2019 10:04:21 -0400 (EDT) |
wingo pushed a commit to branch lightening
in repository guile.
commit 0be4f7a2a1a5ed8bb972f5489013e914d941718d
Author: Andy Wingo <address@hidden>
Date: Thu Apr 18 17:47:01 2019 +0200
Simplify API for loading call arguments
---
lightening.h | 169 +++++++++++++++++-----
lightening/lightening.c | 5 +-
lightening/x86.c | 375 +++++++++++++++++++++++++-----------------------
tests/absr_d.c | 8 +-
tests/absr_f.c | 8 +-
tests/addi.c | 8 +-
tests/addr.c | 9 +-
tests/addr_d.c | 9 +-
tests/addr_f.c | 9 +-
tests/addx.c | 8 +-
tests/andi.c | 8 +-
tests/andr.c | 9 +-
tests/beqi.c | 8 +-
tests/beqr.c | 9 +-
tests/beqr_d.c | 9 +-
tests/beqr_f.c | 9 +-
tests/bgei.c | 8 +-
tests/bgei_u.c | 8 +-
tests/bger.c | 9 +-
tests/bger_d.c | 9 +-
tests/bger_f.c | 9 +-
tests/bger_u.c | 9 +-
tests/bgti.c | 8 +-
tests/bgti_u.c | 8 +-
tests/bgtr.c | 9 +-
tests/bgtr_d.c | 9 +-
tests/bgtr_f.c | 9 +-
tests/bgtr_u.c | 9 +-
tests/blei.c | 8 +-
tests/blei_u.c | 8 +-
tests/bler.c | 9 +-
tests/bler_d.c | 9 +-
tests/bler_f.c | 9 +-
tests/bler_u.c | 9 +-
tests/bltgtr_d.c | 9 +-
tests/bltgtr_f.c | 9 +-
tests/blti.c | 8 +-
tests/blti_u.c | 8 +-
tests/bltr.c | 9 +-
tests/bltr_d.c | 9 +-
tests/bltr_f.c | 9 +-
tests/bltr_u.c | 9 +-
tests/bmci.c | 8 +-
tests/bmcr.c | 9 +-
tests/bmsi.c | 8 +-
tests/bmsr.c | 9 +-
tests/bnei.c | 8 +-
tests/bner.c | 9 +-
tests/bner_d.c | 9 +-
tests/bner_f.c | 9 +-
tests/boaddi.c | 7 +-
tests/boaddi_u.c | 7 +-
tests/boaddr.c | 8 +-
tests/boaddr_u.c | 8 +-
tests/bordr_d.c | 9 +-
tests/bordr_f.c | 9 +-
tests/bosubi.c | 7 +-
tests/bosubi_u.c | 7 +-
tests/bosubr.c | 8 +-
tests/bosubr_u.c | 8 +-
tests/bswapr_ui.c | 8 +-
tests/bswapr_ul.c | 8 +-
tests/bswapr_us.c | 8 +-
tests/buneqr_d.c | 9 +-
tests/buneqr_f.c | 9 +-
tests/bunger_d.c | 9 +-
tests/bunger_f.c | 9 +-
tests/bungtr_d.c | 9 +-
tests/bungtr_f.c | 9 +-
tests/bunler_d.c | 9 +-
tests/bunler_f.c | 9 +-
tests/bunltr_d.c | 9 +-
tests/bunltr_f.c | 9 +-
tests/bunordr_d.c | 9 +-
tests/bunordr_f.c | 9 +-
tests/bxaddi.c | 7 +-
tests/bxaddi_u.c | 7 +-
tests/bxaddr.c | 8 +-
tests/bxaddr_u.c | 8 +-
tests/bxsubi.c | 7 +-
tests/bxsubi_u.c | 7 +-
tests/bxsubr.c | 8 +-
tests/bxsubr_u.c | 8 +-
tests/comr.c | 8 +-
tests/divr.c | 9 +-
tests/divr_d.c | 9 +-
tests/divr_f.c | 9 +-
tests/divr_u.c | 9 +-
tests/extr_c.c | 8 +-
tests/extr_d.c | 8 +-
tests/extr_d_f.c | 8 +-
tests/extr_f.c | 8 +-
tests/extr_f_d.c | 8 +-
tests/extr_i.c | 8 +-
tests/extr_s.c | 8 +-
tests/extr_uc.c | 8 +-
tests/extr_ui.c | 8 +-
tests/extr_us.c | 8 +-
tests/jmpr.c | 8 +-
tests/ldr_c.c | 8 +-
tests/ldr_d.c | 8 +-
tests/ldr_f.c | 8 +-
tests/ldr_i.c | 8 +-
tests/ldr_l.c | 8 +-
tests/ldr_s.c | 8 +-
tests/ldr_uc.c | 8 +-
tests/ldr_ui.c | 8 +-
tests/ldr_us.c | 8 +-
tests/ldxi_c.c | 8 +-
tests/ldxi_d.c | 8 +-
tests/ldxi_f.c | 8 +-
tests/ldxi_i.c | 8 +-
tests/ldxi_l.c | 8 +-
tests/ldxi_s.c | 8 +-
tests/ldxi_uc.c | 8 +-
tests/ldxi_ui.c | 8 +-
tests/ldxi_us.c | 8 +-
tests/ldxr_c.c | 9 +-
tests/ldxr_d.c | 9 +-
tests/ldxr_f.c | 9 +-
tests/ldxr_i.c | 9 +-
tests/ldxr_l.c | 9 +-
tests/ldxr_s.c | 9 +-
tests/ldxr_uc.c | 9 +-
tests/ldxr_ui.c | 9 +-
tests/ldxr_us.c | 9 +-
tests/lshi.c | 8 +-
tests/lshr.c | 9 +-
tests/mulr.c | 9 +-
tests/mulr_d.c | 9 +-
tests/mulr_f.c | 9 +-
tests/negr.c | 8 +-
tests/negr_d.c | 8 +-
tests/negr_f.c | 8 +-
tests/ori.c | 8 +-
tests/orr.c | 9 +-
tests/pushpop.c | 7 +-
tests/qdivr.c | 19 +--
tests/qdivr_u.c | 18 +--
tests/qmulr.c | 18 +--
tests/qmulr_u.c | 18 +--
tests/remr.c | 9 +-
tests/remr_u.c | 9 +-
tests/rshi.c | 8 +-
tests/rshi_u.c | 8 +-
tests/rshr.c | 9 +-
tests/rshr_u.c | 9 +-
tests/sqrtr_d.c | 8 +-
tests/sqrtr_f.c | 8 +-
tests/sti_c.c | 8 +-
tests/sti_d.c | 8 +-
tests/sti_f.c | 8 +-
tests/sti_i.c | 8 +-
tests/sti_l.c | 8 +-
tests/sti_s.c | 8 +-
tests/str_c.c | 9 +-
tests/str_d.c | 9 +-
tests/str_f.c | 9 +-
tests/str_i.c | 9 +-
tests/str_l.c | 9 +-
tests/str_s.c | 9 +-
tests/stxi_c.c | 11 +-
tests/stxi_d.c | 11 +-
tests/stxi_f.c | 11 +-
tests/stxi_i.c | 11 +-
tests/stxi_l.c | 11 +-
tests/stxi_s.c | 11 +-
tests/stxr_c.c | 12 +-
tests/stxr_d.c | 12 +-
tests/stxr_f.c | 12 +-
tests/stxr_i.c | 12 +-
tests/stxr_l.c | 12 +-
tests/stxr_s.c | 12 +-
tests/subr.c | 9 +-
tests/subr_d.c | 9 +-
tests/subr_f.c | 9 +-
tests/subx.c | 8 +-
tests/truncr_d_i.c | 8 +-
tests/truncr_d_l.c | 8 +-
tests/truncr_f_i.c | 8 +-
tests/truncr_f_l.c | 8 +-
tests/xori.c | 8 +-
tests/xorr.c | 9 +-
183 files changed, 641 insertions(+), 1498 deletions(-)
diff --git a/lightening.h b/lightening.h
index ba56513..20a1441 100644
--- a/lightening.h
+++ b/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/lightening/lightening.c b/lightening/lightening.c
index 14c8426..d3494fd 100644
--- a/lightening/lightening.c
+++ b/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/lightening/x86.c b/lightening/x86.c
index 0ec8c2f..b8d1150 100644
--- a/lightening/x86.c
+++ b/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/tests/absr_d.c b/tests/absr_d.c
index 5671c4f..93b10b6 100644
--- a/tests/absr_d.c
+++ b/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/tests/absr_f.c b/tests/absr_f.c
index e93fb49..64463bf 100644
--- a/tests/absr_f.c
+++ b/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/tests/addi.c b/tests/addi.c
index 9b1a82b..f0e632c 100644
--- a/tests/addi.c
+++ b/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/tests/addr.c b/tests/addr.c
index 236fcd1..8894cc5 100644
--- a/tests/addr.c
+++ b/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/tests/addr_d.c b/tests/addr_d.c
index e89663e..8c7be62 100644
--- a/tests/addr_d.c
+++ b/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/tests/addr_f.c b/tests/addr_f.c
index ce918fd..1ed1f36 100644
--- a/tests/addr_f.c
+++ b/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/tests/addx.c b/tests/addx.c
index 664c139..6013e52 100644
--- a/tests/addx.c
+++ b/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/tests/andi.c b/tests/andi.c
index 781b7d0..a1d3203 100644
--- a/tests/andi.c
+++ b/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/tests/andr.c b/tests/andr.c
index 4c549e8..62cc61e 100644
--- a/tests/andr.c
+++ b/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/tests/beqi.c b/tests/beqi.c
index d65d48d..9941473 100644
--- a/tests/beqi.c
+++ b/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/tests/beqr.c b/tests/beqr.c
index 6df434d..2bdeb24 100644
--- a/tests/beqr.c
+++ b/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/tests/beqr_d.c b/tests/beqr_d.c
index 408f0df..628e80c 100644
--- a/tests/beqr_d.c
+++ b/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/tests/beqr_f.c b/tests/beqr_f.c
index 2e91105..dca60fa 100644
--- a/tests/beqr_f.c
+++ b/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/tests/bgei.c b/tests/bgei.c
index 25fe2ee..7a847e6 100644
--- a/tests/bgei.c
+++ b/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/tests/bgei_u.c b/tests/bgei_u.c
index f2b5a53..6847613 100644
--- a/tests/bgei_u.c
+++ b/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/tests/bger.c b/tests/bger.c
index 0bff98a..68df65b 100644
--- a/tests/bger.c
+++ b/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/tests/bger_d.c b/tests/bger_d.c
index 74786ad..ab1190e 100644
--- a/tests/bger_d.c
+++ b/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/tests/bger_f.c b/tests/bger_f.c
index 03dde27..07cf7f0 100644
--- a/tests/bger_f.c
+++ b/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/tests/bger_u.c b/tests/bger_u.c
index 890aec9..806953c 100644
--- a/tests/bger_u.c
+++ b/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/tests/bgti.c b/tests/bgti.c
index fa1e7aa..e6e6c05 100644
--- a/tests/bgti.c
+++ b/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/tests/bgti_u.c b/tests/bgti_u.c
index 2d01728..f604fed 100644
--- a/tests/bgti_u.c
+++ b/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/tests/bgtr.c b/tests/bgtr.c
index 779b320..de31bf8 100644
--- a/tests/bgtr.c
+++ b/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/tests/bgtr_d.c b/tests/bgtr_d.c
index f5ea7a2..1cc8dd5 100644
--- a/tests/bgtr_d.c
+++ b/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/tests/bgtr_f.c b/tests/bgtr_f.c
index e1aec3a..37d65f2 100644
--- a/tests/bgtr_f.c
+++ b/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/tests/bgtr_u.c b/tests/bgtr_u.c
index cec4d17..31202c4 100644
--- a/tests/bgtr_u.c
+++ b/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/tests/blei.c b/tests/blei.c
index 1d0a91e..c9317ea 100644
--- a/tests/blei.c
+++ b/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/tests/blei_u.c b/tests/blei_u.c
index fcfde3a..614ddf0 100644
--- a/tests/blei_u.c
+++ b/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/tests/bler.c b/tests/bler.c
index b4ec034..ba580b0 100644
--- a/tests/bler.c
+++ b/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/tests/bler_d.c b/tests/bler_d.c
index 8d189a8..f11b923 100644
--- a/tests/bler_d.c
+++ b/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/tests/bler_f.c b/tests/bler_f.c
index 74cc65c..9c0a7f7 100644
--- a/tests/bler_f.c
+++ b/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/tests/bler_u.c b/tests/bler_u.c
index 006f84b..036bb64 100644
--- a/tests/bler_u.c
+++ b/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/tests/bltgtr_d.c b/tests/bltgtr_d.c
index 79ef139..6d433e4 100644
--- a/tests/bltgtr_d.c
+++ b/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/tests/bltgtr_f.c b/tests/bltgtr_f.c
index 8cbf83e..711e516 100644
--- a/tests/bltgtr_f.c
+++ b/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/tests/blti.c b/tests/blti.c
index 8c3cd34..a16ac02 100644
--- a/tests/blti.c
+++ b/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/tests/blti_u.c b/tests/blti_u.c
index b7af89d..1a93f1d 100644
--- a/tests/blti_u.c
+++ b/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/tests/bltr.c b/tests/bltr.c
index 56b0d68..7802fa8 100644
--- a/tests/bltr.c
+++ b/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/tests/bltr_d.c b/tests/bltr_d.c
index 9ce78b6..11930ee 100644
--- a/tests/bltr_d.c
+++ b/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/tests/bltr_f.c b/tests/bltr_f.c
index 177a586..4bb3ac4 100644
--- a/tests/bltr_f.c
+++ b/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/tests/bltr_u.c b/tests/bltr_u.c
index e87a946..c73949f 100644
--- a/tests/bltr_u.c
+++ b/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/tests/bmci.c b/tests/bmci.c
index 0ffe415..8846c94 100644
--- a/tests/bmci.c
+++ b/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/tests/bmcr.c b/tests/bmcr.c
index 03591fc..ba8b246 100644
--- a/tests/bmcr.c
+++ b/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/tests/bmsi.c b/tests/bmsi.c
index 21f986f..538575f 100644
--- a/tests/bmsi.c
+++ b/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/tests/bmsr.c b/tests/bmsr.c
index cd58951..3ac320f 100644
--- a/tests/bmsr.c
+++ b/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/tests/bnei.c b/tests/bnei.c
index a34a3ad..f1ac741 100644
--- a/tests/bnei.c
+++ b/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/tests/bner.c b/tests/bner.c
index c0253a6..1f8f05d 100644
--- a/tests/bner.c
+++ b/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/tests/bner_d.c b/tests/bner_d.c
index d106ef5..afe1a36 100644
--- a/tests/bner_d.c
+++ b/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/tests/bner_f.c b/tests/bner_f.c
index 7c3753d..bc57824 100644
--- a/tests/bner_f.c
+++ b/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/tests/boaddi.c b/tests/boaddi.c
index 717c4c1..3ee3bef 100644
--- a/tests/boaddi.c
+++ b/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/tests/boaddi_u.c b/tests/boaddi_u.c
index 66b261b..c55c1f8 100644
--- a/tests/boaddi_u.c
+++ b/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/tests/boaddr.c b/tests/boaddr.c
index 95fb624..4c86c32 100644
--- a/tests/boaddr.c
+++ b/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/tests/boaddr_u.c b/tests/boaddr_u.c
index b9b2b45..9c610f5 100644
--- a/tests/boaddr_u.c
+++ b/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/tests/bordr_d.c b/tests/bordr_d.c
index 24f4214..6e220d9 100644
--- a/tests/bordr_d.c
+++ b/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/tests/bordr_f.c b/tests/bordr_f.c
index 827da92..29bf8d4 100644
--- a/tests/bordr_f.c
+++ b/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/tests/bosubi.c b/tests/bosubi.c
index b645140..ccf3581 100644
--- a/tests/bosubi.c
+++ b/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/tests/bosubi_u.c b/tests/bosubi_u.c
index 76a7d67..4b36b90 100644
--- a/tests/bosubi_u.c
+++ b/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/tests/bosubr.c b/tests/bosubr.c
index e79c10b..f77d9ba 100644
--- a/tests/bosubr.c
+++ b/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/tests/bosubr_u.c b/tests/bosubr_u.c
index ad55af3..2e9562c 100644
--- a/tests/bosubr_u.c
+++ b/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/tests/bswapr_ui.c b/tests/bswapr_ui.c
index f566ad4..2046d7f 100644
--- a/tests/bswapr_ui.c
+++ b/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/tests/bswapr_ul.c b/tests/bswapr_ul.c
index 28a2f03..1b712db 100644
--- a/tests/bswapr_ul.c
+++ b/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/tests/bswapr_us.c b/tests/bswapr_us.c
index 10028df..44302bc 100644
--- a/tests/bswapr_us.c
+++ b/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/tests/buneqr_d.c b/tests/buneqr_d.c
index 887a3dd..b24bb2b 100644
--- a/tests/buneqr_d.c
+++ b/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/tests/buneqr_f.c b/tests/buneqr_f.c
index 0671dae..2c88bf0 100644
--- a/tests/buneqr_f.c
+++ b/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/tests/bunger_d.c b/tests/bunger_d.c
index 3a22336..21f851f 100644
--- a/tests/bunger_d.c
+++ b/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/tests/bunger_f.c b/tests/bunger_f.c
index a4bd7f0..3ea27d4 100644
--- a/tests/bunger_f.c
+++ b/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/tests/bungtr_d.c b/tests/bungtr_d.c
index 780e8d0..1af8987 100644
--- a/tests/bungtr_d.c
+++ b/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/tests/bungtr_f.c b/tests/bungtr_f.c
index 4debed9..f603377 100644
--- a/tests/bungtr_f.c
+++ b/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/tests/bunler_d.c b/tests/bunler_d.c
index 868001e..d16a0dc 100644
--- a/tests/bunler_d.c
+++ b/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/tests/bunler_f.c b/tests/bunler_f.c
index 10c5d4a..56680ba 100644
--- a/tests/bunler_f.c
+++ b/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/tests/bunltr_d.c b/tests/bunltr_d.c
index 79b96a1..30b1576 100644
--- a/tests/bunltr_d.c
+++ b/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/tests/bunltr_f.c b/tests/bunltr_f.c
index 3fdd4bb..97c89a0 100644
--- a/tests/bunltr_f.c
+++ b/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/tests/bunordr_d.c b/tests/bunordr_d.c
index ef3818d..3c124f9 100644
--- a/tests/bunordr_d.c
+++ b/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/tests/bunordr_f.c b/tests/bunordr_f.c
index 3af0238..a1bd0a4 100644
--- a/tests/bunordr_f.c
+++ b/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/tests/bxaddi.c b/tests/bxaddi.c
index 16d4055..43894a2 100644
--- a/tests/bxaddi.c
+++ b/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/tests/bxaddi_u.c b/tests/bxaddi_u.c
index 6c32578..c67d40d 100644
--- a/tests/bxaddi_u.c
+++ b/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/tests/bxaddr.c b/tests/bxaddr.c
index a73a0d8..85af51d 100644
--- a/tests/bxaddr.c
+++ b/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/tests/bxaddr_u.c b/tests/bxaddr_u.c
index ba54c03..517b03f 100644
--- a/tests/bxaddr_u.c
+++ b/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/tests/bxsubi.c b/tests/bxsubi.c
index 83669ac..f6b66f8 100644
--- a/tests/bxsubi.c
+++ b/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/tests/bxsubi_u.c b/tests/bxsubi_u.c
index 5d09727..95a78df 100644
--- a/tests/bxsubi_u.c
+++ b/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/tests/bxsubr.c b/tests/bxsubr.c
index aa99db9..9f9b79c 100644
--- a/tests/bxsubr.c
+++ b/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/tests/bxsubr_u.c b/tests/bxsubr_u.c
index f476c24..0d505b0 100644
--- a/tests/bxsubr_u.c
+++ b/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/tests/comr.c b/tests/comr.c
index 608c374..4b0151a 100644
--- a/tests/comr.c
+++ b/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/tests/divr.c b/tests/divr.c
index 389a69d..4ca4904 100644
--- a/tests/divr.c
+++ b/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/tests/divr_d.c b/tests/divr_d.c
index 8597fdd..d678c73 100644
--- a/tests/divr_d.c
+++ b/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/tests/divr_f.c b/tests/divr_f.c
index dd2c633..0dcf8a6 100644
--- a/tests/divr_f.c
+++ b/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/tests/divr_u.c b/tests/divr_u.c
index 177c609..c51bbc7 100644
--- a/tests/divr_u.c
+++ b/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/tests/extr_c.c b/tests/extr_c.c
index f4390a7..834777d 100644
--- a/tests/extr_c.c
+++ b/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/tests/extr_d.c b/tests/extr_d.c
index 35d0ab3..40d20e6 100644
--- a/tests/extr_d.c
+++ b/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/tests/extr_d_f.c b/tests/extr_d_f.c
index 570bae8..83f7a86 100644
--- a/tests/extr_d_f.c
+++ b/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/tests/extr_f.c b/tests/extr_f.c
index f16cd8c..e84458c 100644
--- a/tests/extr_f.c
+++ b/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/tests/extr_f_d.c b/tests/extr_f_d.c
index 5e90be4..8f14ea4 100644
--- a/tests/extr_f_d.c
+++ b/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/tests/extr_i.c b/tests/extr_i.c
index a0ec079..1a80b5e 100644
--- a/tests/extr_i.c
+++ b/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/tests/extr_s.c b/tests/extr_s.c
index c12adb7..e4d1f1e 100644
--- a/tests/extr_s.c
+++ b/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/tests/extr_uc.c b/tests/extr_uc.c
index fb700bd..d9890c7 100644
--- a/tests/extr_uc.c
+++ b/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/tests/extr_ui.c b/tests/extr_ui.c
index 30706f0..6aa6024 100644
--- a/tests/extr_ui.c
+++ b/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/tests/extr_us.c b/tests/extr_us.c
index a10f6e9..c10567b 100644
--- a/tests/extr_us.c
+++ b/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/tests/jmpr.c b/tests/jmpr.c
index 32a7717..e81a027 100644
--- a/tests/jmpr.c
+++ b/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/tests/ldr_c.c b/tests/ldr_c.c
index d653dea..0d50d4d 100644
--- a/tests/ldr_c.c
+++ b/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/tests/ldr_d.c b/tests/ldr_d.c
index 8488fb3..5f3073a 100644
--- a/tests/ldr_d.c
+++ b/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/tests/ldr_f.c b/tests/ldr_f.c
index 160af85..c0776b6 100644
--- a/tests/ldr_f.c
+++ b/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/tests/ldr_i.c b/tests/ldr_i.c
index 956d254..ed8784a 100644
--- a/tests/ldr_i.c
+++ b/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/tests/ldr_l.c b/tests/ldr_l.c
index a1a554a..d71f3e4 100644
--- a/tests/ldr_l.c
+++ b/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/tests/ldr_s.c b/tests/ldr_s.c
index 4384c5e..af83dc7 100644
--- a/tests/ldr_s.c
+++ b/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/tests/ldr_uc.c b/tests/ldr_uc.c
index 41dad79..54a2075 100644
--- a/tests/ldr_uc.c
+++ b/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/tests/ldr_ui.c b/tests/ldr_ui.c
index 7f684f6..1867812 100644
--- a/tests/ldr_ui.c
+++ b/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/tests/ldr_us.c b/tests/ldr_us.c
index e813d65..5387882 100644
--- a/tests/ldr_us.c
+++ b/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/tests/ldxi_c.c b/tests/ldxi_c.c
index fd208cd..58d1de9 100644
--- a/tests/ldxi_c.c
+++ b/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/tests/ldxi_d.c b/tests/ldxi_d.c
index 6152923..c749920 100644
--- a/tests/ldxi_d.c
+++ b/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/tests/ldxi_f.c b/tests/ldxi_f.c
index 47afc3b..33206de 100644
--- a/tests/ldxi_f.c
+++ b/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/tests/ldxi_i.c b/tests/ldxi_i.c
index 0054718..f51bb5c 100644
--- a/tests/ldxi_i.c
+++ b/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/tests/ldxi_l.c b/tests/ldxi_l.c
index c9d07c4..9bdc655 100644
--- a/tests/ldxi_l.c
+++ b/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/tests/ldxi_s.c b/tests/ldxi_s.c
index 1639f6c..4c75cc2 100644
--- a/tests/ldxi_s.c
+++ b/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/tests/ldxi_uc.c b/tests/ldxi_uc.c
index 744768b..ebe91b4 100644
--- a/tests/ldxi_uc.c
+++ b/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/tests/ldxi_ui.c b/tests/ldxi_ui.c
index a25b1b9..ad1599f 100644
--- a/tests/ldxi_ui.c
+++ b/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/tests/ldxi_us.c b/tests/ldxi_us.c
index 1523727..a50e4ed 100644
--- a/tests/ldxi_us.c
+++ b/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/tests/ldxr_c.c b/tests/ldxr_c.c
index 238e441..dd3df16 100644
--- a/tests/ldxr_c.c
+++ b/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/tests/ldxr_d.c b/tests/ldxr_d.c
index b793637..28543b7 100644
--- a/tests/ldxr_d.c
+++ b/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/tests/ldxr_f.c b/tests/ldxr_f.c
index 8c865a9..a87f15a 100644
--- a/tests/ldxr_f.c
+++ b/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/tests/ldxr_i.c b/tests/ldxr_i.c
index fb00320..65ed039 100644
--- a/tests/ldxr_i.c
+++ b/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/tests/ldxr_l.c b/tests/ldxr_l.c
index f139e8e..d8afce5 100644
--- a/tests/ldxr_l.c
+++ b/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/tests/ldxr_s.c b/tests/ldxr_s.c
index 8ba44c1..7f0724c 100644
--- a/tests/ldxr_s.c
+++ b/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/tests/ldxr_uc.c b/tests/ldxr_uc.c
index b6a3cb1..d6dcaf9 100644
--- a/tests/ldxr_uc.c
+++ b/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/tests/ldxr_ui.c b/tests/ldxr_ui.c
index 04fcb7d..4e2d773 100644
--- a/tests/ldxr_ui.c
+++ b/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/tests/ldxr_us.c b/tests/ldxr_us.c
index 12c4d9c..78d38f5 100644
--- a/tests/ldxr_us.c
+++ b/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/tests/lshi.c b/tests/lshi.c
index 41c079a..183aed9 100644
--- a/tests/lshi.c
+++ b/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/tests/lshr.c b/tests/lshr.c
index 80edae3..5f3d5b9 100644
--- a/tests/lshr.c
+++ b/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/tests/mulr.c b/tests/mulr.c
index 4cd28e6..943b31e 100644
--- a/tests/mulr.c
+++ b/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/tests/mulr_d.c b/tests/mulr_d.c
index 0b4fa18..460b14b 100644
--- a/tests/mulr_d.c
+++ b/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/tests/mulr_f.c b/tests/mulr_f.c
index ed716fa..6189be2 100644
--- a/tests/mulr_f.c
+++ b/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/tests/negr.c b/tests/negr.c
index 5a5c5c1..974d3f0 100644
--- a/tests/negr.c
+++ b/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/tests/negr_d.c b/tests/negr_d.c
index 1af229b..566061c 100644
--- a/tests/negr_d.c
+++ b/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/tests/negr_f.c b/tests/negr_f.c
index cdc1ccd..24b509f 100644
--- a/tests/negr_f.c
+++ b/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/tests/ori.c b/tests/ori.c
index 59e91b9..ad55576 100644
--- a/tests/ori.c
+++ b/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/tests/orr.c b/tests/orr.c
index 6c98544..10b7c3d 100644
--- a/tests/orr.c
+++ b/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/tests/pushpop.c b/tests/pushpop.c
index 9a464c3..d2a4ab7 100644
--- a/tests/pushpop.c
+++ b/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/tests/qdivr.c b/tests/qdivr.c
index d6e967c..d54c3c1 100644
--- a/tests/qdivr.c
+++ b/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/tests/qdivr_u.c b/tests/qdivr_u.c
index 8b2f63e..0471e9e 100644
--- a/tests/qdivr_u.c
+++ b/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/tests/qmulr.c b/tests/qmulr.c
index a683cc4..68a2f40 100644
--- a/tests/qmulr.c
+++ b/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/tests/qmulr_u.c b/tests/qmulr_u.c
index e5e7277..f3724e5 100644
--- a/tests/qmulr_u.c
+++ b/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/tests/remr.c b/tests/remr.c
index a06e240..3c61384 100644
--- a/tests/remr.c
+++ b/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/tests/remr_u.c b/tests/remr_u.c
index 0250181..01113db 100644
--- a/tests/remr_u.c
+++ b/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/tests/rshi.c b/tests/rshi.c
index 0f2cdfd..1f1ed6d 100644
--- a/tests/rshi.c
+++ b/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/tests/rshi_u.c b/tests/rshi_u.c
index 141c41c..e78a205 100644
--- a/tests/rshi_u.c
+++ b/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/tests/rshr.c b/tests/rshr.c
index ef702b6..1a32bfd 100644
--- a/tests/rshr.c
+++ b/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/tests/rshr_u.c b/tests/rshr_u.c
index 268117f..644e717 100644
--- a/tests/rshr_u.c
+++ b/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/tests/sqrtr_d.c b/tests/sqrtr_d.c
index cb17b56..35e2230 100644
--- a/tests/sqrtr_d.c
+++ b/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/tests/sqrtr_f.c b/tests/sqrtr_f.c
index ffa9211..0c37373 100644
--- a/tests/sqrtr_f.c
+++ b/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/tests/sti_c.c b/tests/sti_c.c
index 10b7b6a..61ae9b6 100644
--- a/tests/sti_c.c
+++ b/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/tests/sti_d.c b/tests/sti_d.c
index 2c51827..c10b7b7 100644
--- a/tests/sti_d.c
+++ b/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/tests/sti_f.c b/tests/sti_f.c
index 1e3674a..2401526 100644
--- a/tests/sti_f.c
+++ b/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/tests/sti_i.c b/tests/sti_i.c
index b0e6d83..c8bb72e 100644
--- a/tests/sti_i.c
+++ b/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/tests/sti_l.c b/tests/sti_l.c
index e997b01..5bd4ed1 100644
--- a/tests/sti_l.c
+++ b/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/tests/sti_s.c b/tests/sti_s.c
index 95cfd33..4d4b272 100644
--- a/tests/sti_s.c
+++ b/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/tests/str_c.c b/tests/str_c.c
index eb04a85..f8d7d75 100644
--- a/tests/str_c.c
+++ b/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/tests/str_d.c b/tests/str_d.c
index 04e5aed..817fd64 100644
--- a/tests/str_d.c
+++ b/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/tests/str_f.c b/tests/str_f.c
index 167fac0..22af0d5 100644
--- a/tests/str_f.c
+++ b/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/tests/str_i.c b/tests/str_i.c
index 7dd6d8c..3872ed7 100644
--- a/tests/str_i.c
+++ b/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/tests/str_l.c b/tests/str_l.c
index 8a1b905..0b4755c 100644
--- a/tests/str_l.c
+++ b/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/tests/str_s.c b/tests/str_s.c
index 97932ad..0044d82 100644
--- a/tests/str_s.c
+++ b/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/tests/stxi_c.c b/tests/stxi_c.c
index 1a87743..c38e529 100644
--- a/tests/stxi_c.c
+++ b/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/tests/stxi_d.c b/tests/stxi_d.c
index a9de3d2..cf68704 100644
--- a/tests/stxi_d.c
+++ b/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/tests/stxi_f.c b/tests/stxi_f.c
index a348249..cec7fba 100644
--- a/tests/stxi_f.c
+++ b/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/tests/stxi_i.c b/tests/stxi_i.c
index c39adc2..d0aef11 100644
--- a/tests/stxi_i.c
+++ b/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/tests/stxi_l.c b/tests/stxi_l.c
index b280c4d..f731ee4 100644
--- a/tests/stxi_l.c
+++ b/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/tests/stxi_s.c b/tests/stxi_s.c
index 09af31e..4deb826 100644
--- a/tests/stxi_s.c
+++ b/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/tests/stxr_c.c b/tests/stxr_c.c
index 14e40c7..bcebb35 100644
--- a/tests/stxr_c.c
+++ b/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/tests/stxr_d.c b/tests/stxr_d.c
index 8f1d957..ba4988a 100644
--- a/tests/stxr_d.c
+++ b/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/tests/stxr_f.c b/tests/stxr_f.c
index 7de5771..30c1e92 100644
--- a/tests/stxr_f.c
+++ b/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/tests/stxr_i.c b/tests/stxr_i.c
index b613ec0..247cab2 100644
--- a/tests/stxr_i.c
+++ b/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/tests/stxr_l.c b/tests/stxr_l.c
index 0fd239c..e680238 100644
--- a/tests/stxr_l.c
+++ b/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/tests/stxr_s.c b/tests/stxr_s.c
index 926da56..02d8483 100644
--- a/tests/stxr_s.c
+++ b/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/tests/subr.c b/tests/subr.c
index a375dff..0ed2e32 100644
--- a/tests/subr.c
+++ b/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/tests/subr_d.c b/tests/subr_d.c
index 94c5ea4..71259a8 100644
--- a/tests/subr_d.c
+++ b/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/tests/subr_f.c b/tests/subr_f.c
index fd6b377..410dc26 100644
--- a/tests/subr_f.c
+++ b/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/tests/subx.c b/tests/subx.c
index f287399..91f1f95 100644
--- a/tests/subx.c
+++ b/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/tests/truncr_d_i.c b/tests/truncr_d_i.c
index c703ae8..12aaa91 100644
--- a/tests/truncr_d_i.c
+++ b/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/tests/truncr_d_l.c b/tests/truncr_d_l.c
index 752a76f..1f5dc99 100644
--- a/tests/truncr_d_l.c
+++ b/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/tests/truncr_f_i.c b/tests/truncr_f_i.c
index 32fd71f..077d7be 100644
--- a/tests/truncr_f_i.c
+++ b/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/tests/truncr_f_l.c b/tests/truncr_f_l.c
index af3a116..c5a86f8 100644
--- a/tests/truncr_f_l.c
+++ b/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/tests/xori.c b/tests/xori.c
index 59859fc..5884025 100644
--- a/tests/xori.c
+++ b/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/tests/xorr.c b/tests/xorr.c
index 1be654b..c249466 100644
--- a/tests/xorr.c
+++ b/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);
- [Guile-commits] branch lightening updated (b35662f -> 9a32b4b), Andy Wingo, 2019/04/24
- [Guile-commits] 02/09: Add support for "make test-ia32" in tests/, Andy Wingo, 2019/04/24
- [Guile-commits] 08/09: Merge from upstream lightening, Andy Wingo, 2019/04/24
- [Guile-commits] 07/09: Add support for operand addends, Andy Wingo, 2019/04/24
- [Guile-commits] 05/09: Merge from upstream lightening, Andy Wingo, 2019/04/24
- [Guile-commits] 01/09: Allow test suite to test multiple targets., Andy Wingo, 2019/04/24
- [Guile-commits] 09/09: Adapt to new lightening call API, Andy Wingo, 2019/04/24
- [Guile-commits] 03/09: Fix lightening name, Andy Wingo, 2019/04/24
- [Guile-commits] 06/09: Add proper parallel-moves solver, Andy Wingo, 2019/04/24
- [Guile-commits] 04/09: Simplify API for loading call arguments,
Andy Wingo <=