mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-06-25 04:40:19 +02:00
Code Activity

Add {enter,leave}_jit_abi calls in tests

Browse source 
This saves and restores RBP on x86-32.
This commit is contained in:
Andy Wingo 2019-04-27 22:54:38 +02:00
parent 81ba8830a2
commit d11864f098
188 changed files with 438 additions and 8 deletions
Download patch file Download diff file Expand all files Collapse all files

2
tests/absr_d.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
jit_absr_d(j, JIT_F0, JIT_F0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0);
double (*f)(double) = jit_end(j, NULL);

2
tests/absr_f.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
jit_absr_f(j, JIT_F0, JIT_F0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0);
float (*f)(float) = jit_end(j, NULL);

2
tests/addi.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_addi(j, JIT_R0, JIT_R0, 69);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;

2
tests/addr.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_addr(j, JIT_R0, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;

2
tests/addr_d.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0);
size_t size = 0;

2
tests/addr_f.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0);
size_t size = 0;

2
tests/addx.c
View file

@ -4,12 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_movi(j, JIT_R2, 0);
jit_addcr(j, JIT_R0, JIT_R0, JIT_R1);
jit_addxi(j, JIT_R2, JIT_R2, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R2);
size_t size = 0;

2
tests/andi.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_andi(j, JIT_R0, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;

2
tests/andr.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_andr(j, JIT_R0, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;

3
tests/beqi.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_beqi(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/beqr.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_beqr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/beqr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/beqr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bgei.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bgei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bgei_u.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bgei_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bger.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bger(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bger_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bger_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bger_u.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bger_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bgti.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bgti(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bgti_u.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bgti_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bgtr.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bgtr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bgtr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bgtr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bgtr_u.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bgtr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/blei.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_blei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/blei_u.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_blei_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bler.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bler(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bler_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bler_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bler_u.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bler_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bltgtr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bltgtr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/blti.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_blti(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/blti_u.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_blti_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bltr.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bltr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bltr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bltr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bltr_u.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bltr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bmci.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bmci(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bmcr.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bmcr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bmsi.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bmsi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bmsr.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bmsr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bnei.c
View file

@ -4,11 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bnei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bner.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bner(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bner_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bner_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/boaddi.c
View file

@ -6,12 +6,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_boaddi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/boaddi_u.c
View file

@ -6,12 +6,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_boaddi_u(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/boaddr.c
View file

@ -6,13 +6,16 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_boaddr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/boaddr_u.c
View file

@ -6,13 +6,16 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_boaddr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bordr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bordr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bosubi.c
View file

@ -6,12 +6,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bosubi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bosubi_u.c
View file

@ -6,12 +6,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bosubi_u(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

3
tests/bosubr.c
View file

@ -6,13 +6,16 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bosubr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

3
tests/bosubr_u.c
View file

@ -6,13 +6,16 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bosubr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

2
tests/bswapr_ui.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_ui(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

2
tests/bswapr_ul.c
View file

@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
#if __WORDSIZE > 32
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_ul(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

2
tests/bswapr_us.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_us(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

3
tests/buneqr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/buneqr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bunger_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bunger_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bungtr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bungtr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bunler_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bunler_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bunltr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bunltr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

3
tests/bunordr_d.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(double, double) = jit_end(j, NULL);

3
tests/bunordr_f.c
View file

@ -4,12 +4,15 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
jit_word_t (*f)(float, float) = jit_end(j, NULL);

2
tests/bxaddi.c
View file

@ -6,11 +6,13 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bxaddi(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

2
tests/bxaddi_u.c
View file

@ -6,11 +6,13 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bxaddi_u(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

2
tests/bxaddr.c
View file

@ -6,12 +6,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bxaddr(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

2
tests/bxaddr_u.c
View file

@ -6,12 +6,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bxaddr_u(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

2
tests/bxsubi.c
View file

@ -6,11 +6,13 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bxsubi(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

2
tests/bxsubi_u.c
View file

@ -6,11 +6,13 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bxsubi_u(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

2
tests/bxsubr.c
View file

@ -6,12 +6,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bxsubr(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

2
tests/bxsubr_u.c
View file

@ -6,12 +6,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bxsubr_u(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);

2
tests/comr.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_comr(j, JIT_R0, JIT_R0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);

2
tests/divr.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_divr(j, JIT_R0, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;

2
tests/divr_d.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0);
size_t size = 0;

2
tests/divr_f.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
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_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0);
size_t size = 0;

2
tests/divr_u.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_divr_u(j, JIT_R0, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;

2
tests/extr_c.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_c(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

2
tests/extr_d.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_extr_d(j, JIT_F0, JIT_R0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0);
double (*f)(jit_word_t) = jit_end(j, NULL);

2
tests/extr_d_f.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
jit_extr_d_f(j, JIT_F0, JIT_F0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0);
float (*f)(double) = jit_end(j, NULL);

2
tests/extr_f.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_extr_f(j, JIT_F0, JIT_R0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0);
float (*f)(jit_word_t) = jit_end(j, NULL);

2
tests/extr_f_d.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
jit_extr_f_d(j, JIT_F0, JIT_F0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0);
double (*f)(float) = jit_end(j, NULL);

2
tests/extr_i.c
View file

@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
#if __WORDSIZE > 32
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_i(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

2
tests/extr_s.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_s(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

2
tests/extr_uc.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_uc(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

2
tests/extr_ui.c
View file

@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
#if __WORDSIZE > 32
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_ui(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

2
tests/extr_us.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_us(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);

2
tests/ldi_c.c
View file

@ -6,8 +6,10 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_ldi_c(j, JIT_R0, &data[0]);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(void) = jit_end(j, NULL);

2
tests/ldi_d.c
View file

@ -6,8 +6,10 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_ldi_d(j, JIT_F0, &data);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0);
double (*f)(void) = jit_end(j, NULL);

2
tests/ldi_f.c
View file

@ -6,8 +6,10 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_ldi_f(j, JIT_F0, &data);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0);
float (*f)(void) = jit_end(j, NULL);

2
tests/ldi_i.c
View file

@ -6,8 +6,10 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_ldi_i(j, JIT_R0, &data);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(void) = jit_end(j, NULL);

2
tests/ldi_l.c
View file

@ -7,8 +7,10 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
static uint64_t data = 0xffffffffffffffff;
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_ldi_l(j, JIT_R0, &data);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_uword_t (*f)(void) = jit_end(j, NULL);

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