Add {enter,leave}_jit_abi calls in tests

This saves and restores RBP on x86-32.

188 files changed, 438 insertions, 8 deletions

diff --git a/tests/absr_d.c b/tests/absr_d.c
index 93b10b673..00b8fa460 100644
--- a/tests/absr_d.c
+++ b/tests/absr_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_absr_d(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(double) = jit_end(j, NULL);
diff --git a/tests/absr_f.c b/tests/absr_f.c
index 64463bf89..e019b5ff3 100644
--- a/tests/absr_f.c
+++ b/tests/absr_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_absr_f(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(float) = jit_end(j, NULL);
diff --git a/tests/addi.c b/tests/addi.c
index 85d4d8e9b..756d07061 100644
--- a/tests/addi.c
+++ b/tests/addi.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_addi(j, JIT_R0, JIT_R0, 69);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/addr.c b/tests/addr.c
index a54f75661..6ee76e291 100644
--- a/tests/addr.c
+++ b/tests/addr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_addr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/addr_d.c b/tests/addr_d.c
index 8c7be6298..11216202e 100644
--- a/tests/addr_d.c
+++ b/tests/addr_d.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_addr_d(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   size_t size = 0;
diff --git a/tests/addr_f.c b/tests/addr_f.c
index 1ed1f36b4..4317dfe3a 100644
--- a/tests/addr_f.c
+++ b/tests/addr_f.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_addr_f(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   size_t size = 0;
diff --git a/tests/addx.c b/tests/addx.c
index 875e09f42..417cd1a26 100644
--- a/tests/addx.c
+++ b/tests/addx.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_movi(j, JIT_R2, 0);
   jit_addcr(j, JIT_R0, JIT_R0, JIT_R1);
   jit_addxi(j, JIT_R2, JIT_R2, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R2);
 
   size_t size = 0;
diff --git a/tests/andi.c b/tests/andi.c
index 2f84d767e..c6f39d7aa 100644
--- a/tests/andi.c
+++ b/tests/andi.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_andi(j, JIT_R0, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/andr.c b/tests/andr.c
index 2e09527b8..1114ef98f 100644
--- a/tests/andr.c
+++ b/tests/andr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_andr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/beqi.c b/tests/beqi.c
index 857d927a5..2fb2454c0 100644
--- a/tests/beqi.c
+++ b/tests/beqi.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_beqi(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/beqr.c b/tests/beqr.c
index e8bacd017..d1d80b266 100644
--- a/tests/beqr.c
+++ b/tests/beqr.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_beqr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/beqr_d.c b/tests/beqr_d.c
index 1b7f88b25..a84b6a76a 100644
--- a/tests/beqr_d.c
+++ b/tests/beqr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_beqr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/beqr_f.c b/tests/beqr_f.c
index 85b464f8f..7b5cc2708 100644
--- a/tests/beqr_f.c
+++ b/tests/beqr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_beqr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bgei.c b/tests/bgei.c
index 939e1a02f..b9a830b5d 100644
--- a/tests/bgei.c
+++ b/tests/bgei.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bgei(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bgei_u.c b/tests/bgei_u.c
index b5253e931..894c275e1 100644
--- a/tests/bgei_u.c
+++ b/tests/bgei_u.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bgei_u(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bger.c b/tests/bger.c
index d59e4f456..daab88c39 100644
--- a/tests/bger.c
+++ b/tests/bger.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bger(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bger_d.c b/tests/bger_d.c
index 281803dc6..712b118ea 100644
--- a/tests/bger_d.c
+++ b/tests/bger_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bger_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bger_f.c b/tests/bger_f.c
index d9c556c23..b9d547861 100644
--- a/tests/bger_f.c
+++ b/tests/bger_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bger_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bger_u.c b/tests/bger_u.c
index 13c6a1dc4..5c07f442d 100644
--- a/tests/bger_u.c
+++ b/tests/bger_u.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bger_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bgti.c b/tests/bgti.c
index 36df65930..4bfd36e1f 100644
--- a/tests/bgti.c
+++ b/tests/bgti.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bgti(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bgti_u.c b/tests/bgti_u.c
index c5be4e3f3..b4da14e01 100644
--- a/tests/bgti_u.c
+++ b/tests/bgti_u.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bgti_u(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bgtr.c b/tests/bgtr.c
index 222816a26..dbf5fdd50 100644
--- a/tests/bgtr.c
+++ b/tests/bgtr.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bgtr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bgtr_d.c b/tests/bgtr_d.c
index f2892ab83..d3c24362a 100644
--- a/tests/bgtr_d.c
+++ b/tests/bgtr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bgtr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bgtr_f.c b/tests/bgtr_f.c
index 4ac08a344..91cb8c046 100644
--- a/tests/bgtr_f.c
+++ b/tests/bgtr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bgtr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bgtr_u.c b/tests/bgtr_u.c
index 23ade0931..2ed4d8eda 100644
--- a/tests/bgtr_u.c
+++ b/tests/bgtr_u.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bgtr_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/blei.c b/tests/blei.c
index 4303cae13..cb9eacb9c 100644
--- a/tests/blei.c
+++ b/tests/blei.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_blei(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/blei_u.c b/tests/blei_u.c
index 23c02729d..efe0523c5 100644
--- a/tests/blei_u.c
+++ b/tests/blei_u.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_blei_u(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bler.c b/tests/bler.c
index 0d3f160d9..57371fb18 100644
--- a/tests/bler.c
+++ b/tests/bler.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bler(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bler_d.c b/tests/bler_d.c
index 7d5253160..507dac506 100644
--- a/tests/bler_d.c
+++ b/tests/bler_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bler_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bler_f.c b/tests/bler_f.c
index 5d57bc11d..191b6492c 100644
--- a/tests/bler_f.c
+++ b/tests/bler_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bler_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bler_u.c b/tests/bler_u.c
index a4caf5b31..4269fee10 100644
--- a/tests/bler_u.c
+++ b/tests/bler_u.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bler_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bltgtr_d.c b/tests/bltgtr_d.c
index 21fa5467e..3d8835dbd 100644
--- a/tests/bltgtr_d.c
+++ b/tests/bltgtr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bltgtr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bltgtr_f.c b/tests/bltgtr_f.c
index 872fbb3c3..fbdbc3b30 100644
--- a/tests/bltgtr_f.c
+++ b/tests/bltgtr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bltgtr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/blti.c b/tests/blti.c
index a011f5a6c..fcdeb15b4 100644
--- a/tests/blti.c
+++ b/tests/blti.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_blti(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/blti_u.c b/tests/blti_u.c
index b4afe71f5..e90f1938e 100644
--- a/tests/blti_u.c
+++ b/tests/blti_u.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_blti_u(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bltr.c b/tests/bltr.c
index d9d252007..901f6c4b4 100644
--- a/tests/bltr.c
+++ b/tests/bltr.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bltr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bltr_d.c b/tests/bltr_d.c
index a1b60a314..2d6260931 100644
--- a/tests/bltr_d.c
+++ b/tests/bltr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bltr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bltr_f.c b/tests/bltr_f.c
index adbafec37..eebd3da0c 100644
--- a/tests/bltr_f.c
+++ b/tests/bltr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bltr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bltr_u.c b/tests/bltr_u.c
index 4ec33c26b..9df16fc1d 100644
--- a/tests/bltr_u.c
+++ b/tests/bltr_u.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bltr_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bmci.c b/tests/bmci.c
index 55cd4a33a..608d6667b 100644
--- a/tests/bmci.c
+++ b/tests/bmci.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bmci(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bmcr.c b/tests/bmcr.c
index 00dad50d2..df7e04641 100644
--- a/tests/bmcr.c
+++ b/tests/bmcr.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bmcr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bmsi.c b/tests/bmsi.c
index a51616427..82c2ba7ea 100644
--- a/tests/bmsi.c
+++ b/tests/bmsi.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bmsi(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bmsr.c b/tests/bmsr.c
index 79a9d235f..8caa7e0e7 100644
--- a/tests/bmsr.c
+++ b/tests/bmsr.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bmsr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bnei.c b/tests/bnei.c
index 3b064820b..73e38a7db 100644
--- a/tests/bnei.c
+++ b/tests/bnei.c
@@ -4,11 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bnei(j, JIT_R0, 0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bner.c b/tests/bner.c
index 2e1321682..e6515865e 100644
--- a/tests/bner.c
+++ b/tests/bner.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bner(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bner_d.c b/tests/bner_d.c
index 3f29d460b..079fda466 100644
--- a/tests/bner_d.c
+++ b/tests/bner_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bner_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bner_f.c b/tests/bner_f.c
index e43ddf9e8..011df67b2 100644
--- a/tests/bner_f.c
+++ b/tests/bner_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bner_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/boaddi.c b/tests/boaddi.c
index 6dcc4ea5e..1e47297c4 100644
--- a/tests/boaddi.c
+++ b/tests/boaddi.c
@@ -6,12 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_boaddi(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/boaddi_u.c b/tests/boaddi_u.c
index 364c71c96..21c71dfb9 100644
--- a/tests/boaddi_u.c
+++ b/tests/boaddi_u.c
@@ -6,12 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_boaddi_u(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/boaddr.c b/tests/boaddr.c
index c07417c20..8bab91ef1 100644
--- a/tests/boaddr.c
+++ b/tests/boaddr.c
@@ -6,13 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_boaddr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/boaddr_u.c b/tests/boaddr_u.c
index b186a90ce..f4bacde65 100644
--- a/tests/boaddr_u.c
+++ b/tests/boaddr_u.c
@@ -6,13 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_boaddr_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bordr_d.c b/tests/bordr_d.c
index 9a611db0a..9227f2223 100644
--- a/tests/bordr_d.c
+++ b/tests/bordr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bordr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bordr_f.c b/tests/bordr_f.c
index fcfac6e86..25808e51f 100644
--- a/tests/bordr_f.c
+++ b/tests/bordr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bordr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bosubi.c b/tests/bosubi.c
index 41e624517..f10d90a75 100644
--- a/tests/bosubi.c
+++ b/tests/bosubi.c
@@ -6,12 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bosubi(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bosubi_u.c b/tests/bosubi_u.c
index b494a7d92..50af6ad56 100644
--- a/tests/bosubi_u.c
+++ b/tests/bosubi_u.c
@@ -6,12 +6,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bosubi_u(j, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bosubr.c b/tests/bosubr.c
index 17da71f83..cf68ad625 100644
--- a/tests/bosubr.c
+++ b/tests/bosubr.c
@@ -6,13 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bosubr(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bosubr_u.c b/tests/bosubr_u.c
index a3d8ae355..b5e6b39a0 100644
--- a/tests/bosubr_u.c
+++ b/tests/bosubr_u.c
@@ -6,13 +6,16 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bosubr_u(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
   jit_patch_here(j, r);
   jit_movi(j, JIT_R0, overflowed);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bswapr_ui.c b/tests/bswapr_ui.c
index 653eb2d42..c1eb9fdc0 100644
--- a/tests/bswapr_ui.c
+++ b/tests/bswapr_ui.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_bswapr_ui(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/bswapr_ul.c b/tests/bswapr_ul.c
index 106a94cef..a3a11b31e 100644
--- a/tests/bswapr_ul.c
+++ b/tests/bswapr_ul.c
@@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_bswapr_ul(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/bswapr_us.c b/tests/bswapr_us.c
index fd0d439f6..0ff777e9e 100644
--- a/tests/bswapr_us.c
+++ b/tests/bswapr_us.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_bswapr_us(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/buneqr_d.c b/tests/buneqr_d.c
index eead53ef3..1d08e325e 100644
--- a/tests/buneqr_d.c
+++ b/tests/buneqr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_buneqr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/buneqr_f.c b/tests/buneqr_f.c
index b64874209..49d9062ee 100644
--- a/tests/buneqr_f.c
+++ b/tests/buneqr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_buneqr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bunger_d.c b/tests/bunger_d.c
index e949c9719..57888af01 100644
--- a/tests/bunger_d.c
+++ b/tests/bunger_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bunger_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bunger_f.c b/tests/bunger_f.c
index 4fc598393..f3103dc9a 100644
--- a/tests/bunger_f.c
+++ b/tests/bunger_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bunger_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bungtr_d.c b/tests/bungtr_d.c
index f00c1ea3d..649d61f30 100644
--- a/tests/bungtr_d.c
+++ b/tests/bungtr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bungtr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bungtr_f.c b/tests/bungtr_f.c
index 722779c0f..fea66dc60 100644
--- a/tests/bungtr_f.c
+++ b/tests/bungtr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bungtr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bunler_d.c b/tests/bunler_d.c
index d3cec1842..e59382c5e 100644
--- a/tests/bunler_d.c
+++ b/tests/bunler_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bunler_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bunler_f.c b/tests/bunler_f.c
index fa3b0ef99..fddce6b94 100644
--- a/tests/bunler_f.c
+++ b/tests/bunler_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bunler_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bunltr_d.c b/tests/bunltr_d.c
index e6adf6d6c..2ab00510b 100644
--- a/tests/bunltr_d.c
+++ b/tests/bunltr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bunltr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bunltr_f.c b/tests/bunltr_f.c
index 4d6048eae..ade228b7b 100644
--- a/tests/bunltr_f.c
+++ b/tests/bunltr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bunltr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bunordr_d.c b/tests/bunordr_d.c
index f9d074b06..6b04f0ee1 100644
--- a/tests/bunordr_d.c
+++ b/tests/bunordr_d.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_reloc_t r = jit_bunordr_d(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(double, double) = jit_end(j, NULL);
diff --git a/tests/bunordr_f.c b/tests/bunordr_f.c
index 5dffc6920..ce4fc7bea 100644
--- a/tests/bunordr_f.c
+++ b/tests/bunordr_f.c
@@ -4,12 +4,15 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_reloc_t r = jit_bunordr_f(j, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 0);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 1);
 
   jit_word_t (*f)(float, float) = jit_end(j, NULL);
diff --git a/tests/bxaddi.c b/tests/bxaddi.c
index 30ea9430b..6e872dace 100644
--- a/tests/bxaddi.c
+++ b/tests/bxaddi.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bxaddi(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bxaddi_u.c b/tests/bxaddi_u.c
index 702f135a3..e71aeb79d 100644
--- a/tests/bxaddi_u.c
+++ b/tests/bxaddi_u.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bxaddi_u(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bxaddr.c b/tests/bxaddr.c
index 84b3639f0..c1f6f2393 100644
--- a/tests/bxaddr.c
+++ b/tests/bxaddr.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bxaddr(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bxaddr_u.c b/tests/bxaddr_u.c
index b20ddd029..d674f8286 100644
--- a/tests/bxaddr_u.c
+++ b/tests/bxaddr_u.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bxaddr_u(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bxsubi.c b/tests/bxsubi.c
index 23174d7a1..1b642c711 100644
--- a/tests/bxsubi.c
+++ b/tests/bxsubi.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bxsubi(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bxsubi_u.c b/tests/bxsubi_u.c
index 9c50858ef..1345bd2bf 100644
--- a/tests/bxsubi_u.c
+++ b/tests/bxsubi_u.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_reloc_t r = jit_bxsubi_u(j, JIT_R0, 1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bxsubr.c b/tests/bxsubr.c
index 5ac2a7007..d40d1821d 100644
--- a/tests/bxsubr.c
+++ b/tests/bxsubr.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bxsubr(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/bxsubr_u.c b/tests/bxsubr_u.c
index 6ac20dbbf..54a8d2836 100644
--- a/tests/bxsubr_u.c
+++ b/tests/bxsubr_u.c
@@ -6,12 +6,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_reloc_t r = jit_bxsubr_u(j, JIT_R0, JIT_R1);
   jit_movi(j, JIT_R0, overflowed);
   jit_patch_here(j, r);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
diff --git a/tests/comr.c b/tests/comr.c
index bbdc287a1..c2e7d1883 100644
--- a/tests/comr.c
+++ b/tests/comr.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_comr(j, JIT_R0, JIT_R0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/divr.c b/tests/divr.c
index b83382c4f..399d70de1 100644
--- a/tests/divr.c
+++ b/tests/divr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_divr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/divr_d.c b/tests/divr_d.c
index d678c7370..9d21cb591 100644
--- a/tests/divr_d.c
+++ b/tests/divr_d.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_divr_d(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   size_t size = 0;
diff --git a/tests/divr_f.c b/tests/divr_f.c
index 0dcf8a618..de519dc75 100644
--- a/tests/divr_f.c
+++ b/tests/divr_f.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_divr_f(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   size_t size = 0;
diff --git a/tests/divr_u.c b/tests/divr_u.c
index 37ea02260..b8305f781 100644
--- a/tests/divr_u.c
+++ b/tests/divr_u.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_divr_u(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/extr_c.c b/tests/extr_c.c
index 06ea12a08..043068d3f 100644
--- a/tests/extr_c.c
+++ b/tests/extr_c.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_c(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/extr_d.c b/tests/extr_d.c
index 14c327258..af0fe9145 100644
--- a/tests/extr_d.c
+++ b/tests/extr_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_extr_d(j, JIT_F0, JIT_R0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/extr_d_f.c b/tests/extr_d_f.c
index eeeb860c0..049eb5fb5 100644
--- a/tests/extr_d_f.c
+++ b/tests/extr_d_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_extr_d_f(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(double) = jit_end(j, NULL);
diff --git a/tests/extr_f.c b/tests/extr_f.c
index 75d74a25d..b57830cae 100644
--- a/tests/extr_f.c
+++ b/tests/extr_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_extr_f(j, JIT_F0, JIT_R0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/extr_f_d.c b/tests/extr_f_d.c
index 8f14ea4ff..5fa500772 100644
--- a/tests/extr_f_d.c
+++ b/tests/extr_f_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_extr_f_d(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(float) = jit_end(j, NULL);
diff --git a/tests/extr_i.c b/tests/extr_i.c
index 6f7a9bb3f..d26a576b5 100644
--- a/tests/extr_i.c
+++ b/tests/extr_i.c
@@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_i(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/extr_s.c b/tests/extr_s.c
index a111937e6..5b39af392 100644
--- a/tests/extr_s.c
+++ b/tests/extr_s.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_s(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/extr_uc.c b/tests/extr_uc.c
index 4ebae5413..a42e603a9 100644
--- a/tests/extr_uc.c
+++ b/tests/extr_uc.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_uc(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/extr_ui.c b/tests/extr_ui.c
index 70d7f3bb0..37964da16 100644
--- a/tests/extr_ui.c
+++ b/tests/extr_ui.c
@@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_ui(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/extr_us.c b/tests/extr_us.c
index 7ea001fc2..38a7c390a 100644
--- a/tests/extr_us.c
+++ b/tests/extr_us.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_extr_us(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldi_c.c b/tests/ldi_c.c
index a825ab85c..9d5de8226 100644
--- a/tests/ldi_c.c
+++ b/tests/ldi_c.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_c(j, JIT_R0, &data[0]);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldi_d.c b/tests/ldi_d.c
index 562e35d99..b72cdda61 100644
--- a/tests/ldi_d.c
+++ b/tests/ldi_d.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_d(j, JIT_F0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldi_f.c b/tests/ldi_f.c
index ff9abd006..13e5fd427 100644
--- a/tests/ldi_f.c
+++ b/tests/ldi_f.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_f(j, JIT_F0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldi_i.c b/tests/ldi_i.c
index 6bb7a5997..e38978802 100644
--- a/tests/ldi_i.c
+++ b/tests/ldi_i.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_i(j, JIT_R0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldi_l.c b/tests/ldi_l.c
index 1cb5efd38..f3fa729cb 100644
--- a/tests/ldi_l.c
+++ b/tests/ldi_l.c
@@ -7,8 +7,10 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint64_t data = 0xffffffffffffffff;
 
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_l(j, JIT_R0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldi_s.c b/tests/ldi_s.c
index b7d2ff213..d9d1c4725 100644
--- a/tests/ldi_s.c
+++ b/tests/ldi_s.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_s(j, JIT_R0, &data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldi_uc.c b/tests/ldi_uc.c
index 68b082c2e..12f18bf17 100644
--- a/tests/ldi_uc.c
+++ b/tests/ldi_uc.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_uc(j, JIT_R0, data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldi_ui.c b/tests/ldi_ui.c
index 47fe2784d..d233694c6 100644
--- a/tests/ldi_ui.c
+++ b/tests/ldi_ui.c
@@ -7,8 +7,10 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
 
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_ui(j, JIT_R0, data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldi_us.c b/tests/ldi_us.c
index adaf1ee3c..70eb4a093 100644
--- a/tests/ldi_us.c
+++ b/tests/ldi_us.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_ldi_us(j, JIT_R0, data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ldr_c.c b/tests/ldr_c.c
index ac851dbdd..07a59314b 100644
--- a/tests/ldr_c.c
+++ b/tests/ldr_c.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_c(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldr_d.c b/tests/ldr_d.c
index 5f3073ada..37c75f096 100644
--- a/tests/ldr_d.c
+++ b/tests/ldr_d.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_d(j, JIT_F0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldr_f.c b/tests/ldr_f.c
index c0776b6d3..bb6827848 100644
--- a/tests/ldr_f.c
+++ b/tests/ldr_f.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_f(j, JIT_F0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldr_i.c b/tests/ldr_i.c
index 5f6de9912..3de9e5f2c 100644
--- a/tests/ldr_i.c
+++ b/tests/ldr_i.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_i(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldr_l.c b/tests/ldr_l.c
index 6a3d0fc5a..15f00801e 100644
--- a/tests/ldr_l.c
+++ b/tests/ldr_l.c
@@ -7,9 +7,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
 
   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_R1));
 
   jit_ldr_l(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldr_s.c b/tests/ldr_s.c
index 61daa721b..cf668d5b3 100644
--- a/tests/ldr_s.c
+++ b/tests/ldr_s.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_s(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldr_uc.c b/tests/ldr_uc.c
index 049630bf4..a48f37056 100644
--- a/tests/ldr_uc.c
+++ b/tests/ldr_uc.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_uc(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldr_ui.c b/tests/ldr_ui.c
index 85a462c40..7668778b5 100644
--- a/tests/ldr_ui.c
+++ b/tests/ldr_ui.c
@@ -7,9 +7,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
 
   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_R1));
 
   jit_ldr_ui(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldr_us.c b/tests/ldr_us.c
index 464108008..bb9928bf0 100644
--- a/tests/ldr_us.c
+++ b/tests/ldr_us.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R1));
 
   jit_ldr_us(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*) = jit_end(j, NULL);
diff --git a/tests/ldxi_c.c b/tests/ldxi_c.c
index 82242af43..4271f9753 100644
--- a/tests/ldxi_c.c
+++ b/tests/ldxi_c.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_c(j, JIT_R0, JIT_R0, (uintptr_t)&data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxi_d.c b/tests/ldxi_d.c
index db5af67bc..6bcf632cc 100644
--- a/tests/ldxi_d.c
+++ b/tests/ldxi_d.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_d(j, JIT_F0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxi_f.c b/tests/ldxi_f.c
index 0e91f74b9..9e65321d8 100644
--- a/tests/ldxi_f.c
+++ b/tests/ldxi_f.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_f(j, JIT_F0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxi_i.c b/tests/ldxi_i.c
index d6d2def08..d1f7b5605 100644
--- a/tests/ldxi_i.c
+++ b/tests/ldxi_i.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0));
 
   jit_ldxi_i(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxi_l.c b/tests/ldxi_l.c
index 6383166c2..bb1a8b257 100644
--- a/tests/ldxi_l.c
+++ b/tests/ldxi_l.c
@@ -7,9 +7,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
 
   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_ldxi_l(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxi_s.c b/tests/ldxi_s.c
index 698bcdba2..c9376d0fb 100644
--- a/tests/ldxi_s.c
+++ b/tests/ldxi_s.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_s(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxi_uc.c b/tests/ldxi_uc.c
index 35ddf2454..31d7b73d3 100644
--- a/tests/ldxi_uc.c
+++ b/tests/ldxi_uc.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_uc(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxi_ui.c b/tests/ldxi_ui.c
index 00a47598c..4f7e304a6 100644
--- a/tests/ldxi_ui.c
+++ b/tests/ldxi_ui.c
@@ -7,9 +7,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
 
   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_ldxi_ui(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxi_us.c b/tests/ldxi_us.c
index edc71906b..81c984f1f 100644
--- a/tests/ldxi_us.c
+++ b/tests/ldxi_us.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ldxi_us(j, JIT_R0, JIT_R0, (uintptr_t)data);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_c.c b/tests/ldxr_c.c
index c770e7eab..366f5b2f3 100644
--- a/tests/ldxr_c.c
+++ b/tests/ldxr_c.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_c(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_d.c b/tests/ldxr_d.c
index 7267245ea..38a12fdd5 100644
--- a/tests/ldxr_d.c
+++ b/tests/ldxr_d.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_d(j, JIT_F0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_f.c b/tests/ldxr_f.c
index 88aabc67f..c48b11f8f 100644
--- a/tests/ldxr_f.c
+++ b/tests/ldxr_f.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_f(j, JIT_F0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_i.c b/tests/ldxr_i.c
index 774c682d1..e4149aade 100644
--- a/tests/ldxr_i.c
+++ b/tests/ldxr_i.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_i(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_l.c b/tests/ldxr_l.c
index d143ede93..ee9f156a7 100644
--- a/tests/ldxr_l.c
+++ b/tests/ldxr_l.c
@@ -7,10 +7,12 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint64_t data[] = { 0xffffffffffffffff, 0, 0x4242424212345678 };
 
   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_WORD, JIT_R1));
 
   jit_ldxr_l(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_s.c b/tests/ldxr_s.c
index ca93140ab..fbb5c090c 100644
--- a/tests/ldxr_s.c
+++ b/tests/ldxr_s.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_s(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_uc.c b/tests/ldxr_uc.c
index 70bcf13a9..846c552c2 100644
--- a/tests/ldxr_uc.c
+++ b/tests/ldxr_uc.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_uc(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_ui.c b/tests/ldxr_ui.c
index 0c821ee06..cd774d355 100644
--- a/tests/ldxr_ui.c
+++ b/tests/ldxr_ui.c
@@ -7,10 +7,12 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint32_t data[] = { 0xffffffff, 0x00000000, 0x42424242 };
 
   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_WORD, JIT_R1));
 
   jit_ldxr_ui(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/ldxr_us.c b/tests/ldxr_us.c
index 32ce9233e..b7e408bb9 100644
--- a/tests/ldxr_us.c
+++ b/tests/ldxr_us.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_ldxr_us(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_uword_t (*f)(void*, jit_uword_t) = jit_end(j, NULL);
diff --git a/tests/lshi.c b/tests/lshi.c
index 8c25e40b0..e721af58b 100644
--- a/tests/lshi.c
+++ b/tests/lshi.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_lshi(j, JIT_R0, JIT_R0, 31);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/lshr.c b/tests/lshr.c
index 3861adb46..f81aa690a 100644
--- a/tests/lshr.c
+++ b/tests/lshr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_lshr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/mov_addr.c b/tests/mov_addr.c
index 0d7d9e071..b4a9aaae1 100644
--- a/tests/mov_addr.c
+++ b/tests/mov_addr.c
@@ -6,8 +6,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_patch_there(j, jit_mov_addr(j, JIT_R0), &thing);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   void* (*f)(void) = jit_end(j, NULL);
diff --git a/tests/movi_d.c b/tests/movi_d.c
index 58ec949fc..cb9e63d47 100644
--- a/tests/movi_d.c
+++ b/tests/movi_d.c
@@ -4,8 +4,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_movi_d(j, JIT_F0, 3.14159);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(void) = jit_end(j, NULL);
diff --git a/tests/movi_f.c b/tests/movi_f.c
index 0b92f9242..944f61589 100644
--- a/tests/movi_f.c
+++ b/tests/movi_f.c
@@ -4,8 +4,10 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   jit_movi_f(j, JIT_F0, 3.14159f);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   float (*f)(void) = jit_end(j, NULL);
diff --git a/tests/mulr.c b/tests/mulr.c
index 7f39d3d6d..452e35dcb 100644
--- a/tests/mulr.c
+++ b/tests/mulr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_mulr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/mulr_d.c b/tests/mulr_d.c
index 460b14baf..945f1527d 100644
--- a/tests/mulr_d.c
+++ b/tests/mulr_d.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_mulr_d(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   size_t size = 0;
diff --git a/tests/mulr_f.c b/tests/mulr_f.c
index 6189be263..2d0dd4ffa 100644
--- a/tests/mulr_f.c
+++ b/tests/mulr_f.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_mulr_f(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   size_t size = 0;
diff --git a/tests/negr.c b/tests/negr.c
index cf9c84d69..18e27cbbb 100644
--- a/tests/negr.c
+++ b/tests/negr.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_negr(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);
diff --git a/tests/negr_d.c b/tests/negr_d.c
index 566061c46..d0e168b8c 100644
--- a/tests/negr_d.c
+++ b/tests/negr_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_negr_d(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(double) = jit_end(j, NULL);
diff --git a/tests/negr_f.c b/tests/negr_f.c
index 24b509f41..26110d560 100644
--- a/tests/negr_f.c
+++ b/tests/negr_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_negr_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);
diff --git a/tests/nop.c b/tests/nop.c
index e2975c5d2..c029954d2 100644
--- a/tests/nop.c
+++ b/tests/nop.c
@@ -4,6 +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);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
 
   size_t total = 0;
   char *start = jit_address(j);
@@ -11,6 +12,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
     jit_nop(j, i);
   char *end = jit_address(j);
   ASSERT(end - start == total);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_reti(j, 42);
 
   jit_word_t (*f)(void) = jit_end(j, NULL);
diff --git a/tests/ori.c b/tests/ori.c
index 25a528e23..631018527 100644
--- a/tests/ori.c
+++ b/tests/ori.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_ori(j, JIT_R0, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/orr.c b/tests/orr.c
index c7bf31375..5a9087a3d 100644
--- a/tests/orr.c
+++ b/tests/orr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_orr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/pushpop.c b/tests/pushpop.c
index de010c812..cd2420bdd 100644
--- a/tests/pushpop.c
+++ b/tests/pushpop.c
@@ -7,13 +7,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   const jit_fpr_t fpr[] = { JIT_F0, JIT_F1, JIT_F2 };
 
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 3, 0, 0);
 
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
-  for (int i=0; i<6; i++)
-    jit_pushr(j, gpr[i]);
-  for (int i=0; i<3; i++)
-    jit_pushr_d(j, fpr[i]);
+  jit_pushr(j, JIT_R0);
 
   // Stomple registers.
   for (int i=0; i<6; i++)
@@ -21,11 +19,9 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   for (int i=0; i<3; i++)
     jit_extr_d(j, fpr[i], gpr[i]);
 
-  for (int i=2; i>=0; i--)
-    jit_popr_d(j, fpr[i]);
-  for (int i=5; i>=0; i--)
-    jit_popr(j, gpr[i]);
+  jit_popr(j, JIT_R0);
 
+  jit_leave_jit_abi(j, 3, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/remr.c b/tests/remr.c
index 74c85e14e..805d6fbf9 100644
--- a/tests/remr.c
+++ b/tests/remr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_remr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/remr_u.c b/tests/remr_u.c
index 10a59522a..a9a01789a 100644
--- a/tests/remr_u.c
+++ b/tests/remr_u.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_remr_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;
diff --git a/tests/rshi.c b/tests/rshi.c
index ba20db6a6..c536055dc 100644
--- a/tests/rshi.c
+++ b/tests/rshi.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_rshi(j, JIT_R0, JIT_R0, 31);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/rshi_u.c b/tests/rshi_u.c
index c0e3d7193..8f6dbd4e3 100644
--- a/tests/rshi_u.c
+++ b/tests/rshi_u.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_rshi_u(j, JIT_R0, JIT_R0, 31);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
diff --git a/tests/rshr.c b/tests/rshr.c
index c168b9513..b4b568907 100644
--- a/tests/rshr.c
+++ b/tests/rshr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_rshr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/rshr_u.c b/tests/rshr_u.c
index 0ff9c2878..64c59fddb 100644
--- a/tests/rshr_u.c
+++ b/tests/rshr_u.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_rshr_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;
diff --git a/tests/sqrtr_d.c b/tests/sqrtr_d.c
index 35e2230a7..873deb919 100644
--- a/tests/sqrtr_d.c
+++ b/tests/sqrtr_d.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_sqrtr_d(j, JIT_F0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   double (*f)(double) = jit_end(j, NULL);
diff --git a/tests/sqrtr_f.c b/tests/sqrtr_f.c
index 0c3737337..66db83139 100644
--- a/tests/sqrtr_f.c
+++ b/tests/sqrtr_f.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_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);
diff --git a/tests/sti_c.c b/tests/sti_c.c
index 61ae9b69d..ff6e6d563 100644
--- a/tests/sti_c.c
+++ b/tests/sti_c.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_sti_c(j, &data[1], JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(int8_t) = jit_end(j, NULL);
diff --git a/tests/sti_d.c b/tests/sti_d.c
index c10b7b7dd..8a703e6b6 100644
--- a/tests/sti_d.c
+++ b/tests/sti_d.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_sti_d(j, &data[1], JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(double) = jit_end(j, NULL);
diff --git a/tests/sti_f.c b/tests/sti_f.c
index 240152654..e0271925b 100644
--- a/tests/sti_f.c
+++ b/tests/sti_f.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_sti_f(j, &data[1], JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(float) = jit_end(j, NULL);
diff --git a/tests/sti_i.c b/tests/sti_i.c
index c8bb72e73..4a233c657 100644
--- a/tests/sti_i.c
+++ b/tests/sti_i.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_sti_i(j, &data[1], JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(int32_t) = jit_end(j, NULL);
diff --git a/tests/sti_l.c b/tests/sti_l.c
index 939a3e8e3..fce9180b2 100644
--- a/tests/sti_l.c
+++ b/tests/sti_l.c
@@ -7,9 +7,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
 
   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_INT64, JIT_R1));
 
   jit_sti_l(j, &data[1], JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(int64_t) = jit_end(j, NULL);
diff --git a/tests/sti_s.c b/tests/sti_s.c
index 4d4b27212..daab0bda2 100644
--- a/tests/sti_s.c
+++ b/tests/sti_s.c
@@ -6,9 +6,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_sti_s(j, &data[1], JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(int16_t) = jit_end(j, NULL);
diff --git a/tests/str_c.c b/tests/str_c.c
index f8d7d7543..b894b8281 100644
--- a/tests/str_c.c
+++ b/tests/str_c.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_str_c(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, int8_t) = jit_end(j, NULL);
diff --git a/tests/str_d.c b/tests/str_d.c
index 817fd64a2..2f992a66a 100644
--- a/tests/str_d.c
+++ b/tests/str_d.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_str_d(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, double) = jit_end(j, NULL);
diff --git a/tests/str_f.c b/tests/str_f.c
index 22af0d580..fdad3c244 100644
--- a/tests/str_f.c
+++ b/tests/str_f.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_str_f(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, float) = jit_end(j, NULL);
diff --git a/tests/str_i.c b/tests/str_i.c
index 3872ed771..968f0ce91 100644
--- a/tests/str_i.c
+++ b/tests/str_i.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_str_i(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, int32_t) = jit_end(j, NULL);
diff --git a/tests/str_l.c b/tests/str_l.c
index ff91a18f1..450885b39 100644
--- a/tests/str_l.c
+++ b/tests/str_l.c
@@ -7,10 +7,12 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
 
   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_INT64, JIT_R1));
 
   jit_str_l(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, int64_t) = jit_end(j, NULL);
diff --git a/tests/str_s.c b/tests/str_s.c
index 0044d8286..3e228edc7 100644
--- a/tests/str_s.c
+++ b/tests/str_s.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_str_s(j, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, int16_t) = jit_end(j, NULL);
diff --git a/tests/stxi_c.c b/tests/stxi_c.c
index 78982044f..d76d814f5 100644
--- a/tests/stxi_c.c
+++ b/tests/stxi_c.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_stxi_c(j, (uintptr_t)data, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(jit_word_t, int8_t) = jit_end(j, NULL);
diff --git a/tests/stxi_d.c b/tests/stxi_d.c
index a63c335d8..3933c5692 100644
--- a/tests/stxi_d.c
+++ b/tests/stxi_d.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_stxi_d(j, (uintptr_t)data, JIT_R2, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(jit_word_t, double) = jit_end(j, NULL);
diff --git a/tests/stxi_f.c b/tests/stxi_f.c
index 5a93679ff..aea6756cc 100644
--- a/tests/stxi_f.c
+++ b/tests/stxi_f.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_stxi_f(j, (uintptr_t)data, JIT_R2, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(jit_word_t, float) = jit_end(j, NULL);
diff --git a/tests/stxi_i.c b/tests/stxi_i.c
index e320c9201..79dab03c4 100644
--- a/tests/stxi_i.c
+++ b/tests/stxi_i.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_stxi_i(j, (uintptr_t)data, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(jit_word_t, int32_t) = jit_end(j, NULL);
diff --git a/tests/stxi_l.c b/tests/stxi_l.c
index af62d7de0..8a6824136 100644
--- a/tests/stxi_l.c
+++ b/tests/stxi_l.c
@@ -7,10 +7,12 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
 
   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_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT64, JIT_R1));
 
   jit_stxi_l(j, (uintptr_t)data, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(jit_word_t, int64_t) = jit_end(j, NULL);
diff --git a/tests/stxi_s.c b/tests/stxi_s.c
index 7bc8fa2cc..64bda5d6c 100644
--- a/tests/stxi_s.c
+++ b/tests/stxi_s.c
@@ -6,10 +6,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_stxi_s(j, (uintptr_t)data, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(jit_word_t, int16_t) = jit_end(j, NULL);
diff --git a/tests/stxr_c.c b/tests/stxr_c.c
index c88d8cd6f..887685542 100644
--- a/tests/stxr_c.c
+++ b/tests/stxr_c.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT8, JIT_R1));
 
   jit_stxr_c(j, JIT_R0, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, jit_word_t, int8_t) = jit_end(j, NULL);
diff --git a/tests/stxr_d.c b/tests/stxr_d.c
index f3fb9334d..e87688aa1 100644
--- a/tests/stxr_d.c
+++ b/tests/stxr_d.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_stxr_d(j, JIT_R0, JIT_R2, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, jit_word_t, double) = jit_end(j, NULL);
diff --git a/tests/stxr_f.c b/tests/stxr_f.c
index 43aeaa9bd..bf0c47625 100644
--- a/tests/stxr_f.c
+++ b/tests/stxr_f.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_stxr_f(j, JIT_R0, JIT_R2, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, jit_word_t, float) = jit_end(j, NULL);
diff --git a/tests/stxr_i.c b/tests/stxr_i.c
index 376354fca..82604627b 100644
--- a/tests/stxr_i.c
+++ b/tests/stxr_i.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT32, JIT_R1));
 
   jit_stxr_i(j, JIT_R0, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, jit_word_t, int32_t) = jit_end(j, NULL);
diff --git a/tests/stxr_l.c b/tests/stxr_l.c
index 43c08d5d9..fa6bb1fbb 100644
--- a/tests/stxr_l.c
+++ b/tests/stxr_l.c
@@ -7,11 +7,13 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
   static uint64_t data[] = { 0x1212121212121212, 0, 0x3434343434343434 };
 
   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_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT64, JIT_R1));
 
   jit_stxr_l(j, JIT_R0, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, jit_word_t, int64_t) = jit_end(j, NULL);
diff --git a/tests/stxr_s.c b/tests/stxr_s.c
index 2cee20194..a93ccd9e9 100644
--- a/tests/stxr_s.c
+++ b/tests/stxr_s.c
@@ -6,11 +6,13 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_3(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R2),
                   jit_operand_gpr (JIT_OPERAND_ABI_INT16, JIT_R1));
 
   jit_stxr_s(j, JIT_R0, JIT_R2, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_ret(j);
 
   void (*f)(void*, jit_word_t, int16_t) = jit_end(j, NULL);
diff --git a/tests/subr.c b/tests/subr.c
index 92b528fee..57cf950c7 100644
--- a/tests/subr.c
+++ b/tests/subr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_subr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/subr_d.c b/tests/subr_d.c
index 71259a8e3..bc611c52e 100644
--- a/tests/subr_d.c
+++ b/tests/subr_d.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
 
   jit_subr_d(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_d(j, JIT_F0);
 
   size_t size = 0;
diff --git a/tests/subr_f.c b/tests/subr_f.c
index 410dc265d..a7befecfa 100644
--- a/tests/subr_f.c
+++ b/tests/subr_f.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
                   jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
 
   jit_subr_f(j, JIT_F0, JIT_F0, JIT_F1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr_f(j, JIT_F0);
 
   size_t size = 0;
diff --git a/tests/subx.c b/tests/subx.c
index cd1bb5b9c..b88bcbdb1 100644
--- a/tests/subx.c
+++ b/tests/subx.c
@@ -4,12 +4,14 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_movi(j, JIT_R2, 0);
   jit_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;
diff --git a/tests/truncr_d_i.c b/tests/truncr_d_i.c
index 12aaa917d..b21280f77 100644
--- a/tests/truncr_d_i.c
+++ b/tests/truncr_d_i.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_truncr_d_i(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   int (*f)(double) = jit_end(j, NULL);
diff --git a/tests/truncr_d_l.c b/tests/truncr_d_l.c
index 1f5dc995e..189617afb 100644
--- a/tests/truncr_d_l.c
+++ b/tests/truncr_d_l.c
@@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
 
   jit_truncr_d_l(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   int64_t (*f)(double) = jit_end(j, NULL);
diff --git a/tests/truncr_f_i.c b/tests/truncr_f_i.c
index 077d7bec8..3dbf63050 100644
--- a/tests/truncr_f_i.c
+++ b/tests/truncr_f_i.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_truncr_f_i(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   int (*f)(float) = jit_end(j, NULL);
diff --git a/tests/truncr_f_l.c b/tests/truncr_f_l.c
index c5a86f89b..7369ae3ad 100644
--- a/tests/truncr_f_l.c
+++ b/tests/truncr_f_l.c
@@ -5,9 +5,11 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
 #if __WORDSIZE > 32
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
 
   jit_truncr_f_l(j, JIT_R0, JIT_F0);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   int64_t (*f)(float) = jit_end(j, NULL);
diff --git a/tests/xori.c b/tests/xori.c
index 1071a4cd9..4bb2ad1d8 100644
--- a/tests/xori.c
+++ b/tests/xori.c
@@ -4,9 +4,11 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
 
   jit_xori(j, JIT_R0, JIT_R0, 1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;
diff --git a/tests/xorr.c b/tests/xorr.c
index a37a57004..dd5a3905c 100644
--- a/tests/xorr.c
+++ b/tests/xorr.c
@@ -4,10 +4,12 @@ static void
 run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
 {
   jit_begin(j, arena_base, arena_size);
+  size_t align = jit_enter_jit_abi(j, 0, 0, 0);
   jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
                   jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
 
   jit_xorr(j, JIT_R0, JIT_R0, JIT_R1);
+  jit_leave_jit_abi(j, 0, 0, align);
   jit_retr(j, JIT_R0);
 
   size_t size = 0;