From 0be4f7a2a1a5ed8bb972f5489013e914d941718d Mon Sep 17 00:00:00 2001 From: Andy Wingo Date: Thu, 18 Apr 2019 17:47:01 +0200 Subject: [PATCH] Simplify API for loading call arguments --- lightening.h | 167 ++++++++++++++---- lightening/lightening.c | 5 +- lightening/x86.c | 377 +++++++++++++++++++++------------------- 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 ba56513f6..20a14412b 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; + JIT_OPERAND_KIND_IMM, + JIT_OPERAND_KIND_GPR, + JIT_OPERAND_KIND_FPR, + JIT_OPERAND_KIND_MEM +}; -typedef struct jit_arg +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 14c8426cb..d3494fd14 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 0ec8c2f84..b8d1150d9 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 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++; #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++]; -#ifdef __CYGWIN__ - 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); - } + *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 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 10028dfb7..44302bc02 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 887a3ddc2..b24bb2b89 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 0671daeb1..2c88bf043 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 3a22336ca..21f851ff6 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 a4bd7f0df..3ea27d408 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 780e8d0b2..1af89877d 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 4debed9f7..f60337766 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 868001eb2..d16a0dc97 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 10c5d4abd..56680bab4 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 79b96a1c7..30b157698 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 3fdd4bb15..97c89a08c 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 ef3818d51..3c124f964 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 3af023862..a1bd0a41c 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 16d405524..43894a294 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 6c3257876..c67d40d1d 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 a73a0d8eb..85af51d49 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 ba54c0391..517b03fa1 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 83669ac12..f6b66f8eb 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 5d0972706..95a78df67 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 aa99db9c4..9f9b79cad 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 f476c247a..0d505b0cf 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 608c374c1..4b0151a5d 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 389a69d15..4ca4904ef 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 8597fdda0..d678c7370 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 dd2c63317..0dcf8a618 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 177c6098c..c51bbc786 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 f4390a789..834777d69 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 35d0ab3b7..40d20e6d1 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 570bae814..83f7a86f0 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 f16cd8ca3..e84458c16 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 5e90be41b..8f14ea4ff 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 a0ec07916..1a80b5e38 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 c12adb722..e4d1f1eb1 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 fb700bd36..d9890c788 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 30706f093..6aa6024bb 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 a10f6e916..c10567b4f 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 32a771791..e81a02759 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 d653dea3b..0d50d4d59 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 8488fb30f..5f3073ada 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 160af85a4..c0776b6d3 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 956d254ac..ed8784a40 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 a1a554a57..d71f3e47e 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 4384c5e00..af83dc7e6 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 41dad79ca..54a207531 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 7f684f685..1867812b4 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 e813d650d..5387882a6 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 fd208cd58..58d1de9d4 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 61529233d..c74992069 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 47afc3bed..33206debb 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 005471838..f51bb5cfd 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 c9d07c4c9..9bdc6559c 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 1639f6c22..4c75cc2b1 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 744768b99..ebe91b46a 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 a25b1b998..ad1599f65 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 1523727ec..a50e4edc1 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 238e441cf..dd3df16ff 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 b79363730..28543b7c6 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 8c865a9b2..a87f15acd 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 fb003204b..65ed0395b 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 f139e8e00..d8afce547 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 8ba44c1ff..7f0724c27 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 b6a3cb142..d6dcaf979 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 04fcb7d77..4e2d773be 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 12c4d9ca1..78d38f5ef 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 41c079a33..183aed9ff 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 80edae3b3..5f3d5b96e 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 4cd28e618..943b31e01 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 0b4fa18ad..460b14baf 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 ed716fa5f..6189be263 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 5a5c5c1d2..974d3f0e9 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 1af229be6..566061c46 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 cdc1ccdcc..24b509f41 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 59e91b95a..ad555769d 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 6c98544b4..10b7c3d17 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 9a464c3ed..d2a4ab7bb 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 d6e967c13..d54c3c181 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 8b2f63ee3..0471e9ed2 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 a683cc4e0..68a2f40dd 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 e5e727788..f3724e543 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 a06e2407f..3c61384b6 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 025018142..01113dbef 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 0f2cdfda7..1f1ed6d94 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 141c41c09..e78a205b8 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 ef702b630..1a32bfd03 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 268117fe5..644e71728 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 cb17b56ac..35e2230a7 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 ffa9211af..0c3737337 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 10b7b6a91..61ae9b69d 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 2c51827f5..c10b7b7dd 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 1e3674a4f..240152654 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 b0e6d83f7..c8bb72e73 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 e997b014f..5bd4ed19f 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 95cfd3396..4d4b27212 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 eb04a85df..f8d7d7543 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 04e5aed57..817fd64a2 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 167fac038..22af0d580 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 7dd6d8c78..3872ed771 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 8a1b905ea..0b4755c24 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 97932ad31..0044d8286 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 1a877434f..c38e5292e 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 a9de3d23d..cf68704cc 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 a348249ea..cec7fba69 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 c39adc2cd..d0aef1116 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 b280c4d72..f731ee49b 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 09af31ea6..4deb826e6 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 14e40c787..bcebb3530 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 8f1d957d7..ba4988a8d 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 7de57715c..30c1e92de 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 b613ec00a..247cab215 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 0fd239cc7..e680238c5 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 926da5694..02d848382 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 a375dff93..0ed2e320b 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 94c5ea477..71259a8e3 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 fd6b37777..410dc265d 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 f28739965..91f1f9565 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 c703ae8ba..12aaa917d 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 752a76fa0..1f5dc995e 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 32fd71fdf..077d7bec8 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 af3a1168e..c5a86f89b 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 59859fc29..5884025d6 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 1be654b09..c24946638 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);