dmbcs/guile
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Simplify API for loading call arguments

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

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

8
tests/ldr_d.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_d(j, JIT_F0, JIT_R1);
jit_retr_d(j, JIT_F0);

8
tests/ldr_f.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_f(j, JIT_F0, JIT_R1);
jit_retr_f(j, JIT_F0);

8
tests/ldr_i.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_i(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