continue working through test cases

+ Remove overflow and more complicated floating point tests for now

49 files changed, 548 insertions, 1814 deletions

diff --git a/tests/addx.c b/tests/addx.c
deleted file mode 100644
index eed95ba..0000000
--- a/tests/addx.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/* still not entirely sure about semantics, should 32bit systems report carry on
- * 32bit or 64bit internal register sizes? */
-#warning "carry operations unimplemented but TODO"
-int main(){
-}
-
-/* would look something like this */
-#if 0
-#include <ejit/ejit.h>
-#include <assert.h>
-#include "do_jit.h"
-
-int main()
-{
-	struct ejit_operand operands[2] = {
-		EJIT_OPERAND_GPR(0, EJIT_TYPE(long)),
-		EJIT_OPERAND_GPR(1, EJIT_TYPE(long))
-	};
-	struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands);
-
-	ejit_movi(j, EJIT_GPR(2), EJIT_GPR(0));
-	ejit_addcr(j, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1));
-	ejit_addxi(j, EJIT_GPR(2), EJIT_GPR(2), 0);
-	ejit_retr(j, EJIT_GPR(2));
-
-	ejit_select_compile_func(f, 3, 0, EJIT_USE64(long), do_jit);
-
-	jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
-
-	assert(ejit_run_func_2(f, EJIT_ARG(0, long), EJIT_ARG(0, long)) == 0);
-
-#if EJIT_WORDSIZE == 32
-	/* carry */
-	assert(ejit_run_func_2(f,
-	                       EJIT_ARG(0xffffffff, long),
-	                       EJIT_ARG(0xffffffff, long)) == 1);
-	/* overflow */
-	assert(ejit_run_func_2(f,
-	                       EJIT_ARG(0x7fffffff long),
-	                       EJIT_ARG(1, long)) == 0);
-
-	/* overflow */
-	assert(ejit_run_func_2(f,
-	                       EJIT_ARG(0x7fffffff, long),
-	                       EJIT_ARG(0x7fffffff, long)) == 0);
-
-	/* carry */
-	assert(ejit_run_func_2(f,
-	                       EJIT_ARG(0x7fffffff, long),
-	                       EJIT_ARG(0x80000000, long)) == 0);
-
-	/* carry+overflow */
-	assert(ejit_run_func_2(f,
-	                       EJIT_ARG(0x80000000, long),
-	                       EJIT_ARG(0x80000000, long)) == 1);
-#else
-	/* nothing */
-	assert(f(0xffffffff, 0xffffffff) == 0);
-	/* nothing */
-	assert(f(0x7fffffff, 1) == 0);
-	/* nothing */
-	assert(f(0x7fffffff, 0x7fffffff) == 0);
-	/* nothing */
-	assert(f(0x7fffffff, 0x80000000) == 0);
-	/* nothing */
-	assert(f(0x80000000, 0x80000000) == 0);
-	/* carry */
-	assert(f(0xffffffffffffffff, 0xffffffffffffffff) == 1);
-	/* overflow */
-	assert(f(0x7fffffffffffffff, 1) == 0);
-	/* overflow */
-	assert(f(0x7fffffffffffffff, 0x7fffffffffffffff) == 0);
-	/* overflow */
-	assert(f(0x7fffffffffffffff, 0x8000000000000000) == 0);
-	/* carry+overflow */
-	assert(f(0x8000000000000000, 0x8000000000000000) == 1);
-#endif
-}
-#endif
diff --git a/tests/bltgtr_f.c b/tests/bltgtr_f.c
deleted file mode 100644
index 32b2a96..0000000
--- a/tests/bltgtr_f.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include <ejit/ejit.h>
-#include <assert.h>
-#include "do_jit.h"
-
-int main()
-{
-	struct ejit_operand operands[2] = {
-		EJIT_OPERAND_FPR(0, EJIT_TYPE(double)),
-		EJIT_OPERAND_FPR(1, EJIT_TYPE(double)),
-	};
-
-	struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands);
-	struct ejit_reloc r = ejit_bltgtr_f(f, EJIT_FPR(0), EJIT_FPR(1));
-	ejit_reti(f, 0);
-
-	struct ejit_label l = ejit_label(f);
-	ejit_patch(f, r, l);
-	ejit_reti(f, 1);
-
-	ejit_select_compile_func(f, 0, 2, EJIT_USE64(double), do_jit);
-
-	assert(ejit_run_func_2(f, EJIT_ARG(0, double),
-	                       EJIT_ARG(0, double)) == 0);
-	assert(ejit_run_func_2(f, EJIT_ARG(0, double),
-	                       EJIT_ARG(1, double)) == 1);
-	assert(ejit_run_func_2(f, EJIT_ARG(1, double),
-	                       EJIT_ARG(0, double)) == 1);
-	assert(ejit_run_func_2(f, EJIT_ARG(0, double),
-	                       EJIT_ARG(-1, double)) == 1);
-	assert(ejit_run_func_2(f, EJIT_ARG(-1, double),
-	                       EJIT_ARG(0, double)) == 1);
-	assert(ejit_run_func_2(f, EJIT_ARG(1, double),
-	                       EJIT_ARG(1, double)) == 0);
-
-	assert(ejit_run_func_2(f, EJIT_ARG(0, double),
-	                       EJIT_ARG(0.0/0.0, double)) == 0);
-	assert(ejit_run_func_2(f, EJIT_ARG(0.0/0.0, double),
-	                       EJIT_ARG(0, double)) == 0);
-	assert(ejit_run_func_2(f, EJIT_ARG(0.0/0.0, double),
-	                       EJIT_ARG(0.0/0.0, double)) == 0);
-}
diff --git a/tests/boaddi.c b/tests/boaddi.c
deleted file mode 100644
index e0fed81..0000000
--- a/tests/boaddi.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(-1) == 0);
-	ASSERT(f(0) == 1);
-	ASSERT(f(1) == 2);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0x7fffffff) == overflowed);
-	ASSERT(f(0x80000000) == 0x80000001);
-	ASSERT(f(0xffffffff) == 0);
-#else
-	ASSERT(f(0x7fffffffffffffff) == overflowed);
-	ASSERT(f(0x8000000000000000) == 0x8000000000000001);
-	ASSERT(f(0xffffffffffffffff) == 0);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/boaddi_u.c b/tests/boaddi_u.c
deleted file mode 100644
index b6ffa89..0000000
--- a/tests/boaddi_u.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(-1) == overflowed);
-	ASSERT(f(0) == 1);
-	ASSERT(f(1) == 2);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0x7fffffff) == 0x80000000);
-	ASSERT(f(0x80000000) == 0x80000001);
-	ASSERT(f(0xffffffff) == overflowed);
-#else
-	ASSERT(f(0x7fffffffffffffff) == 0x8000000000000000);
-	ASSERT(f(0x8000000000000000) == 0x8000000000000001);
-	ASSERT(f(0xffffffffffffffff) == overflowed);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/boaddr.c b/tests/boaddr.c
deleted file mode 100644
index 69668f7..0000000
--- a/tests/boaddr.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(1, 1) == 2);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0xffffffff, 0xffffffff) == -2);
-	ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
-	ASSERT(f(0x7fffffff, 1) == overflowed);
-	ASSERT(f(0x7fffffff, 0x7fffffff) == overflowed);
-	ASSERT(f(0x7fffffff, 0x80000000) == -1);
-	ASSERT(f(0x80000000, 0x80000000) == overflowed);
-#else
-	ASSERT(f(0xffffffff, 0xffffffff) == 0xffffffffull + 0xffffffffull);
-	ASSERT(f(0x7fffffff, 1) == 0x80000000);
-	ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffull + 0x7fffffffull);
-	ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
-	ASSERT(f(0x80000000, 0x80000000) == 0x100000000);
-	ASSERT(f(0xffffffffffffffff, 0xffffffffffffffff) == -2);
-	ASSERT(f(0x7fffffffffffffff, 1) == overflowed);
-	ASSERT(f(0x7fffffffffffffff, 0x7fffffffffffffff) == overflowed);
-	ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == -1);
-	ASSERT(f(0x8000000000000000, 0x8000000000000000) == overflowed);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/boaddr_u.c b/tests/boaddr_u.c
deleted file mode 100644
index 1483471..0000000
--- a/tests/boaddr_u.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(1, 1) == 2);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0xffffffff, 0xffffffff) == overflowed);
-	ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
-	ASSERT(f(0x7fffffff, 1) == 0x80000000);
-	ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffu + 0x7fffffffu);
-	ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
-	ASSERT(f(0x80000000, 0x80000000) == overflowed);
-#else
-	ASSERT(f(0xffffffff, 0xffffffff) == 0xffffffffull + 0xffffffffull);
-	ASSERT(f(0x7fffffff, 1) == 0x80000000);
-	ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffull + 0x7fffffffull);
-	ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
-	ASSERT(f(0x80000000, 0x80000000) == 0x100000000);
-	ASSERT(f(0xffffffffffffffff, 0xffffffffffffffff) == overflowed);
-	ASSERT(f(0x7fffffffffffffff, 1) == 0x8000000000000000);
-	ASSERT(f(0x7fffffffffffffff, 0x7fffffffffffffff) == -2);
-	ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == -1);
-	ASSERT(f(0x8000000000000000, 0x8000000000000000) == overflowed);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bordr_f.c b/tests/bordr_f.c
deleted file mode 100644
index a3db62e..0000000
--- a/tests/bordr_f.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0, 0) == 1);
-	ASSERT(f(0, 1) == 1);
-	ASSERT(f(1, 0) == 1);
-	ASSERT(f(-1, 0) == 1);
-	ASSERT(f(0, -1) == 1);
-	ASSERT(f(1, 1) == 1);
-
-	ASSERT(f(0, 0.0/0.0) == 0);
-	ASSERT(f(0.0/0.0, 0) == 0);
-	ASSERT(f(0.0/0.0, 0.0/0.0) == 0);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bosubi.c b/tests/bosubi.c
deleted file mode 100644
index b1bbc77..0000000
--- a/tests/bosubi.c
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(-1) == -2);
-	ASSERT(f(0) == -1);
-	ASSERT(f(1) == 0);
-
-#if EJIT_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);
-}
diff --git a/tests/bosubi_u.c b/tests/bosubi_u.c
deleted file mode 100644
index c04b971..0000000
--- a/tests/bosubi_u.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(-1) == -2);
-	ASSERT(f(0) == overflowed);
-	ASSERT(f(1) == 0);
-
-#if EJIT_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);
-}
diff --git a/tests/bosubr.c b/tests/bosubr.c
deleted file mode 100644
index 01ea9fe..0000000
--- a/tests/bosubr.c
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(0, 1) == -1);
-	ASSERT(f(1, 1) == 0);
-	ASSERT(f(1, -1) == 2);
-
-#if EJIT_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);
-}
diff --git a/tests/bosubr_u.c b/tests/bosubr_u.c
deleted file mode 100644
index 0f6d5b7..0000000
--- a/tests/bosubr_u.c
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(1, 1) == 0);
-	ASSERT(f(0, 1) == overflowed);
-	ASSERT(f(1, 0) == 1);
-
-#if EJIT_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);
-}
diff --git a/tests/bswapr_ui.c b/tests/bswapr_ui.c
deleted file mode 100644
index 9c4b42b..0000000
--- a/tests/bswapr_ui.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0) == 0);
-	ASSERT(f(0x12345678) == 0x78563412);
-#if EJIT_WORDSIZE > 32
-	ASSERT(f(0xff12345678) == 0x78563412);
-	ASSERT(f(0xff00000000) == 0);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bswapr_ul.c b/tests/bswapr_ul.c
deleted file mode 100644
index 03136d8..0000000
--- a/tests/bswapr_ul.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#include "test.h"
-
-static void
-run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
-{
-#if EJIT_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);
-
-	ASSERT(f(0) == 0);
-	ASSERT(f(0x12345678) == 0x7856341200000000);
-	ASSERT(f(0xff12345678) == 0x78563412ff000000);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bswapr_us.c b/tests/bswapr_us.c
deleted file mode 100644
index a2c223b..0000000
--- a/tests/bswapr_us.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0) == 0);
-	ASSERT(f(0x12345678) == 0x7856);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/buneqr_f.c b/tests/buneqr_f.c
deleted file mode 100644
index 4277f86..0000000
--- a/tests/buneqr_f.c
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0, 0) == 1);
-	ASSERT(f(0, 1) == 0);
-	ASSERT(f(1, 0) == 0);
-	ASSERT(f(-1, 0) == 0);
-	ASSERT(f(0, -1) == 0);
-	ASSERT(f(1, 1) == 1);
-
-	ASSERT(f(0, 0.0/0.0) == 1);
-	ASSERT(f(0.0/0.0, 0) == 1);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bunger_f.c b/tests/bunger_f.c
deleted file mode 100644
index 0fa542b..0000000
--- a/tests/bunger_f.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0, 0) == 1);
-	ASSERT(f(0, 1) == 0);
-	ASSERT(f(1, 0) == 1);
-	ASSERT(f(-1, 0) == 0);
-	ASSERT(f(0, -1) == 1);
-
-	ASSERT(f(0, 0.0/0.0) == 1);
-	ASSERT(f(0.0/0.0, 0) == 1);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bungtr_f.c b/tests/bungtr_f.c
deleted file mode 100644
index 94a9170..0000000
--- a/tests/bungtr_f.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(0, 1) == 0);
-	ASSERT(f(1, 0) == 1);
-	ASSERT(f(-1, 0) == 0);
-	ASSERT(f(0, -1) == 1);
-
-	ASSERT(f(0, 0.0/0.0) == 1);
-	ASSERT(f(0.0/0.0, 0) == 1);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bunler_f.c b/tests/bunler_f.c
deleted file mode 100644
index 3b40f95..0000000
--- a/tests/bunler_f.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0, 0) == 1);
-	ASSERT(f(0, 1) == 1);
-	ASSERT(f(1, 0) == 0);
-	ASSERT(f(-1, 0) == 1);
-	ASSERT(f(0, -1) == 0);
-
-	ASSERT(f(0, 0.0/0.0) == 1);
-	ASSERT(f(0.0/0.0, 0) == 1);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bunltr_f.c b/tests/bunltr_f.c
deleted file mode 100644
index d86ce1a..0000000
--- a/tests/bunltr_f.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(0, 1) == 1);
-	ASSERT(f(1, 0) == 0);
-	ASSERT(f(-1, 0) == 1);
-	ASSERT(f(0, -1) == 0);
-
-	ASSERT(f(0, 0.0/0.0) == 1);
-	ASSERT(f(0.0/0.0, 0) == 1);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bunordr_f.c b/tests/bunordr_f.c
deleted file mode 100644
index 663d988..0000000
--- a/tests/bunordr_f.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "test.h"
-
-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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(0, 1) == 0);
-	ASSERT(f(1, 0) == 0);
-	ASSERT(f(-1, 0) == 0);
-	ASSERT(f(0, -1) == 0);
-	ASSERT(f(1, 1) == 0);
-
-	ASSERT(f(0, 0.0/0.0) == 1);
-	ASSERT(f(0.0/0.0, 0) == 1);
-	ASSERT(f(0.0/0.0, 0.0/0.0) == 1);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bxaddi.c b/tests/bxaddi.c
deleted file mode 100644
index 282b1f1..0000000
--- a/tests/bxaddi.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(-1) == 0);
-	ASSERT(f(0) == 1);
-	ASSERT(f(1) == 2);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0x7fffffff) == overflowed);
-	ASSERT(f(0x80000000) == 0x80000001);
-	ASSERT(f(0xffffffff) == 0);
-#else
-	ASSERT(f(0x7fffffffffffffff) == overflowed);
-	ASSERT(f(0x8000000000000000) == 0x8000000000000001);
-	ASSERT(f(0xffffffffffffffff) == 0);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bxaddi_u.c b/tests/bxaddi_u.c
deleted file mode 100644
index dc3140e..0000000
--- a/tests/bxaddi_u.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(-1) == overflowed);
-	ASSERT(f(0) == 1);
-	ASSERT(f(1) == 2);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0x7fffffff) == 0x80000000);
-	ASSERT(f(0x80000000) == 0x80000001);
-	ASSERT(f(0xffffffff) == overflowed);
-#else
-	ASSERT(f(0x7fffffffffffffff) == 0x8000000000000000);
-	ASSERT(f(0x8000000000000000) == 0x8000000000000001);
-	ASSERT(f(0xffffffffffffffff) == overflowed);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bxaddr.c b/tests/bxaddr.c
deleted file mode 100644
index 472906d..0000000
--- a/tests/bxaddr.c
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(1, 1) == 2);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0xffffffff, 0xffffffff) == -2);
-	ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
-	ASSERT(f(0x7fffffff, 1) == overflowed);
-	ASSERT(f(0x7fffffff, 0x7fffffff) == overflowed);
-	ASSERT(f(0x7fffffff, 0x80000000) == -1);
-	ASSERT(f(0x80000000, 0x80000000) == overflowed);
-#else
-	ASSERT(f(0xffffffff, 0xffffffff) == 0xffffffffull + 0xffffffffull);
-	ASSERT(f(0x7fffffff, 1) == 0x80000000);
-	ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffull + 0x7fffffffull);
-	ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
-	ASSERT(f(0x80000000, 0x80000000) == 0x100000000);
-	ASSERT(f(0xffffffffffffffff, 0xffffffffffffffff) == -2);
-	ASSERT(f(0x7fffffffffffffff, 1) == overflowed);
-	ASSERT(f(0x7fffffffffffffff, 0x7fffffffffffffff) == overflowed);
-	ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == -1);
-	ASSERT(f(0x8000000000000000, 0x8000000000000000) == overflowed);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bxaddr_u.c b/tests/bxaddr_u.c
deleted file mode 100644
index d40e0ff..0000000
--- a/tests/bxaddr_u.c
+++ /dev/null
@@ -1,49 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(1, 1) == 2);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0xffffffff, 0xffffffff) == overflowed);
-	ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
-	ASSERT(f(0x7fffffff, 1) == 0x80000000);
-	ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffu + 0x7fffffffu);
-	ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
-	ASSERT(f(0x80000000, 0x80000000) == overflowed);
-#else
-	ASSERT(f(0xffffffff, 0xffffffff) == 0xffffffffull + 0xffffffffull);
-	ASSERT(f(0x7fffffff, 1) == 0x80000000);
-	ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffull + 0x7fffffffull);
-	ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
-	ASSERT(f(0x80000000, 0x80000000) == 0x100000000);
-	ASSERT(f(0xffffffffffffffff, 0xffffffffffffffff) == overflowed);
-	ASSERT(f(0x7fffffffffffffff, 1) == 0x8000000000000000);
-	ASSERT(f(0x7fffffffffffffff, 0x7fffffffffffffff) == -2);
-	ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == -1);
-	ASSERT(f(0x8000000000000000, 0x8000000000000000) == overflowed);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/bxsubi.c b/tests/bxsubi.c
deleted file mode 100644
index e6224bf..0000000
--- a/tests/bxsubi.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(-1) == -2);
-	ASSERT(f(0) == -1);
-	ASSERT(f(1) == 0);
-
-#if EJIT_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);
-}
diff --git a/tests/bxsubi_u.c b/tests/bxsubi_u.c
deleted file mode 100644
index 6c1d1f3..0000000
--- a/tests/bxsubi_u.c
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(-1) == -2);
-	ASSERT(f(0) == overflowed);
-	ASSERT(f(1) == 0);
-
-#if EJIT_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);
-}
diff --git a/tests/bxsubr.c b/tests/bxsubr.c
deleted file mode 100644
index 50f5dbb..0000000
--- a/tests/bxsubr.c
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(0, 1) == -1);
-	ASSERT(f(1, 1) == 0);
-	ASSERT(f(1, -1) == 2);
-
-#if EJIT_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);
-}
diff --git a/tests/bxsubr_u.c b/tests/bxsubr_u.c
deleted file mode 100644
index 771ea3c..0000000
--- a/tests/bxsubr_u.c
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "test.h"
-
-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);
-	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);
-
-	ASSERT(f(0, 0) == 0);
-	ASSERT(f(1, 1) == 0);
-	ASSERT(f(0, 1) == overflowed);
-	ASSERT(f(1, 0) == 1);
-
-#if EJIT_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);
-}
diff --git a/tests/call_10.c b/tests/call_10.c
deleted file mode 100644
index 533acda..0000000
--- a/tests/call_10.c
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "test.h"
-
-static int32_t f(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e,
-                 int32_t f, int32_t g, int32_t h, int32_t i, int32_t j) {
-	ASSERT(a == 0);
-	ASSERT(b == 1);
-	ASSERT(c == 2);
-	ASSERT(d == 3);
-	ASSERT(e == 4);
-	ASSERT(f == 5);
-	ASSERT(g == 6);
-	ASSERT(h == 7);
-	ASSERT(i == 8);
-	ASSERT(j == 9);
-	return 42;
-}
-
-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_POINTER, JIT_R0));
-
-	jit_operand_t args[10] = {
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                0 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                1 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                2 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                3 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                4 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                5 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                6 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                7 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                8 * sizeof(int32_t)),
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0,
-		                9 * sizeof(int32_t))
-	};
-	jit_calli(j, f, 10, args);
-	jit_leave_jit_abi(j, 0, 0, align);
-	jit_ret(j);
-
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
-
-	int32_t (*f)(int32_t*) = ret;
-
-	int32_t iargs[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-	ASSERT(f(iargs) == 42);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/call_double.c b/tests/call_double.c
deleted file mode 100644
index 1138655..0000000
--- a/tests/call_double.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "test.h"
-
-static double f(int32_t a, double b) {
-	return b + a;
-}
-
-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_POINTER, JIT_R0),
-	                jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
-
-	jit_operand_t args[2] = {
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0, 0),
-		jit_operand_mem(JIT_OPERAND_ABI_DOUBLE, JIT_R1, 0)
-	};
-	jit_calli(j, f, 2, args);
-	jit_retval_d(j, JIT_F0);
-	jit_leave_jit_abi(j, 0, 0, align);
-	jit_retr_d(j, JIT_F0);
-
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
-
-	double (*f)(int32_t*, double*) = ret;
-
-	double d = 22.0f;
-	int32_t i = 20;
-	ASSERT(f(&i, &d) == 42.0f);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/call_float.c b/tests/call_float.c
deleted file mode 100644
index 9534e4b..0000000
--- a/tests/call_float.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "test.h"
-
-static float f(int32_t a, float b) {
-	return b + a;
-}
-
-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_POINTER, JIT_R0),
-	                jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
-
-	jit_operand_t args[2] = {
-		jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0, 0),
-		jit_operand_mem(JIT_OPERAND_ABI_FLOAT, JIT_R1, 0)
-	};
-	jit_calli(j, f, 2, args);
-	jit_retval_f(j, JIT_F0);
-	jit_leave_jit_abi(j, 0, 0, align);
-	jit_retr_f(j, JIT_F0);
-
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
-
-	float (*f)(int32_t*, float*) = ret;
-
-	float d = 22.0f;
-	int32_t i = 20;
-	ASSERT(f(&i, &d) == 42.0f);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/callee_9.c b/tests/callee_9.c
index 9d4e217..7dd131f 100644
--- a/tests/callee_9.c
+++ b/tests/callee_9.c
@@ -1,68 +1,78 @@
-#include "test.h"
+#include <ejit/ejit.h>
+#include <assert.h>
+#include "do_jit.h"
 
 struct args
 {
 	int8_t a;
 	int16_t b;
 	int32_t c;
-	jit_word_t d;
+	long d;
 	uint16_t e;
 	float f;
 	double g;
 	float h;
 };
 
-static void
-run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
+int main()
 {
-	jit_begin(j, arena_base, arena_size);
-	size_t align = jit_enter_jit_abi(j, 3, 0, 0);
-
-	jit_operand_t args[9] = {
-		jit_operand_gpr(JIT_OPERAND_ABI_POINTER, JIT_R0),
-		jit_operand_gpr(JIT_OPERAND_ABI_INT8, JIT_R1),
-		jit_operand_gpr(JIT_OPERAND_ABI_INT16, JIT_R2),
-		jit_operand_gpr(JIT_OPERAND_ABI_INT32, JIT_V0),
-		jit_operand_gpr(JIT_OPERAND_ABI_WORD, JIT_V1),
-		jit_operand_gpr(JIT_OPERAND_ABI_UINT16, JIT_V2),
-		jit_operand_fpr(JIT_OPERAND_ABI_FLOAT, JIT_F0),
-		jit_operand_fpr(JIT_OPERAND_ABI_DOUBLE, JIT_F1),
-		jit_operand_fpr(JIT_OPERAND_ABI_FLOAT, JIT_F2),
+	struct ejit_operand operands[9] = {
+		EJIT_OPERAND_GPR(0, EJIT_POINTER),
+		EJIT_OPERAND_GPR(1, EJIT_INT8),
+		EJIT_OPERAND_GPR(2, EJIT_INT16),
+		EJIT_OPERAND_GPR(3, EJIT_INT32),
+		EJIT_OPERAND_GPR(4, EJIT_TYPE(long)),
+		EJIT_OPERAND_GPR(5, EJIT_UINT16),
+		EJIT_OPERAND_FPR(0, EJIT_FLOAT),
+		EJIT_OPERAND_FPR(1, EJIT_DOUBLE),
+		EJIT_OPERAND_FPR(2, EJIT_FLOAT)
 	};
-	jit_load_args(j, 9, args);
-	jit_stxi_c(j, offsetof(struct args, a), JIT_R0, JIT_R1); // a
-	jit_stxi_s(j, offsetof(struct args, b), JIT_R0, JIT_R2); // b
-	jit_stxi_i(j, offsetof(struct args, c), JIT_R0, JIT_V0); // c
-	jit_stxi(j,   offsetof(struct args, d), JIT_R0, JIT_V1);// d
-	jit_stxi_s(j, offsetof(struct args, e), JIT_R0, JIT_V2); // e
-	jit_stxi_f(j, offsetof(struct args, f), JIT_R0, JIT_F0); // f
-	jit_stxi_d(j, offsetof(struct args, g), JIT_R0, JIT_F1); // g
-	jit_stxi_f(j, offsetof(struct args, h), JIT_R0, JIT_F2); // h
 
-	jit_leave_jit_abi(j, 3, 0, align);
-	jit_retr(j, JIT_R0);
+	struct ejit_func *f = ejit_create_func(EJIT_POINTER, 9, operands);
+	EJIT_STXI(f, int8_t,   EJIT_GPR(1), EJIT_GPR(0),
+	          offsetof(struct args, a));                                        // a
+	EJIT_STXI(f, int16_t,  EJIT_GPR(2), EJIT_GPR(0),
+	          offsetof(struct args, b));                                        // b
+	EJIT_STXI(f, int32_t,  EJIT_GPR(3), EJIT_GPR(0),
+	          offsetof(struct args, c));                                        // c
+	EJIT_STXI(f, long,     EJIT_GPR(4), EJIT_GPR(0),
+	          offsetof(struct args, d));                                        // d
+	EJIT_STXI(f, uint16_t, EJIT_GPR(5), EJIT_GPR(0),
+	          offsetof(struct args, e));                                        // e
+	EJIT_STXI(f, float,    EJIT_FPR(0), EJIT_GPR(0),
+	          offsetof(struct args, f));                                        // f
+	EJIT_STXI(f, double,   EJIT_FPR(1), EJIT_GPR(0),
+	          offsetof(struct args, g));                                        // g
+	EJIT_STXI(f, float,    EJIT_FPR(2), EJIT_GPR(0),
+	          offsetof(struct args, h));                                        // h
 
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
+	ejit_retr(f, EJIT_GPR(0));
 
-	struct args* (*f)(struct args*, int8_t, int16_t, int32_t, jit_word_t,
-	                  uint16_t, float, double, float) = ret;
+	ejit_select_compile_func(f, 6, 3, EJIT_USE64(long), do_jit);
 
 	struct args in = { 0, 1, 2, 3, 4, 5, 6, 7 };
 	struct args out;
-	ASSERT(f(&out, in.a, in.b, in.c, in.d, in.e, in.f, in.g, in.h) == &out);
-	ASSERT(in.a == out.a);
-	ASSERT(in.b == out.b);
-	ASSERT(in.c == out.c);
-	ASSERT(in.d == out.d);
-	ASSERT(in.e == out.e);
-	ASSERT(in.f == out.f);
-	ASSERT(in.g == out.g);
-	ASSERT(in.h == out.h);
-}
 
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
+	struct ejit_arg args[9] = {
+		EJIT_ARG(&out, void *),
+		EJIT_ARG(in.a, int8_t),
+		EJIT_ARG(in.b, int16_t),
+		EJIT_ARG(in.c, int32_t),
+		EJIT_ARG(in.d, long),
+		EJIT_ARG(in.e, uint16_t),
+		EJIT_ARG(in.f, float),
+		EJIT_ARG(in.g, double),
+		EJIT_ARG(in.h, float)
+	};
+	assert((void *)ejit_run_func(f, 8, args) == &out);
+	assert(in.a == out.a);
+	assert(in.b == out.b);
+	assert(in.c == out.c);
+	assert(in.d == out.d);
+	assert(in.e == out.e);
+	assert(in.f == out.f);
+	assert(in.g == out.g);
+	assert(in.h == out.h);
+
+	ejit_destroy_func(f);
 }
diff --git a/tests/cas_atomic.c b/tests/cas_atomic.c
deleted file mode 100644
index a382eae..0000000
--- a/tests/cas_atomic.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "test.h"
-
-static long data[] = { 0x12121212, 0x00000000, 0x34343434 };
-
-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_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-	                jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1),
-	                jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R2));
-
-	jit_cas_atomic(j, JIT_R0, JIT_R0, JIT_R1, JIT_R2);
-	jit_leave_jit_abi(j, 0, 0, align);
-	jit_ret(j);
-
-	void (*f)(void*, int32_t, int32_t) = jit_end(j, NULL);
-
-	ASSERT(data[0] == 0x12121212);
-	ASSERT(data[1] == 0x00);
-	ASSERT(data[2] == 0x34343434);
-	f(&data[1], 0, 0x0f0f0f0f);
-	ASSERT(data[0] == 0x12121212);
-	ASSERT(data[1] == 0x0f0f0f0f);
-	ASSERT(data[2] == 0x34343434);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/comr.c b/tests/comr.c
index 3cfacac..a6b6dc3 100644
--- a/tests/comr.c
+++ b/tests/comr.c
@@ -1,41 +1,61 @@
-#include "test.h"
+#include <ejit/ejit.h>
+#include <assert.h>
+#include "do_jit.h"
 
-static void
-run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
+int main()
 {
-	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);
-
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0) == 0xffffffff);
-	ASSERT(f(1) == 0xfffffffe);
-	ASSERT(f(0xffffffff) == 0);
-	ASSERT(f(0x80000000) == 0x7fffffff);
-	ASSERT(f(0x7fffffff) == 0x80000000);
-	ASSERT(f(0x80000001) == 0x7ffffffe);
-#else
-	ASSERT(f(0) == 0xffffffffffffffff);
-	ASSERT(f(1) == 0xfffffffffffffffe);
-	ASSERT(f(0xffffffff) == 0xffffffff00000000);
-	ASSERT(f(0x80000000) == 0xffffffff7fffffff);
-	ASSERT(f(0x7fffffff) == 0xffffffff80000000);
-	ASSERT(f(0x80000001) == 0xffffffff7ffffffe);
-	ASSERT(f(0xffffffffffffffff) == 0);
-	ASSERT(f(0x8000000000000000) == 0x7fffffffffffffff);
-	ASSERT(f(0x7fffffffffffffff) == 0x8000000000000000);
-	ASSERT(f(0x8000000000000001) == 0x7ffffffffffffffe);
-#endif
-}
+	struct ejit_operand operands[1] = {
+		EJIT_OPERAND_GPR(0, EJIT_TYPE(long))
+	};
 
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
+	struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 1, operands);
+
+	ejit_comr(f, EJIT_GPR(0), EJIT_GPR(0));
+	ejit_retr(f, EJIT_GPR(0));
+
+	ejit_select_compile_func(f, 1, 0, EJIT_USE64(long), do_jit);
+
+	assert((int32_t)ejit_run_func_1(f, EJIT_ARG(0, long))
+	       == (int32_t)0xffffffff);
+
+	assert((int32_t)ejit_run_func_1(f, EJIT_ARG(1, long))
+	       == (int32_t)0xfffffffe);
+
+	assert((int32_t)ejit_run_func_1(f, EJIT_ARG(0xffffffff, long)) == 0);
+	assert((int32_t)ejit_run_func_1(f, EJIT_ARG(0x80000000, long))
+	       == 0x7fffffff);
+
+	assert((int32_t)ejit_run_func_1(f, EJIT_ARG(0x7fffffff, long))
+	       == (int32_t)0x80000000);
+
+	assert((int32_t)ejit_run_func_1(f, EJIT_ARG(0x80000001, long))
+	       == (int32_t)0x7ffffffe);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(0, long))
+	       == (int64_t)0xffffffffffffffff);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(1, long))
+	       == (int64_t)0xfffffffffffffffe);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(0xffffffff, long))
+	       == (int64_t)0xffffffff00000000);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(0x80000000, long))
+	       == (int64_t)0xffffffff7fffffff);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(0x7fffffff, long))
+	       == (int64_t)0xffffffff80000000);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(0x80000001, long))
+	       == (int64_t)0xffffffff7ffffffe);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(0xffffffffffffffff, long)) == 0);
+	assert(ejit_run_func_1(f, EJIT_ARG(0x8000000000000000, long))
+	       == (int64_t)0x7fffffffffffffff);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(0x7fffffffffffffff, long))
+	       == (int64_t)0x8000000000000000);
+
+	assert(ejit_run_func_1(f, EJIT_ARG(0x8000000000000001, long))
+	       == (int64_t)0x7ffffffffffffffe);
 }
diff --git a/tests/divr.c b/tests/divr.c
index c68fcaa..e16a8bf 100644
--- a/tests/divr.c
+++ b/tests/divr.c
@@ -1,60 +1,152 @@
-#include "test.h"
+#include <ejit/ejit.h>
+#include <assert.h>
+#include "do_jit.h"
 
-static void
-run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
+int main()
 {
-	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;
-	void* ret = jit_end(j, &size);
-
-	jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
-
-	ASSERT(f(0x7fffffff, 1) == 0x7fffffff);
-	ASSERT(f(1, 0x7fffffff) == 0);
-	ASSERT(f(0x80000000, 1) == 0x80000000);
-	ASSERT(f(1, 0x80000000) == 0);
-	ASSERT(f(0x7fffffff, 2) == 0x3fffffff);
-	ASSERT(f(2, 0x7fffffff) == 0);
-	ASSERT(f(2, 0x80000000) == 0);
-	ASSERT(f(0x7fffffff, 0x80000000) == 0);
-	ASSERT(f(0, 0x7fffffff) == 0);
-	ASSERT(f(0xffffffff, 0xffffffff) == 1);
-#if EJIT_WORDSIZE == 32
-	ASSERT(f(0x80000000, 2) == 0xc0000000);
-	ASSERT(f(0x80000000, 0x7fffffff) == 0xffffffff);
-	ASSERT(f(0x7fffffff, 0xffffffff) == 0x80000001);
-	ASSERT(f(0xffffffff, 0x7fffffff) == 0);
-#else
-	ASSERT(f(0x80000000, 2) == 0x40000000);
-	ASSERT(f(0x80000000, 0x7fffffff) == 1);
-	ASSERT(f(0x7fffffff, 0xffffffff) == 0);
-	ASSERT(f(0xffffffff, 0x7fffffff) == 2);
-	ASSERT(f(0x7fffffffffffffff, 1) == 0x7fffffffffffffff);
-	ASSERT(f(1, 0x7fffffffffffffff) == 0);
-	ASSERT(f(0x8000000000000000, 1) == 0x8000000000000000);
-	ASSERT(f(1, 0x8000000000000000) == 0);
-	ASSERT(f(0x7fffffffffffffff, 2) == 0x3fffffffffffffff);
-	ASSERT(f(2, 0x7fffffffffffffff) == 0);
-	ASSERT(f(0x8000000000000000, 2) == 0xc000000000000000);
-	ASSERT(f(2, 0x8000000000000000) == 0);
-	ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == 0);
-	ASSERT(f(0x8000000000000000, 0x7fffffffffffffff) == 0xffffffffffffffff);
-	ASSERT(f(0x7fffffffffffffff, 0xffffffffffffffff) == 0x8000000000000001);
-	ASSERT(f(0xffffffffffffffff, 0x7fffffffffffffff) == 0);
-	ASSERT(f(0xffffffffffffffff, 0xffffffffffffffff) == 1);
-#endif
-}
+	struct ejit_operand operands[2] = {
+		EJIT_OPERAND_GPR(0, EJIT_TYPE(long)),
+		EJIT_OPERAND_GPR(1, EJIT_TYPE(long))
+	};
+	struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands);
 
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
+	ejit_divr(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1));
+	ejit_retr(f, EJIT_GPR(0));
+
+	ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x7fffffff, long),
+	                       EJIT_ARG(1, long)) == 0x7fffffff);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(1, long),
+	                       EJIT_ARG(0x7fffffff, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x80000000, long),
+	                       EJIT_ARG(1, long)) == 0x80000000);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(1, long),
+	                       EJIT_ARG(0x80000000, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x7fffffff, long),
+	                       EJIT_ARG(2, long)) == 0x3fffffff);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(2, long),
+	                       EJIT_ARG(0x7fffffff, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(2, long),
+	                       EJIT_ARG(0x80000000, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x7fffffff, long),
+	                       EJIT_ARG(0x80000000, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0, long),
+	                       EJIT_ARG(0x7fffffff, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0xffffffff, long),
+	                       EJIT_ARG(0xffffffff, long)) == 1);
+
+#warning "Some 32bit handling still unclear"
+	/* 32bit specific stuff, unsure how this should be handled on 64bit
+	 * systems
+	   assert(ejit_run_func_2(f,
+	                        EJIT_ARG(0x80000000, long),
+	                        EJIT_ARG(2, long)) == 0xc0000000);
+
+	   assert(ejit_run_func_2(f,
+	                        EJIT_ARG(0x80000000, long),
+	                        EJIT_ARG(0x7fffffff, long)) == 0xffffffff);
+
+	   assert(ejit_run_func_2(f,
+	                        EJIT_ARG(0x7fffffff, long),
+	                        EJIT_ARG(0xffffffff, long)) == 0x80000001);
+
+	   assert(ejit_run_func_2(f,
+	                        EJIT_ARG(0xffffffff, long),
+	                        EJIT_ARG(0x7fffffff, long)) == 0);
+	 */
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x80000000, long),
+	                       EJIT_ARG(2, long)) == 0x40000000);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x80000000, long),
+	                       EJIT_ARG(0x7fffffff, long)) == 1);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x7fffffff, long),
+	                       EJIT_ARG(0xffffffff, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0xffffffff, long),
+	                       EJIT_ARG(0x7fffffff, long)) == 2);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x7fffffffffffffff, long),
+	                       EJIT_ARG(1, long)) == 0x7fffffffffffffff);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(1, long),
+	                       EJIT_ARG(0x7fffffffffffffff, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x8000000000000000, long),
+	                       EJIT_ARG(1, long))
+	       == (int64_t)0x8000000000000000);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(1, long),
+	                       EJIT_ARG(0x8000000000000000, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x7fffffffffffffff, long),
+	                       EJIT_ARG(2, long))
+	       == (int64_t)0x3fffffffffffffff);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(2, long),
+	                       EJIT_ARG(0x7fffffffffffffff, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x8000000000000000, long),
+	                       EJIT_ARG(2, long))
+	       == (int64_t)0xc000000000000000);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(2, long),
+	                       EJIT_ARG(0x8000000000000000, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x7fffffffffffffff, long),
+	                       EJIT_ARG(0x8000000000000000, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x8000000000000000, long),
+	                       EJIT_ARG(0x7fffffffffffffff, long))
+	       == (int32_t)0xffffffffffffffff);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0x7fffffffffffffff, long),
+	                       EJIT_ARG(0xffffffffffffffff, long))
+	       == (int32_t)0x8000000000000001);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0xffffffffffffffff, long),
+	                       EJIT_ARG(0x7fffffffffffffff, long)) == 0);
+
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(0xffffffffffffffff, long),
+	                       EJIT_ARG(0xffffffffffffffff, long)) == 1);
+
+	ejit_destroy_func(f);
 }
diff --git a/tests/divr_f.c b/tests/divr_f.c
index 085ecff..081c63d 100644
--- a/tests/divr_f.c
+++ b/tests/divr_f.c
@@ -1,27 +1,27 @@
-#include "test.h"
+#include <ejit/ejit.h>
+#include <assert.h>
+#include "do_jit.h"
 
-static void
-run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
+int main()
 {
-	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));
+	struct ejit_operand operands[2] = {
+		EJIT_OPERAND_FPR(0, EJIT_TYPE(double)),
+		EJIT_OPERAND_FPR(1, EJIT_TYPE(double))
+	};
+	struct ejit_func *f = ejit_create_func(EJIT_TYPE(double), 2, operands);
 
-	jit_divr_f(j, JIT_F0, JIT_F0, JIT_F1);
-	jit_leave_jit_abi(j, 0, 0, align);
-	jit_retr_f(j, JIT_F0);
+	ejit_divr_f(f, EJIT_FPR(0), EJIT_FPR(0), EJIT_FPR(1));
+	ejit_retr_f(f, EJIT_FPR(0));
 
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
+	ejit_select_compile_func(f, 0, 2, EJIT_USE64(double), do_jit);
 
-	float (*f)(float, float) = ret;
-	ASSERT(f(-0.5f, 0.5f) == -1.0f);
-	ASSERT(f(1.25f, 0.5f) == 2.5f);
-}
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(-0.5f, double),
+	                       EJIT_ARG(0.5f, double)) == -1.0f);
 
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(1.25f, double),
+	                       EJIT_ARG(0.5f, double)) == 2.5f);
+
+	ejit_destroy_func(f);
 }
diff --git a/tests/divr_u.c b/tests/divr_u.c
index 65d0ae2..1af4874 100644
--- a/tests/divr_u.c
+++ b/tests/divr_u.c
@@ -1,55 +1,87 @@
-#include "test.h"
+#include <ejit/ejit.h>
+#include <assert.h>
+#include "do_jit.h"
 
-static void
-run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
+int main()
 {
-	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;
-	void* ret = jit_end(j, &size);
-
-	jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
-
-	ASSERT(f(0x7fffffff, 1) == 0x7fffffff);
-	ASSERT(f(1, 0x7fffffff) == 0);
-	ASSERT(f(0x80000000, 1) == 0x80000000);
-	ASSERT(f(1, 0x80000000) == 0);
-	ASSERT(f(0x7fffffff, 2) == 0x3fffffff);
-	ASSERT(f(2, 0x7fffffff) == 0);
-	ASSERT(f(0x80000000, 2) == 0x40000000);
-	ASSERT(f(2, 0x80000000) == 0);
-	ASSERT(f(0x7fffffff, 0x80000000) == 0);
-	ASSERT(f(0x80000000, 0x7fffffff) == 1);
-	ASSERT(f(0, 0x7fffffff) == 0);
-	ASSERT(f(0x7fffffff, 0xffffffff) == 0);
-	ASSERT(f(0xffffffff, 0x7fffffff) == 2);
-	ASSERT(f(0xffffffff, 0xffffffff) == 1);
-#if EJIT_WORDSIZE != 32
-	ASSERT(f(0x7fffffffffffffff, 1) == 0x7fffffffffffffff);
-	ASSERT(f(1, 0x7fffffffffffffff) == 0);
-	ASSERT(f(0x8000000000000000, 1) == 0x8000000000000000);
-	ASSERT(f(1, 0x8000000000000000) == 0);
-	ASSERT(f(0x7fffffffffffffff, 2) == 0x3fffffffffffffff);
-	ASSERT(f(2, 0x7fffffffffffffff) == 0);
-	ASSERT(f(0x8000000000000000, 2) == 0x4000000000000000);
-	ASSERT(f(2, 0x8000000000000000) == 0);
-	ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == 0);
-	ASSERT(f(0x8000000000000000, 0x7fffffffffffffff) == 1);
-	ASSERT(f(0x7fffffffffffffff, 0xffffffffffffffff) == 0);
-	ASSERT(f(0xffffffffffffffff, 0x7fffffffffffffff) == 2);
-	ASSERT(f(0xffffffffffffffff, 0xffffffffffffffff) == 1);
-#endif
-}
+	struct ejit_operand operands[2] = {
+		EJIT_OPERAND_GPR(0, EJIT_TYPE(long)),
+		EJIT_OPERAND_GPR(1, EJIT_TYPE(long))
+	};
+	struct ejit_func *f = ejit_create_func(EJIT_TYPE(long), 2, operands);
 
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
+	ejit_divr_u(f, EJIT_GPR(0), EJIT_GPR(0), EJIT_GPR(1));
+	ejit_retr(f, EJIT_GPR(0));
+
+	ejit_select_compile_func(f, 2, 0, EJIT_USE64(long), do_jit);
+
+	assert(erf2(f, EJIT_ARG(0x7fffffff, long),
+	            EJIT_ARG(1, long)) == 0x7fffffff);
+	assert(erf2(f, EJIT_ARG(0x80000000, long),
+	            EJIT_ARG(1, long)) == 0x80000000);
+	assert(erf2(f, EJIT_ARG(0x7fffffff, long),
+	            EJIT_ARG(2, long)) == 0x3fffffff);
+	assert(erf2(f, EJIT_ARG(0x80000000, long),
+	            EJIT_ARG(2, long)) == 0x40000000);
+	assert(erf2(f, EJIT_ARG(0x7fffffff, long),
+	            EJIT_ARG(0x80000000, long)) == 0);
+	assert(erf2(f, EJIT_ARG(0x80000000, long),
+	            EJIT_ARG(0x7fffffff, long)) == 1);
+	assert(erf2(f, EJIT_ARG(0x7fffffff, long),
+	            EJIT_ARG(0xffffffff, long)) == 0);
+	assert(erf2(f, EJIT_ARG(0xffffffff, long),
+	            EJIT_ARG(0x7fffffff, long)) == 2);
+	assert(erf2(f, EJIT_ARG(0xffffffff, long),
+	            EJIT_ARG(0xffffffff, long)) == 1);
+	assert(erf2(f, EJIT_ARG(1, long), EJIT_ARG(0x7fffffff, long)) == 0);
+	assert(erf2(f, EJIT_ARG(1, long), EJIT_ARG(0x80000000, long)) == 0);
+	assert(erf2(f, EJIT_ARG(2, long), EJIT_ARG(0x7fffffff, long)) == 0);
+	assert(erf2(f, EJIT_ARG(2, long), EJIT_ARG(0x80000000, long)) == 0);
+	assert(erf2(f, EJIT_ARG(0, long), EJIT_ARG(0x7fffffff, long)) == 0);
+	/* wordsize != 64 */
+	assert(erf2(f, EJIT_ARG(0x7fffffffffffffff, long), EJIT_ARG(1, long))
+	       == 0x7fffffffffffffff);
+
+	assert(erf2(f, EJIT_ARG(0x8000000000000000, long), EJIT_ARG(1, long))
+	       == (int64_t)0x8000000000000000);
+
+	assert(erf2(f, EJIT_ARG(0x7fffffffffffffff, long), EJIT_ARG(2, long))
+	       == 0x3fffffffffffffff);
+
+	assert(erf2(f, EJIT_ARG(0x8000000000000000, long), EJIT_ARG(2, long))
+	       == 0x4000000000000000);
+
+	assert(erf2(f, EJIT_ARG(1, long),
+	            EJIT_ARG(0x7fffffffffffffff, long)) == 0);
+
+	assert(erf2(f, EJIT_ARG(1, long),
+	            EJIT_ARG(0x8000000000000000, long)) == 0);
+
+	assert(erf2(f, EJIT_ARG(2, long),
+	            EJIT_ARG(0x7fffffffffffffff, long)) == 0);
+
+	assert(erf2(f, EJIT_ARG(2, long),
+	            EJIT_ARG(0x8000000000000000, long)) == 0);
+
+	assert(erf2(f,
+	            EJIT_ARG(0x7fffffffffffffff, long),
+	            EJIT_ARG(0x8000000000000000, long)) == 0);
+
+	assert(erf2(f,
+	            EJIT_ARG(0x8000000000000000, long),
+	            EJIT_ARG(0x7fffffffffffffff, long)) == 1);
+
+	assert(erf2(f,
+	            EJIT_ARG(0x7fffffffffffffff, long),
+	            EJIT_ARG(0xffffffffffffffff, long)) == 0);
+
+	assert(erf2(f,
+	            EJIT_ARG(0xffffffffffffffff, long),
+	            EJIT_ARG(0x7fffffffffffffff, long)) == 2);
+
+	assert(erf2(f,
+	            EJIT_ARG(0xffffffffffffffff, long),
+	            EJIT_ARG(0xffffffffffffffff, long)) == 1);
+
+	ejit_destroy_func(f);
 }
diff --git a/tests/do_jit.h b/tests/do_jit.h
index d0d4921..637ed7d 100644
--- a/tests/do_jit.h
+++ b/tests/do_jit.h
@@ -7,4 +7,12 @@ static bool do_jit = false;
 static bool do_jit = true;
 #endif
 
+#define erf3 ejit_run_func_3
+#define erf2 ejit_run_func_2
+#define erf1 ejit_run_func_1
+
+#define erff3 ejit_run_func_f_3
+#define erff2 ejit_run_func_f_2
+#define erff1 ejit_run_func_f_1
+
 #endif /* DOJIT_H */
diff --git a/tests/eqr.c b/tests/eqr.c
index 7f33b19..7b8067e 100644
--- a/tests/eqr.c
+++ b/tests/eqr.c
@@ -5,7 +5,7 @@
 int main()
 {
 	struct ejit_operand operands[2] = {
-		EJIT_OPERAND_GPR(0, EJIT_TYPE(long))
+		EJIT_OPERAND_GPR(0, EJIT_TYPE(long)),
 		EJIT_OPERAND_GPR(1, EJIT_TYPE(long))
 	};
 
diff --git a/tests/eqr_f.c b/tests/eqr_f.c
index 7afe002..e11397b 100644
--- a/tests/eqr_f.c
+++ b/tests/eqr_f.c
@@ -5,7 +5,7 @@
 int main()
 {
 	struct ejit_operand operands[2] = {
-		EJIT_OPERAND_FPR(0, EJIT_TYPE(double))
+		EJIT_OPERAND_FPR(0, EJIT_TYPE(double)),
 		EJIT_OPERAND_FPR(1, EJIT_TYPE(double))
 	};
 
@@ -16,17 +16,17 @@ int main()
 
 	ejit_select_compile_func(f, 1, 2, EJIT_USE64(long), do_jit);
 
-	assert(ejit_run_func_2(f, EJIT_ARG(1, double),
+	assert(ejit_run_func_2(f,
+	                       EJIT_ARG(1, double),
 	                       EJIT_ARG(1, double)) == 1);
-	assert(ejit_run_func_2(f, EJIT_ARG(1, double),
-	                       EJIT_ARG(0, double)) == 0);
 
 	assert(ejit_run_func_2(f,
-	                       EJIT_ARG(0x7fffffffffffffff, double),
-	                       EJIT_ARG(0x7ffffffffffffff0, double)) == 0);
+	                       EJIT_ARG(1, double),
+	                       EJIT_ARG(0, double)) == 0);
 
 	assert(ejit_run_func_2(f,
-	                       EJIT_ARG(0x6fffffffffffffff, double),
-	                       EJIT_ARG(0x7fffffffffffffff, double)) == 0);
+	                       EJIT_ARG(0.0/0.0, double),
+	                       EJIT_ARG(0.0/0.0, double)) == 0);
+
 	ejit_destroy_func(f);
 }
diff --git a/tests/escapei_10.c b/tests/escapei_10.c
new file mode 100644
index 0000000..2ca1ea2
--- /dev/null
+++ b/tests/escapei_10.c
@@ -0,0 +1,81 @@
+#include <ejit/ejit.h>
+#include <assert.h>
+#include "do_jit.h"
+
+static int32_t func(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e,
+                    int32_t f, int32_t g, int32_t h, int32_t i, int32_t j)
+{
+	assert(a == 0);
+	assert(b == 1);
+	assert(c == 2);
+	assert(d == 3);
+	assert(e == 4);
+	assert(f == 5);
+	assert(g == 6);
+	assert(h == 7);
+	assert(i == 8);
+	assert(j == 9);
+	return 42;
+}
+
+static long escape_func(size_t argc, const struct ejit_arg args[argc])
+{
+	assert(argc == 10);
+	assert(args[0].type == EJIT_INT32);
+	assert(args[1].type == EJIT_INT32);
+	assert(args[3].type == EJIT_INT32);
+	assert(args[4].type == EJIT_INT32);
+	assert(args[5].type == EJIT_INT32);
+	assert(args[6].type == EJIT_INT32);
+	assert(args[7].type == EJIT_INT32);
+	assert(args[8].type == EJIT_INT32);
+	assert(args[9].type == EJIT_INT32);
+
+	int32_t a = args[0].i32;
+	int32_t b = args[1].i32;
+	int32_t c = args[2].i32;
+	int32_t d = args[3].i32;
+	int32_t e = args[4].i32;
+	int32_t f = args[5].i32;
+	int32_t g = args[6].i32;
+	int32_t h = args[7].i32;
+	int32_t i = args[8].i32;
+	int32_t j = args[9].i32;
+	return func(a, b, c, d, e, f, g, h, i, j);
+}
+
+int main()
+{
+	struct ejit_operand operands[1] = {
+		EJIT_OPERAND_GPR(0, EJIT_POINTER)
+	};
+	struct ejit_func *f = ejit_create_func(EJIT_INT32, 1, operands);
+	/* move from argument array to registers */
+	for (size_t i = 0; i < 10; ++i) {
+		ejit_ldxi_i32(f, EJIT_GPR(i + 1), EJIT_GPR(0),
+		              i * sizeof(int32_t));
+	}
+
+	struct ejit_operand args[10] = {
+		EJIT_OPERAND_GPR( 1, EJIT_INT32),
+		EJIT_OPERAND_GPR( 2, EJIT_INT32),
+		EJIT_OPERAND_GPR( 3, EJIT_INT32),
+		EJIT_OPERAND_GPR( 4, EJIT_INT32),
+		EJIT_OPERAND_GPR( 5, EJIT_INT32),
+		EJIT_OPERAND_GPR( 6, EJIT_INT32),
+		EJIT_OPERAND_GPR( 7, EJIT_INT32),
+		EJIT_OPERAND_GPR( 8, EJIT_INT32),
+		EJIT_OPERAND_GPR( 9, EJIT_INT32),
+		EJIT_OPERAND_GPR(10, EJIT_INT32),
+	};
+	ejit_escapei(f, escape_func, 10, args);
+	ejit_retval(f, EJIT_GPR(0));
+	ejit_retr(f, EJIT_GPR(0));
+
+	ejit_select_compile_func(f, 11, 0, false, do_jit);
+
+	int32_t iargs[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+	assert(ejit_run_func_1(f, EJIT_ARG(iargs, void *)) == 42);
+
+	ejit_destroy_func(f);
+}
diff --git a/tests/escapei_double.c b/tests/escapei_double.c
new file mode 100644
index 0000000..3165ece
--- /dev/null
+++ b/tests/escapei_double.c
@@ -0,0 +1,43 @@
+#include <ejit/ejit.h>
+#include <assert.h>
+#include "do_jit.h"
+
+static double func(int32_t a, double b) {
+	return b + a;
+}
+
+static double escape_func(size_t argc, const struct ejit_arg args[argc])
+{
+	assert(argc == 2);
+	assert(args[0].type == EJIT_INT32);
+	assert(args[1].type == EJIT_DOUBLE);
+	int32_t a = args[0].i32;
+	double b = args[1].d;
+	return func(a, b);
+}
+
+int main()
+{
+	struct ejit_operand operands[2] = {
+		EJIT_OPERAND_GPR(0, EJIT_POINTER),
+		EJIT_OPERAND_GPR(1, EJIT_POINTER)
+	};
+
+	struct ejit_func *f = ejit_create_func(EJIT_DOUBLE, 2, operands);
+	EJIT_LDXI(f, int32_t, EJIT_GPR(0), EJIT_GPR(0), 0);
+	EJIT_LDXI(f, double, EJIT_FPR(0), EJIT_GPR(1), 0);
+
+	struct ejit_operand args[2] = {
+		EJIT_OPERAND_GPR(0, EJIT_INT32),
+		EJIT_OPERAND_FPR(0, EJIT_DOUBLE)
+	};
+	ejit_escapei_f(f, escape_func, 2, args);
+	ejit_retval_f(f, EJIT_FPR(0));
+	ejit_retr_f(f, EJIT_FPR(0));
+
+	ejit_select_compile_func(f, 2, 1, false, do_jit);
+
+	double d = 22.0f;
+	int32_t i = 20;
+	assert(erff2(f, EJIT_ARG(&i, void *), EJIT_ARG(&d, void *)) == 42.0f);
+}
diff --git a/tests/escapei_float.c b/tests/escapei_float.c
new file mode 100644
index 0000000..a947f24
--- /dev/null
+++ b/tests/escapei_float.c
@@ -0,0 +1,43 @@
+#include <ejit/ejit.h>
+#include <assert.h>
+#include "do_jit.h"
+
+static float func(int32_t a, float b) {
+	return b + a;
+}
+
+static double escape_func(size_t argc, const struct ejit_arg args[argc])
+{
+	assert(argc == 2);
+	assert(args[0].type == EJIT_INT32);
+	assert(args[1].type == EJIT_FLOAT);
+	int32_t a = args[0].i32;
+	float b = args[1].f;
+	return func(a, b);
+}
+
+int main()
+{
+	struct ejit_operand operands[2] = {
+		EJIT_OPERAND_GPR(0, EJIT_POINTER),
+		EJIT_OPERAND_GPR(1, EJIT_POINTER)
+	};
+
+	struct ejit_func *f = ejit_create_func(EJIT_FLOAT, 2, operands);
+	EJIT_LDXI(f, int32_t, EJIT_GPR(0), EJIT_GPR(0), 0);
+	EJIT_LDXI(f, float, EJIT_FPR(0), EJIT_GPR(1), 0);
+
+	struct ejit_operand args[2] = {
+		EJIT_OPERAND_GPR(0, EJIT_INT32),
+		EJIT_OPERAND_FPR(0, EJIT_FLOAT)
+	};
+	ejit_escapei_f(f, escape_func, 2, args);
+	ejit_retval_f(f, EJIT_FPR(0));
+	ejit_retr_f(f, EJIT_FPR(0));
+
+	ejit_select_compile_func(f, 2, 1, false, do_jit);
+
+	float d = 22.0f;
+	int32_t i = 20;
+	assert(erff2(f, EJIT_ARG(&i, void *), EJIT_ARG(&d, void *)) == 42.0f);
+}
diff --git a/tests/qdivr.c b/tests/qdivr.c
deleted file mode 100644
index c559802..0000000
--- a/tests/qdivr.c
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "test.h"
-
-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, 3, 0, 0);
-
-	jit_operand_t args[] =
-	{ jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-	  jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1),
-	  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
-	  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_V0) };
-	jit_load_args(j, 4, args);
-
-	jit_qdivr(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
-	jit_str(j, JIT_R0, JIT_V1);
-	jit_str(j, JIT_R1, JIT_V2);
-
-	jit_leave_jit_abi(j, 3, 0, align);
-
-	jit_ret(j);
-
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
-
-	void (*f)(jit_word_t*, jit_word_t*, jit_word_t, jit_word_t) = ret;
-
-#define QDIV(a, b, c, d)                                                  \
-	do {                                                              \
-		jit_word_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); \
-		ASSERT(D == d);                                           \
-	} while (0)
-
-	QDIV(10, 3, 3, 1);
-	QDIV(-33, 9, -3, -6);
-	QDIV(-41, -7, 5, -6);
-	QDIV(65536, 4096, 16, 0);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/qdivr_u.c b/tests/qdivr_u.c
deleted file mode 100644
index df215ec..0000000
--- a/tests/qdivr_u.c
+++ /dev/null
@@ -1,43 +0,0 @@
-#include "test.h"
-
-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, 3, 0, 0);
-
-	jit_operand_t args[] =
-	{ jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-	  jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1),
-	  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
-	  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_V0) };
-	jit_load_args(j, 4, args);
-
-	jit_qdivr_u(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
-	jit_str(j, JIT_R0, JIT_V1);
-	jit_str(j, JIT_R1, JIT_V2);
-
-	jit_leave_jit_abi(j, 3, 0, align);
-
-	jit_ret(j);
-
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
-
-	void (*f)(jit_word_t*, jit_word_t*, jit_word_t, jit_word_t) = ret;
-#define QDIV(a, b, c, d)                                                  \
-	do {                                                              \
-		jit_word_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); \
-		ASSERT(D == d);                                           \
-	} while (0)
-
-	QDIV(-1, -2, 1, 1);
-	QDIV(-2, -5, 1, 3);
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/qmulr.c b/tests/qmulr.c
deleted file mode 100644
index b7aa5e8..0000000
--- a/tests/qmulr.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "test.h"
-
-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, 3, 0, 0);
-
-	jit_operand_t args[] =
-	{ jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-	  jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1),
-	  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
-	  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_V0) };
-	jit_load_args(j, 4, args);
-
-	jit_qmulr(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
-	jit_str(j, JIT_R0, JIT_V1);
-	jit_str(j, JIT_R1, JIT_V2);
-
-	jit_leave_jit_abi(j, 3, 0, align);
-
-	jit_ret(j);
-
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
-
-	void (*f)(jit_word_t*, jit_word_t*, jit_word_t, jit_word_t) = ret;
-
-#define QMUL(a, b, c, d)                                                  \
-	do {                                                              \
-		jit_word_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); \
-		ASSERT(D == d);                                           \
-	} while (0)
-
-	QMUL(-2, -1, 2, 0);
-	QMUL(0, -1, 0, 0);
-	QMUL(-1, 0, 0, 0);
-	QMUL(1, -1, -1, -1);
-#if EJIT_WORDSIZE == 32
-	QMUL(0x7ffff, 0x7ffff, 0xfff00001, 0x3f);
-	QMUL(0x80000000, -2, 0, 1);
-	QMUL(0x80000000, 2, 0, -1);
-	QMUL(0x80000001, 3, 0x80000003, -2);
-	QMUL(0x80000001, -3, 0x7ffffffd, 1);
-#else
-	QMUL(0x7ffffffff, 0x7ffffffff, 0xfffffff000000001, 0x3f);
-	QMUL(0x8000000000000000, -2, 0, 1);
-	QMUL(0x8000000000000000, 2, 0, -1);
-	QMUL(0x8000000000000001, 3, 0x8000000000000003, -2);
-	QMUL(0x8000000000000001, -3, 0x7ffffffffffffffd, 1);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/qmulr_u.c b/tests/qmulr_u.c
deleted file mode 100644
index 3840c92..0000000
--- a/tests/qmulr_u.c
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "test.h"
-
-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, 3, 0, 0);
-
-	jit_operand_t args[] =
-	{ jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
-	  jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1),
-	  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
-	  jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_V0) };
-	jit_load_args(j, 4, args);
-
-	jit_qmulr_u(j, JIT_V1, JIT_V2, JIT_R2, JIT_V0);
-	jit_str(j, JIT_R0, JIT_V1);
-	jit_str(j, JIT_R1, JIT_V2);
-
-	jit_leave_jit_abi(j, 3, 0, align);
-
-	jit_ret(j);
-
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
-
-	void (*f)(jit_word_t*, jit_word_t*, jit_word_t, jit_word_t) = ret;
-
-#define UQMUL(a, b, c, d)                                                 \
-	do {                                                              \
-		jit_word_t C = 0, D = 0; f(&C, &D, a, b); ASSERT(C == c); \
-		ASSERT(D == d);                                           \
-	} while (0)
-
-#if EJIT_WORDSIZE == 32
-	UQMUL(0xffffff, 0xffffff, 0xfe000001, 0xffff);
-#else
-	UQMUL(0xffffffffff, 0xffffffffff, 0xfffffe0000000001, 0xffff);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/sqrtr_f.c b/tests/sqrtr_f.c
deleted file mode 100644
index 7735f68..0000000
--- a/tests/sqrtr_f.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "test.h"
-
-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_sqrtr_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);
-
-	ASSERT(f(0.0) == 0.0);
-	ASSERT(f(4.0) == 2.0);
-	ASSERT(f(-4.0) != f(-4.0)); // nan
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}
diff --git a/tests/subx.c b/tests/subx.c
deleted file mode 100644
index b2bb3c2..0000000
--- a/tests/subx.c
+++ /dev/null
@@ -1,63 +0,0 @@
-#include "test.h"
-
-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_subcr(j, JIT_R0, JIT_R0, JIT_R1);
-	jit_subxi(j, JIT_R2, JIT_R2, 0);
-	jit_leave_jit_abi(j, 0, 0, align);
-	jit_retr(j, JIT_R2);
-
-	size_t size = 0;
-	void* ret = jit_end(j, &size);
-
-	jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
-
-	ASSERT(f(0, 0) == 0);
-
-#if EJIT_WORDSIZE == 32
-	/* carry */
-	ASSERT(f(0x7fffffff, 0xffffffff) == 0xffffffff);
-	/* overflow */
-	ASSERT(f(0x80000000, 1) == 0);
-	/* carry */
-	ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
-	/* overflow */
-	ASSERT(f(0x80000000, 0x7fffffff) == 0);
-	/* carry+overflow */
-	ASSERT(f(1, 0x80000000) == 0xffffffff);
-#else
-	/* carry */
-	ASSERT(f(0x7fffffff, 0xffffffff) == -1);
-	/* nothing */
-	ASSERT(f(0x80000000, 1) == 0);
-	/* carry */
-	ASSERT(f(0x7fffffff, 0x80000000) == -1);
-	/* nothing */
-	ASSERT(f(0x80000000, 0x7fffffff) == 0);
-	/* carry */
-	ASSERT(f(1, 0x80000000) == -1);
-	/* carry */
-	ASSERT(f(0x7fffffffffffffff, 0xffffffffffffffff) == -1);
-	/* overflow */
-	ASSERT(f(0x8000000000000000, 1) == 0);
-	/* carry */
-	ASSERT(f(0x7fffffffffffffff, 0x8000000000000000) == -1);
-	/* overflow */
-	ASSERT(f(0x8000000000000000, 0x7fffffffffffffff) == 0);
-	/* carry+overflow */
-	ASSERT(f(1, 0x8000000000000000) == -1);
-#endif
-}
-
-int
-main (int argc, char *argv[])
-{
-	return main_helper(argc, argv, run_test);
-}