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

Add sub-and-branch-on-overflow tests

Browse source
This commit is contained in:
Andy Wingo 2019-03-26 16:09:07 +01:00
parent 6dbad81afd
commit 8a8273c45c
8 changed files with 354 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

43
tests/bosubi.c Normal file
View file

@ -0,0 +1,43 @@
#include "test.h"
static const intmax_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);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_reloc_t r = jit_bosubi(j, JIT_R0, 1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == -1);
ASSERT(f(1) == 0);
#if __WORDSIZE == 32
ASSERT(f(0x7fffffff) == 0x7ffffffe);
ASSERT(f(0x80000000) == overflowed);
ASSERT(f(0x80000001) == 0x80000000);
#else
ASSERT(f(0x7fffffffffffffff) == 0x7ffffffffffffffe);
ASSERT(f(0x8000000000000000) == overflowed);
ASSERT(f(0x8000000000000001) == 0x8000000000000000);
#endif
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}

39
tests/bosubi_u.c Normal file
View file

@ -0,0 +1,39 @@
#include "test.h"
static const intmax_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);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_reloc_t r = jit_bosubi_u(j, JIT_R0, 1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == overflowed);
ASSERT(f(1) == 0);
#if __WORDSIZE == 32
ASSERT(f(0x80000000) == 0x7fffffff);
#else
ASSERT(f(0x8000000000000000) == 0x7fffffffffffffff);
#endif
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}

49
tests/bosubr.c Normal file
View file

@ -0,0 +1,49 @@
#include "test.h"
static const intmax_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);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_reloc_t r = jit_bosubr(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == -1);
ASSERT(f(1, 1) == 0);
ASSERT(f(1, -1) == 2);
#if __WORDSIZE == 32
ASSERT(f(0xffffffff, 0xffffffff) == 0);
ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
ASSERT(f(0x7fffffff, 1) == 0x7ffffffe);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0);
ASSERT(f(0x80000000, 0x7fffffff) == overflowed);
ASSERT(f(0x7fffffff, 0x80000000) == overflowed);
ASSERT(f(0x80000000, 0x80000000) == 0);
#else
ASSERT(f(0x7fffffffffffffff, 0x7fffffffffffffff) == 0);
ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == overflowed);
ASSERT(f(0x8000000000000000, 0x7fffffffffffffff) == overflowed);
ASSERT(f(0x8000000000000000, 0x8000000000000000) == 0);
#endif
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}

48
tests/bosubr_u.c Normal file
View file

@ -0,0 +1,48 @@
#include "test.h"
static const intmax_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);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_reloc_t r = jit_bosubr_u(j, JIT_R0, JIT_R1);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 0);
ASSERT(f(0, 1) == overflowed);
ASSERT(f(1, 0) == 1);
#if __WORDSIZE == 32
ASSERT(f(0xffffffff, 0xffffffff) == 0);
ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
ASSERT(f(0x7fffffff, 1) == 0x7ffffffe);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0);
ASSERT(f(0x7fffffff, 0x80000000) == overflowed);
ASSERT(f(0x80000000, 0x80000000) == 0);
#else
ASSERT(f(0xffffffffffffffff, 0xffffffffffffffff) == 0);
ASSERT(f(0x7fffffffffffffff, 0x7fffffffffffffff) == 0);
ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == overflowed);
ASSERT(f(0x8000000000000000, 0x8000000000000000) == 0);
#endif
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}

42
tests/bxsubi.c Normal file
View file

@ -0,0 +1,42 @@
#include "test.h"
static const intmax_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);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_reloc_t r = jit_bxsubi(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == -1);
ASSERT(f(1) == 0);
#if __WORDSIZE == 32
ASSERT(f(0x7fffffff) == 0x7ffffffe);
ASSERT(f(0x80000000) == overflowed);
ASSERT(f(0x80000001) == 0x80000000);
#else
ASSERT(f(0x7fffffffffffffff) == 0x7ffffffffffffffe);
ASSERT(f(0x8000000000000000) == overflowed);
ASSERT(f(0x8000000000000001) == 0x8000000000000000);
#endif
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}

38
tests/bxsubi_u.c Normal file
View file

@ -0,0 +1,38 @@
#include "test.h"
static const intmax_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);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX };
jit_arg_t args[1];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 } };
jit_receive(j, 1, abi, args);
jit_load_args(j, 1, abi, args, regs);
jit_reloc_t r = jit_bxsubi_u(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == overflowed);
ASSERT(f(1) == 0);
#if __WORDSIZE == 32
ASSERT(f(0x80000000) == 0x7fffffff);
#else
ASSERT(f(0x8000000000000000) == 0x7fffffffffffffff);
#endif
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}

48
tests/bxsubr.c Normal file
View file

@ -0,0 +1,48 @@
#include "test.h"
static const intmax_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);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_reloc_t r = jit_bxsubr(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == -1);
ASSERT(f(1, 1) == 0);
ASSERT(f(1, -1) == 2);
#if __WORDSIZE == 32
ASSERT(f(0xffffffff, 0xffffffff) == 0);
ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
ASSERT(f(0x7fffffff, 1) == 0x7ffffffe);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0);
ASSERT(f(0x80000000, 0x7fffffff) == overflowed);
ASSERT(f(0x7fffffff, 0x80000000) == overflowed);
ASSERT(f(0x80000000, 0x80000000) == 0);
#else
ASSERT(f(0x7fffffffffffffff, 0x7fffffffffffffff) == 0);
ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == overflowed);
ASSERT(f(0x8000000000000000, 0x7fffffffffffffff) == overflowed);
ASSERT(f(0x8000000000000000, 0x8000000000000000) == 0);
#endif
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}

47
tests/bxsubr_u.c Normal file
View file

@ -0,0 +1,47 @@
#include "test.h"
static const intmax_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);
const jit_arg_abi_t abi[] = { JIT_ARG_ABI_INTMAX, JIT_ARG_ABI_INTMAX };
jit_arg_t args[2];
const jit_anyreg_t regs[] = { { .gpr=JIT_R0 }, { .gpr=JIT_R1 }};
jit_receive(j, 2, abi, args);
jit_load_args(j, 2, abi, args, regs);
jit_reloc_t r = jit_bxsubr_u(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 0);
ASSERT(f(0, 1) == overflowed);
ASSERT(f(1, 0) == 1);
#if __WORDSIZE == 32
ASSERT(f(0xffffffff, 0xffffffff) == 0);
ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
ASSERT(f(0x7fffffff, 1) == 0x7ffffffe);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0);
ASSERT(f(0x7fffffff, 0x80000000) == overflowed);
ASSERT(f(0x80000000, 0x80000000) == 0);
#else
ASSERT(f(0xffffffffffffffff, 0xffffffffffffffff) == 0);
ASSERT(f(0x7fffffffffffffff, 0x7fffffffffffffff) == 0);
ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == overflowed);
ASSERT(f(0x8000000000000000, 0x8000000000000000) == 0);
#endif
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}