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

Use jit_word_t for register-sized values instead of intmax_t

Browse source
This commit is contained in:
Andy Wingo 2019-04-26 15:00:29 +02:00
parent bab1f40b5e
commit e9d1567f7f
156 changed files with 322 additions and 323 deletions
Download patch file Download diff file Expand all files Collapse all files

4
lightening.h
View file

@ -124,8 +124,8 @@ enum jit_operand_abi
JIT_OPERAND_ABI_POINTER,
JIT_OPERAND_ABI_FLOAT,
JIT_OPERAND_ABI_DOUBLE,
JIT_OPERAND_ABI_INTMAX = CHOOSE_32_64(JIT_OPERAND_ABI_INT32,
JIT_OPERAND_ABI_INT64)
JIT_OPERAND_ABI_WORD = CHOOSE_32_64(JIT_OPERAND_ABI_INT32,
JIT_OPERAND_ABI_INT64)
};
enum jit_operand_kind

2
lightening/lightening.c
View file

@ -565,7 +565,7 @@ abi_mem_to_fpr(jit_state_t *_jit, enum jit_operand_abi abi,
static void
abi_imm_to_mem(jit_state_t *_jit, enum jit_operand_abi abi, jit_gpr_t base,
ptrdiff_t offset, intmax_t imm)
ptrdiff_t offset, jit_imm_t imm)
{
ASSERT(!is_fpr_arg(abi));

2
tests/Makefile
View file

@ -27,7 +27,7 @@ test-native-%: %.c lightening-native.o test.h
test-ia32-%: CC = $(CC_IA32)
test-ia32-%: %.c lightening-ia32.o test.h
$(CC) -m32 $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening-ia32.o $<
$(CC) $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening-ia32.o $<
clean:
rm -f $(foreach TARGET,$(TARGETS),$(addprefix test-$(TARGET)-,$(TESTS)))

2
tests/addi.c
View file

@ -4,7 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_addi(j, JIT_R0, JIT_R0, 69);
jit_retr(j, JIT_R0);

4
tests/addr.c
View file

@ -4,8 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_retr(j, JIT_R0);

6
tests/addx.c
View file

@ -4,8 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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);
@ -15,7 +15,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
size_t size = 0;
void* ret = jit_end(j, &size);
intmax_t (*f)(intmax_t, intmax_t) = ret;
jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
ASSERT(f(0, 0) == 0);

4
tests/andi.c
View file

@ -4,7 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_andi(j, JIT_R0, JIT_R0, 1);
jit_retr(j, JIT_R0);
@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
size_t size = 0;
void* ret = jit_end(j, &size);
intmax_t (*f)(intmax_t) = ret;
jit_word_t (*f)(jit_word_t) = ret;
ASSERT(f(0x7fffffff) == 1);
ASSERT(f(0x80000000) == 0);

6
tests/andr.c
View file

@ -4,8 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_retr(j, JIT_R0);
@ -13,7 +13,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
size_t size = 0;
void* ret = jit_end(j, &size);
intmax_t (*f)(intmax_t, intmax_t) = ret;
jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
ASSERT(f(0x7fffffff, 1) == 1);
ASSERT(f(1, 0x7fffffff) == 1);

4
tests/beqi.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 0);

6
tests/beqr.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

2
tests/beqr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

2
tests/beqr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

4
tests/bgei.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 1);

4
tests/bgei_u.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 1);

6
tests/bger.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

2
tests/bger_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

2
tests/bger_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

6
tests/bger_u.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

4
tests/bgti.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

4
tests/bgti_u.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

6
tests/bgtr.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

2
tests/bgtr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

2
tests/bgtr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

6
tests/bgtr_u.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

4
tests/blei.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 0);

4
tests/blei_u.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 0);

6
tests/bler.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

2
tests/bler_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

2
tests/bler_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

6
tests/bler_u.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

2
tests/bltgtr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

2
tests/bltgtr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

4
tests/blti.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 0);

4
tests/blti_u.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 0);

6
tests/bltr.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

2
tests/bltr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

2
tests/bltr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

6
tests/bltr_u.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

4
tests/bmci.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 0);

6
tests/bmcr.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

4
tests/bmsi.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

6
tests/bmsr.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

4
tests/bnei.c
View file

@ -4,14 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

6
tests/bner.c
View file

@ -4,15 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_reti(j, 0);
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

2
tests/bner_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

2
tests/bner_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

6
tests/boaddi.c
View file

@ -1,12 +1,12 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == 0);
ASSERT(f(0) == 1);

6
tests/boaddi_u.c
View file

@ -1,12 +1,12 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == overflowed);
ASSERT(f(0) == 1);

8
tests/boaddr.c
View file

@ -1,13 +1,13 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
@ -15,7 +15,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 2);

8
tests/boaddr_u.c
View file

@ -1,13 +1,13 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
@ -15,7 +15,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 2);

2
tests/bordr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

2
tests/bordr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

6
tests/bosubi.c
View file

@ -1,12 +1,12 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == -1);

6
tests/bosubi_u.c
View file

@ -1,12 +1,12 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
@ -14,7 +14,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == overflowed);

8
tests/bosubr.c
View file

@ -1,13 +1,13 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
@ -15,7 +15,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == -1);

8
tests/bosubr_u.c
View file

@ -1,13 +1,13 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
@ -15,7 +15,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 0);

4
tests/bswapr_ui.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_ui(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(0x12345678) == 0x78563412);

4
tests/bswapr_ul.c
View file

@ -5,12 +5,12 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
#if __WORDSIZE > 32
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_ul(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(0x12345678) == 0x7856341200000000);

4
tests/bswapr_us.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_us(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(0x12345678) == 0x7856);

2
tests/buneqr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

2
tests/buneqr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

2
tests/bunger_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

2
tests/bunger_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

2
tests/bungtr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

2
tests/bungtr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

2
tests/bunler_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

2
tests/bunler_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

2
tests/bunltr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

2
tests/bunltr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

2
tests/bunordr_d.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

2
tests/bunordr_f.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_patch_here(j, r);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

6
tests/bxaddi.c
View file

@ -1,19 +1,19 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == 0);
ASSERT(f(0) == 1);

6
tests/bxaddi_u.c
View file

@ -1,19 +1,19 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == overflowed);
ASSERT(f(0) == 1);

8
tests/bxaddr.c
View file

@ -1,20 +1,20 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 2);

8
tests/bxaddr_u.c
View file

@ -1,20 +1,20 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 2);

6
tests/bxsubi.c
View file

@ -1,19 +1,19 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == -1);

6
tests/bxsubi_u.c
View file

@ -1,19 +1,19 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == overflowed);

8
tests/bxsubr.c
View file

@ -1,20 +1,20 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == -1);

8
tests/bxsubr_u.c
View file

@ -1,20 +1,20 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
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));
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_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 0);

4
tests/comr.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_comr(j, JIT_R0, JIT_R0);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
#if __WORDSIZE == 32
ASSERT(f(0) == 0xffffffff);

6
tests/divr.c
View file

@ -4,8 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_retr(j, JIT_R0);
@ -13,7 +13,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
size_t size = 0;
void* ret = jit_end(j, &size);
intmax_t (*f)(intmax_t, intmax_t) = ret;
jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
ASSERT(f(0x7fffffff, 1) == 0x7fffffff);
ASSERT(f(1, 0x7fffffff) == 0);

6
tests/divr_u.c
View file

@ -4,8 +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);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
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_retr(j, JIT_R0);
@ -13,7 +13,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
size_t size = 0;
void* ret = jit_end(j, &size);
intmax_t (*f)(intmax_t, intmax_t) = ret;
jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
ASSERT(f(0x7fffffff, 1) == 0x7fffffff);
ASSERT(f(1, 0x7fffffff) == 0);

4
tests/extr_c.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_c(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

4
tests/extr_d.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_extr_d(j, JIT_F0, JIT_R0);
jit_retr_d(j, JIT_F0);
double (*f)(intmax_t) = jit_end(j, NULL);
double (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0.0);
ASSERT(f(1) == 1.0);

4
tests/extr_f.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_extr_f(j, JIT_F0, JIT_R0);
jit_retr_f(j, JIT_F0);
float (*f)(intmax_t) = jit_end(j, NULL);
float (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0.0f);
ASSERT(f(1) == 1.0f);

4
tests/extr_i.c
View file

@ -5,12 +5,12 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
#if __WORDSIZE > 32
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_i(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

4
tests/extr_s.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_s(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

4
tests/extr_uc.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_uc(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

4
tests/extr_ui.c
View file

@ -5,12 +5,12 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
#if __WORDSIZE > 32
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_ui(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

4
tests/extr_us.c
View file

@ -4,12 +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);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_extr_us(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

2
tests/ldi_c.c
View file

@ -10,7 +10,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldi_c(j, JIT_R0, &data[0]);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void) = jit_end(j, NULL);
jit_uword_t (*f)(void) = jit_end(j, NULL);
ASSERT(f() == -1);
}

2
tests/ldi_i.c
View file

@ -10,7 +10,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldi_i(j, JIT_R0, &data);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void) = jit_end(j, NULL);
jit_uword_t (*f)(void) = jit_end(j, NULL);
ASSERT(f() == -1);
}

2
tests/ldi_l.c
View file

@ -11,7 +11,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldi_l(j, JIT_R0, &data);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void) = jit_end(j, NULL);
jit_uword_t (*f)(void) = jit_end(j, NULL);
ASSERT(f() == -1);
#endif

2
tests/ldi_s.c
View file

@ -10,7 +10,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldi_s(j, JIT_R0, &data);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void) = jit_end(j, NULL);
jit_uword_t (*f)(void) = jit_end(j, NULL);
ASSERT(f() == -1);
}

2
tests/ldi_uc.c
View file

@ -10,7 +10,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldi_uc(j, JIT_R0, data);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void) = jit_end(j, NULL);
jit_uword_t (*f)(void) = jit_end(j, NULL);
ASSERT(f() == 0xff);
}

2
tests/ldi_ui.c
View file

@ -11,7 +11,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldi_ui(j, JIT_R0, data);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void) = jit_end(j, NULL);
jit_uword_t (*f)(void) = jit_end(j, NULL);
ASSERT(f() == data[0]);
#endif

2
tests/ldi_us.c
View file

@ -10,7 +10,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldi_us(j, JIT_R0, data);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void) = jit_end(j, NULL);
jit_uword_t (*f)(void) = jit_end(j, NULL);
ASSERT(f() == data[0]);
}

2
tests/ldr_c.c
View file

@ -11,7 +11,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldr_c(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void*) = jit_end(j, NULL);
jit_uword_t (*f)(void*) = jit_end(j, NULL);
ASSERT(f(&data[0]) == -1);
ASSERT(f(&data[1]) == 0);

2
tests/ldr_i.c
View file

@ -11,7 +11,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldr_i(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void*) = jit_end(j, NULL);
jit_uword_t (*f)(void*) = jit_end(j, NULL);
ASSERT(f(&data[0]) == -1);
ASSERT(f(&data[1]) == 0);

2
tests/ldr_l.c
View file

@ -12,7 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_ldr_l(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
uintmax_t (*f)(void*) = jit_end(j, NULL);
jit_uword_t (*f)(void*) = jit_end(j, NULL);
ASSERT(f(&data[0]) == -1);
ASSERT(f(&data[1]) == 0);

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