mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-20 11:40:18 +02:00
Code Activity

Simplify API for loading call arguments

Browse source
This commit is contained in:
Andy Wingo 2019-04-18 17:47:01 +02:00
parent 668196aa27
commit 0be4f7a2a1
183 changed files with 641 additions and 1498 deletions
Download patch file Download diff file Expand all files Collapse all files

167
lightening.h
View file

@ -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)

5
lightening/lightening.c
View file

@ -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;
}

377
lightening/x86.c
View file

@ -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<argc; j++)
if (args[j].kind == JIT_ARG_LOC_GPR && rn(args[j].loc.gpr) == rn(dst))
if (args[j].kind == JIT_OPERAND_KIND_GPR && rn(args[j].loc.gpr) == rn(dst))
{
xchgr(_jit, rn(args[idx].loc.gpr), rn(dst));
args[j].loc.gpr = args[idx].loc.gpr;
@ -703,7 +691,7 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
/* Could be this register holds a value for more than one argument;
update subsequent args if any. */
for (size_t k=j+1; k<argc; k++)
if (args[k].kind == JIT_ARG_LOC_GPR && rn(args[k].loc.gpr) == rn(dst))
if (args[k].kind == JIT_OPERAND_KIND_GPR && rn(args[k].loc.gpr) == rn(dst))
args[k].loc.gpr = args[j].loc.gpr;
return;
}
@ -716,9 +704,9 @@ shuffle_gpr_arg(jit_state_t *_jit, jit_gpr_t dst, size_t argc,
static void
shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
jit_arg_t *args, size_t idx)
jit_operand_t *args, size_t idx)
{
ASSERT(args[idx].kind == JIT_ARG_LOC_FPR);
ASSERT(args[idx].kind == JIT_OPERAND_KIND_FPR);
if (rn(args[idx].loc.fpr) == rn(dst))
return;
@ -726,7 +714,7 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
/* Arg in a reg but it's not the right one. See if this reg
holds some other arg, and swap if so. */
for (size_t j=idx+1; j<argc; j++)
if (args[j].kind == JIT_ARG_LOC_FPR && rn(args[j].loc.fpr) == rn(dst))
if (args[j].kind == JIT_OPERAND_KIND_FPR && rn(args[j].loc.fpr) == rn(dst))
{
jit_fpr_t tmp = get_temp_xpr(_jit);
jit_movr_d (_jit, tmp, args[idx].loc.fpr);
@ -738,7 +726,7 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
/* Could be this register holds a value for more than one argument;
update subsequent args if any. */
for (size_t k=j+1; k<argc; k++)
if (args[k].kind == JIT_ARG_LOC_FPR && rn(args[k].loc.fpr) == rn(dst))
if (args[k].kind == JIT_OPERAND_KIND_FPR && rn(args[k].loc.fpr) == rn(dst))
args[k].loc.fpr = args[j].loc.fpr;
return;
}
@ -750,14 +738,13 @@ shuffle_fpr_arg(jit_state_t *_jit, jit_fpr_t dst, size_t argc,
}
static void
prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
jit_arg_t args[])
prepare_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
{
jit_arg_t scratch;
jit_operand_t scratch;
struct abi_arg_iterator iter;
// Compute stack arg size.
reset_abi_arg_iterator(&iter, argc, abi);
reset_abi_arg_iterator(&iter, argc, args);
for (size_t i = 0; i < argc; i++)
next_abi_arg(&iter, &scratch);
@ -767,12 +754,12 @@ prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
{
size_t stack_size = iter.stack_size;
subi(_jit, _RSP_REGNO, _RSP_REGNO, stack_size);
reset_abi_arg_iterator(&iter, argc, abi);
reset_abi_arg_iterator(&iter, argc, args);
for (size_t i = 0; i < argc; i++) {
next_abi_arg(&iter, &scratch);
if (scratch.kind == JIT_ARG_LOC_MEM)
store_mem_abi_arg(_jit, abi[i], &args[i],
scratch.loc.mem.base, scratch.loc.mem.offset);
if (scratch.kind == JIT_OPERAND_KIND_MEM)
store_mem_abi_arg(_jit, &args[i], scratch.loc.mem.base,
scratch.loc.mem.offset);
}
}
@ -781,18 +768,18 @@ prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
// register for the correponding ABI argument. Note that there may be ABI
// register arguments whose values are still in memory or as immediates; we
// will load them later.
reset_abi_arg_iterator(&iter, argc, abi);
reset_abi_arg_iterator(&iter, argc, args);
for (size_t i = 0; i < argc; i++)
{
next_abi_arg(&iter, &scratch);
switch (scratch.kind) {
case JIT_ARG_LOC_GPR:
if (args[i].kind == JIT_ARG_LOC_GPR)
case JIT_OPERAND_KIND_GPR:
if (args[i].kind == JIT_OPERAND_KIND_GPR)
shuffle_gpr_arg(_jit, scratch.loc.gpr, argc, args, i);
break;
case JIT_ARG_LOC_FPR:
if (args[i].kind == JIT_ARG_LOC_FPR)
case JIT_OPERAND_KIND_FPR:
if (args[i].kind == JIT_OPERAND_KIND_FPR)
shuffle_fpr_arg(_jit, scratch.loc.fpr, argc, args, i);
break;
@ -803,31 +790,31 @@ prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
// The only thing that's left is ABI register arguments whose values are still
// in memory or immediates; load them now.
reset_abi_arg_iterator(&iter, argc, abi);
reset_abi_arg_iterator(&iter, argc, args);
for (size_t i = 0; i < argc; i++)
{
next_abi_arg(&iter, &scratch);
switch (scratch.kind) {
case JIT_ARG_LOC_GPR:
if (args[i].kind == JIT_ARG_LOC_MEM) {
abi_mem_to_gpr(_jit, abi[i], scratch.loc.gpr, args[i].loc.mem.base,
args[i].loc.mem.offset);
args[i].kind = JIT_ARG_LOC_GPR;
case JIT_OPERAND_KIND_GPR:
if (args[i].kind == JIT_OPERAND_KIND_MEM) {
abi_mem_to_gpr(_jit, args[i].abi, scratch.loc.gpr,
args[i].loc.mem.base, args[i].loc.mem.offset);
args[i].kind = JIT_OPERAND_KIND_GPR;
args[i].loc.gpr = scratch.loc.gpr;
} else if (args[i].kind == JIT_ARG_LOC_IMM) {
abi_imm_to_gpr(_jit, abi[i], scratch.loc.gpr, args[i].loc.imm);
args[i].kind = JIT_ARG_LOC_GPR;
} else if (args[i].kind == JIT_OPERAND_KIND_IMM) {
abi_imm_to_gpr(_jit, args[i].abi, scratch.loc.gpr, args[i].loc.imm);
args[i].kind = JIT_OPERAND_KIND_GPR;
args[i].loc.gpr = scratch.loc.gpr;
}
break;
case JIT_ARG_LOC_FPR:
if (args[i].kind == JIT_ARG_LOC_MEM) {
abi_mem_to_fpr(_jit, abi[i], scratch.loc.fpr, args[i].loc.mem.base,
args[i].loc.mem.offset);
args[i].kind = JIT_ARG_LOC_FPR;
case JIT_OPERAND_KIND_FPR:
if (args[i].kind == JIT_OPERAND_KIND_MEM) {
abi_mem_to_fpr(_jit, args[i].abi, scratch.loc.fpr,
args[i].loc.mem.base, args[i].loc.mem.offset);
args[i].kind = JIT_OPERAND_KIND_FPR;
args[i].loc.fpr = scratch.loc.fpr;
} else if (args[i].kind == JIT_ARG_LOC_IMM) {
} else if (args[i].kind == JIT_OPERAND_KIND_IMM) {
/* Currently unsupported. */
abort ();
}
@ -841,13 +828,13 @@ prepare_args(jit_state_t *_jit, size_t argc, const jit_arg_abi_t abi[],
static void
cleanup_stack_after_call(jit_state_t *_jit, size_t argc,
const jit_arg_abi_t abi[])
const jit_operand_t args[])
{
jit_arg_t scratch;
jit_operand_t scratch;
struct abi_arg_iterator iter;
// Compute stack arg size.
reset_abi_arg_iterator(&iter, argc, abi);
reset_abi_arg_iterator(&iter, argc, args);
for (size_t i = 0; i < argc; i++)
next_abi_arg(&iter, &scratch);
@ -856,71 +843,105 @@ cleanup_stack_after_call(jit_state_t *_jit, size_t argc,
}
void
jit_calli(jit_state_t *_jit, jit_pointer_t f,
size_t argc, const jit_arg_abi_t abi[], jit_arg_t args[])
jit_calli(jit_state_t *_jit, jit_pointer_t f, size_t argc, jit_operand_t args[])
{
prepare_args(_jit, argc, abi, args);
prepare_args(_jit, argc, args);
calli(_jit, (jit_word_t)f);
cleanup_stack_after_call(_jit, argc, abi);
cleanup_stack_after_call(_jit, argc, args);
}
void
jit_callr(jit_state_t *_jit, jit_gpr_t f,
size_t argc, const jit_arg_abi_t abi[], jit_arg_t args[])
jit_callr(jit_state_t *_jit, jit_gpr_t f, size_t argc, jit_operand_t args[])
{
prepare_args(_jit, argc, abi, args);
prepare_args(_jit, argc, args);
callr(_jit, rn(f));
cleanup_stack_after_call(_jit, argc, abi);
cleanup_stack_after_call(_jit, argc, args);
}
void
jit_receive(jit_state_t *_jit,
size_t argc, const jit_arg_abi_t abi[], jit_arg_t args[])
jit_locate_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
{
struct abi_arg_iterator iter;
reset_abi_arg_iterator(&iter, argc, abi);
reset_abi_arg_iterator(&iter, argc, args);
for (size_t i = 0; i < argc; i++)
next_abi_arg(&iter, &args[i]);
}
/* Precondition: args are distinct locations. No JIT_OPERAND_KIND_MEM
element of args aliases stack-spilled args. */
void
jit_load_args(jit_state_t *_jit, size_t argc,
const jit_arg_abi_t abi[], jit_arg_t args[],
const jit_anyreg_t regs[])
jit_load_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
{
jit_operand_t scratch[argc];
memcpy(scratch, args, sizeof(scratch[0]) * argc);
jit_locate_args(_jit, argc, scratch);
/* First shuffle any arguments that are already in registers into
position. */
for (size_t i = 0; i < argc; i++) {
switch (args[i].kind) {
case JIT_ARG_LOC_IMM:
switch (scratch[i].kind) {
case JIT_OPERAND_KIND_IMM:
abort();
case JIT_ARG_LOC_GPR:
shuffle_gpr_arg(_jit, regs[i].gpr, argc, args, i);
case JIT_OPERAND_KIND_GPR:
switch (args[i].kind) {
case JIT_OPERAND_KIND_GPR:
shuffle_gpr_arg(_jit, args[i].loc.gpr, argc, scratch, i);
break;
case JIT_OPERAND_KIND_MEM:
store_mem_abi_arg(_jit, &scratch[i], args[i].loc.mem.base,
args[i].loc.mem.offset);
break;
default:
abort();
}
break;
case JIT_ARG_LOC_FPR:
shuffle_fpr_arg(_jit, regs[i].fpr, argc, args, i);
case JIT_OPERAND_KIND_FPR:
switch (args[i].kind) {
case JIT_OPERAND_KIND_FPR:
shuffle_fpr_arg(_jit, args[i].loc.fpr, argc, scratch, i);
break;
case JIT_OPERAND_KIND_MEM:
store_mem_abi_arg(_jit, &scratch[i], args[i].loc.mem.base,
args[i].loc.mem.offset);
break;
default:
abort();
}
break;
case JIT_ARG_LOC_MEM:
case JIT_OPERAND_KIND_MEM:
break;
default:
abort();
}
}
/* Now load spilled arguments from memory into registers. */
/* Now shuffle spilled arguments from memory into place (memory or
registers). */
for (size_t i = 0; i < argc; i++) {
if (args[i].kind == JIT_ARG_LOC_MEM) {
if (is_gpr_arg(abi[i]))
abi_mem_to_gpr(_jit, abi[i], regs[i].gpr, args[i].loc.mem.base,
args[i].loc.mem.offset);
else
abi_mem_to_fpr(_jit, abi[i], regs[i].fpr, args[i].loc.mem.base,
args[i].loc.mem.offset);
if (args[i].kind == JIT_OPERAND_KIND_MEM) {
switch (args[i].kind) {
case JIT_OPERAND_KIND_GPR:
abi_mem_to_gpr(_jit, args[i].kind, args[i].loc.gpr,
scratch[i].loc.mem.base, scratch[i].loc.mem.offset);
break;
case JIT_OPERAND_KIND_FPR:
abi_mem_to_fpr(_jit, args[i].kind, args[i].loc.fpr,
scratch[i].loc.mem.base, scratch[i].loc.mem.offset);
break;
case JIT_OPERAND_KIND_MEM:
store_mem_abi_arg(_jit, &scratch[i], args[i].loc.mem.base,
args[i].loc.mem.offset);
break;
default:
abort();
}
}
}
}

8
tests/absr_d.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
jit_absr_d(j, JIT_F0, JIT_F0);
jit_retr_d(j, JIT_F0);

8
tests/absr_f.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
jit_absr_f(j, JIT_F0, JIT_F0);
jit_retr_f(j, JIT_F0);

8
tests/addi.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_addi(j, JIT_R0, JIT_R0, 69);
jit_retr(j, JIT_R0);

9
tests/addr.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_addr(j, JIT_R0, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);

9
tests/addr_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_addr_d(j, JIT_F0, JIT_F0, JIT_F1);
jit_retr_d(j, JIT_F0);

9
tests/addr_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_addr_f(j, JIT_F0, JIT_F0, JIT_F1);
jit_retr_f(j, JIT_F0);

8
tests/addx.c
View file

@ -4,13 +4,9 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_movi(j, JIT_R2, 0);
jit_addcr(j, JIT_R0, JIT_R0, JIT_R1);
jit_addxi(j, JIT_R2, JIT_R2, 0);

8
tests/andi.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_andi(j, JIT_R0, JIT_R0, 1);
jit_retr(j, JIT_R0);

9
tests/andr.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_andr(j, JIT_R0, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);

8
tests/beqi.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_beqi(j, JIT_R0, 0);
jit_reti(j, 0);

9
tests/beqr.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_beqr(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

9
tests/beqr_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_beqr_d(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/beqr_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_beqr_f(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

8
tests/bgei.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_bgei(j, JIT_R0, 0);
jit_reti(j, 0);

8
tests/bgei_u.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_bgei_u(j, JIT_R0, 0);
jit_reti(j, 0);

9
tests/bger.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bger(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

9
tests/bger_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bger_d(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bger_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bger_f(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bger_u.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bger_u(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

8
tests/bgti.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_bgti(j, JIT_R0, 0);
jit_reti(j, 0);

8
tests/bgti_u.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_bgti_u(j, JIT_R0, 0);
jit_reti(j, 0);

9
tests/bgtr.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bgtr(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

9
tests/bgtr_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bgtr_d(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bgtr_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bgtr_f(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bgtr_u.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bgtr_u(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

8
tests/blei.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_blei(j, JIT_R0, 0);
jit_reti(j, 0);

8
tests/blei_u.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_blei_u(j, JIT_R0, 0);
jit_reti(j, 0);

9
tests/bler.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bler(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

9
tests/bler_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bler_d(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bler_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bler_f(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bler_u.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bler_u(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

9
tests/bltgtr_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bltgtr_d(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bltgtr_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bltgtr_f(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

8
tests/blti.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_blti(j, JIT_R0, 0);
jit_reti(j, 0);

8
tests/blti_u.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_blti_u(j, JIT_R0, 0);
jit_reti(j, 0);

9
tests/bltr.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bltr(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

9
tests/bltr_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bltr_d(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bltr_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bltr_f(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bltr_u.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bltr_u(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

8
tests/bmci.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_bmci(j, JIT_R0, 1);
jit_reti(j, 0);

9
tests/bmcr.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bmcr(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

8
tests/bmsi.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_bmsi(j, JIT_R0, 1);
jit_reti(j, 0);

9
tests/bmsr.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bmsr(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

8
tests/bnei.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_reloc_t r = jit_bnei(j, JIT_R0, 0);
jit_reti(j, 0);

9
tests/bner.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_reloc_t r = jit_bner(j, JIT_R0, JIT_R1);
jit_reti(j, 0);

9
tests/bner_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bner_d(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bner_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bner_f(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

7
tests/boaddi.c
View file

@ -6,13 +6,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_reloc_t r = jit_boaddi(j, JIT_R0, 1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);

7
tests/boaddi_u.c
View file

@ -6,13 +6,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_reloc_t r = jit_boaddi_u(j, JIT_R0, 1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);

8
tests/boaddr.c
View file

@ -6,13 +6,9 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_reloc_t r = jit_boaddr(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);

8
tests/boaddr_u.c
View file

@ -6,13 +6,9 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_reloc_t r = jit_boaddr_u(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);

9
tests/bordr_d.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_DOUBLE, JIT_ARG_ABI_DOUBLE };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bordr_d(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

9
tests/bordr_f.c
View file

@ -4,13 +4,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_FLOAT, JIT_ARG_ABI_FLOAT };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .fpr=JIT_F0 }, { .fpr=JIT_F1 } };
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bordr_f(j, JIT_F0, JIT_F1);
jit_reti(j, 0);

7
tests/bosubi.c
View file

@ -6,13 +6,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_reloc_t r = jit_bosubi(j, JIT_R0, 1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);

7
tests/bosubi_u.c
View file

@ -6,13 +6,8 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_reloc_t r = jit_bosubi_u(j, JIT_R0, 1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);

8
tests/bosubr.c
View file

@ -6,13 +6,9 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_reloc_t r = jit_bosubr(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);

8
tests/bosubr_u.c
View file

@ -6,13 +6,9 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_reloc_t r = jit_bosubr_u(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);

8
tests/bswapr_ui.c
View file

@ -4,13 +4,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_bswapr_ui(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);

8
tests/bswapr_ul.c
View file

@ -5,13 +5,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
#if __WORDSIZE > 32
jit_begin(j, arena_base, arena_size);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R1 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_bswapr_ul(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);

8
tests/bswapr_us.c
View file

@ -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);

9
tests/buneqr_d.c
View file

@ -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);

9
tests/buneqr_f.c
View file

@ -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);

9
tests/bunger_d.c
View file

@ -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);

9
tests/bunger_f.c
View file

@ -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);

9
tests/bungtr_d.c
View file

@ -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);

9
tests/bungtr_f.c
View file

@ -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);

9
tests/bunler_d.c
View file

@ -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);

9
tests/bunler_f.c
View file

@ -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);

9
tests/bunltr_d.c
View file

@ -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);

9
tests/bunltr_f.c
View file

@ -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);

9
tests/bunordr_d.c
View file

@ -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);

9
tests/bunordr_f.c
View file

@ -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);

7
tests/bxaddi.c
View file

@ -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);

7
tests/bxaddi_u.c
View file

@ -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);

8
tests/bxaddr.c
View file

@ -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);

8
tests/bxaddr_u.c
View file

@ -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);

7
tests/bxsubi.c
View file

@ -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);

7
tests/bxsubi_u.c
View file

@ -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);

8
tests/bxsubr.c
View file

@ -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);

8
tests/bxsubr_u.c
View file

@ -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);

8
tests/comr.c
View file

@ -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);

9
tests/divr.c
View file

@ -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);

9
tests/divr_d.c
View file

@ -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);

9
tests/divr_f.c
View file

@ -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);

9
tests/divr_u.c
View file

@ -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);

8
tests/extr_c.c
View file

@ -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);

8
tests/extr_d.c
View file

@ -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);

8
tests/extr_d_f.c
View file

@ -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);

8
tests/extr_f.c
View file

@ -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);

8
tests/extr_f_d.c
View file

@ -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);

8
tests/extr_i.c
View file

@ -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);

8
tests/extr_s.c
View file

@ -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);

8
tests/extr_uc.c
View file

@ -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);

8
tests/extr_ui.c
View file

@ -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);

8
tests/extr_us.c
View file

@ -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);

8
tests/jmpr.c
View file

@ -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);

8
tests/ldr_c.c
View file

@ -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);

Some files were not shown because too many files have changed in this diff Show more