[Guile-commits] 14/20: Add {enter,leave}_jit_abi calls in tests

[Andy Wingo]

wingo pushed a commit to branch lightening
in repository guile.

commit d11864f09883b1624a17b3f444378c38515b231f
Author: Andy Wingo <address@hidden>
Date:   Sat Apr 27 22:54:38 2019 +0200

    Add {enter,leave}_jit_abi calls in tests
    
    This saves and restores RBP on x86-32.
---
 tests/absr_d.c     |  2 ++
 tests/absr_f.c     |  2 ++
 tests/addi.c       |  2 ++
 tests/addr.c       |  2 ++
 tests/addr_d.c     |  2 ++
 tests/addr_f.c     |  2 ++
 tests/addx.c       |  2 ++
 tests/andi.c       |  2 ++
 tests/andr.c       |  2 ++
 tests/beqi.c       |  3 +++
 tests/beqr.c       |  3 +++
 tests/beqr_d.c     |  3 +++
 tests/beqr_f.c     |  3 +++
 tests/bgei.c       |  3 +++
 tests/bgei_u.c     |  3 +++
 tests/bger.c       |  3 +++
 tests/bger_d.c     |  3 +++
 tests/bger_f.c     |  3 +++
 tests/bger_u.c     |  3 +++
 tests/bgti.c       |  3 +++
 tests/bgti_u.c     |  3 +++
 tests/bgtr.c       |  3 +++
 tests/bgtr_d.c     |  3 +++
 tests/bgtr_f.c     |  3 +++
 tests/bgtr_u.c     |  3 +++
 tests/blei.c       |  3 +++
 tests/blei_u.c     |  3 +++
 tests/bler.c       |  3 +++
 tests/bler_d.c     |  3 +++
 tests/bler_f.c     |  3 +++
 tests/bler_u.c     |  3 +++
 tests/bltgtr_d.c   |  3 +++
 tests/bltgtr_f.c   |  3 +++
 tests/blti.c       |  3 +++
 tests/blti_u.c     |  3 +++
 tests/bltr.c       |  3 +++
 tests/bltr_d.c     |  3 +++
 tests/bltr_f.c     |  3 +++
 tests/bltr_u.c     |  3 +++
 tests/bmci.c       |  3 +++
 tests/bmcr.c       |  3 +++
 tests/bmsi.c       |  3 +++
 tests/bmsr.c       |  3 +++
 tests/bnei.c       |  3 +++
 tests/bner.c       |  3 +++
 tests/bner_d.c     |  3 +++
 tests/bner_f.c     |  3 +++
 tests/boaddi.c     |  3 +++
 tests/boaddi_u.c   |  3 +++
 tests/boaddr.c     |  3 +++
 tests/boaddr_u.c   |  3 +++
 tests/bordr_d.c    |  3 +++
 tests/bordr_f.c    |  3 +++
 tests/bosubi.c     |  3 +++
 tests/bosubi_u.c   |  3 +++
 tests/bosubr.c     |  3 +++
 tests/bosubr_u.c   |  3 +++
 tests/bswapr_ui.c  |  2 ++
 tests/bswapr_ul.c  |  2 ++
 tests/bswapr_us.c  |  2 ++
 tests/buneqr_d.c   |  3 +++
 tests/buneqr_f.c   |  3 +++
 tests/bunger_d.c   |  3 +++
 tests/bunger_f.c   |  3 +++
 tests/bungtr_d.c   |  3 +++
 tests/bungtr_f.c   |  3 +++
 tests/bunler_d.c   |  3 +++
 tests/bunler_f.c   |  3 +++
 tests/bunltr_d.c   |  3 +++
 tests/bunltr_f.c   |  3 +++
 tests/bunordr_d.c  |  3 +++
 tests/bunordr_f.c  |  3 +++
 tests/bxaddi.c     |  2 ++
 tests/bxaddi_u.c   |  2 ++
 tests/bxaddr.c     |  2 ++
 tests/bxaddr_u.c   |  2 ++
 tests/bxsubi.c     |  2 ++
 tests/bxsubi_u.c   |  2 ++
 tests/bxsubr.c     |  2 ++
 tests/bxsubr_u.c   |  2 ++
 tests/comr.c       |  2 ++
 tests/divr.c       |  2 ++
 tests/divr_d.c     |  2 ++
 tests/divr_f.c     |  2 ++
 tests/divr_u.c     |  2 ++
 tests/extr_c.c     |  2 ++
 tests/extr_d.c     |  2 ++
 tests/extr_d_f.c   |  2 ++
 tests/extr_f.c     |  2 ++
 tests/extr_f_d.c   |  2 ++
 tests/extr_i.c     |  2 ++
 tests/extr_s.c     |  2 ++
 tests/extr_uc.c    |  2 ++
 tests/extr_ui.c    |  2 ++
 tests/extr_us.c    |  2 ++
 tests/ldi_c.c      |  2 ++
 tests/ldi_d.c      |  2 ++
 tests/ldi_f.c      |  2 ++
 tests/ldi_i.c      |  2 ++
 tests/ldi_l.c      |  2 ++
 tests/ldi_s.c      |  2 ++
 tests/ldi_uc.c     |  2 ++
 tests/ldi_ui.c     |  2 ++
 tests/ldi_us.c     |  2 ++
 tests/ldr_c.c      |  2 ++
 tests/ldr_d.c      |  2 ++
 tests/ldr_f.c      |  2 ++
 tests/ldr_i.c      |  2 ++
 tests/ldr_l.c      |  2 ++
 tests/ldr_s.c      |  2 ++
 tests/ldr_uc.c     |  2 ++
 tests/ldr_ui.c     |  2 ++
 tests/ldr_us.c     |  2 ++
 tests/ldxi_c.c     |  2 ++
 tests/ldxi_d.c     |  2 ++
 tests/ldxi_f.c     |  2 ++
 tests/ldxi_i.c     |  2 ++
 tests/ldxi_l.c     |  2 ++
 tests/ldxi_s.c     |  2 ++
 tests/ldxi_uc.c    |  2 ++
 tests/ldxi_ui.c    |  2 ++
 tests/ldxi_us.c    |  2 ++
 tests/ldxr_c.c     |  2 ++
 tests/ldxr_d.c     |  2 ++
 tests/ldxr_f.c     |  2 ++
 tests/ldxr_i.c     |  2 ++
 tests/ldxr_l.c     |  2 ++
 tests/ldxr_s.c     |  2 ++
 tests/ldxr_uc.c    |  2 ++
 tests/ldxr_ui.c    |  2 ++
 tests/ldxr_us.c    |  2 ++
 tests/lshi.c       |  2 ++
 tests/lshr.c       |  2 ++
 tests/mov_addr.c   |  2 ++
 tests/movi_d.c     |  2 ++
 tests/movi_f.c     |  2 ++
 tests/mulr.c       |  2 ++
 tests/mulr_d.c     |  2 ++
 tests/mulr_f.c     |  2 ++
 tests/negr.c       |  2 ++
 tests/negr_d.c     |  2 ++
 tests/negr_f.c     |  2 ++
 tests/nop.c        |  2 ++
 tests/ori.c        |  2 ++
 tests/orr.c        |  2 ++
 tests/pushpop.c    | 12 ++++--------
 tests/remr.c       |  2 ++
 tests/remr_u.c     |  2 ++
 tests/rshi.c       |  2 ++
 tests/rshi_u.c     |  2 ++
 tests/rshr.c       |  2 ++
 tests/rshr_u.c     |  2 ++
 tests/sqrtr_d.c    |  2 ++
 tests/sqrtr_f.c    |  2 ++
 tests/sti_c.c      |  2 ++
 tests/sti_d.c      |  2 ++
 tests/sti_f.c      |  2 ++
 tests/sti_i.c      |  2 ++
 tests/sti_l.c      |  2 ++
 tests/sti_s.c      |  2 ++
 tests/str_c.c      |  2 ++
 tests/str_d.c      |  2 ++
 tests/str_f.c      |  2 ++
 tests/str_i.c      |  2 ++
 tests/str_l.c      |  2 ++
 tests/str_s.c      |  2 ++
 tests/stxi_c.c     |  2 ++
 tests/stxi_d.c     |  2 ++
 tests/stxi_f.c     |  2 ++
 tests/stxi_i.c     |  2 ++
 tests/stxi_l.c     |  2 ++
 tests/stxi_s.c     |  2 ++
 tests/stxr_c.c     |  2 ++
 tests/stxr_d.c     |  2 ++
 tests/stxr_f.c     |  2 ++
 tests/stxr_i.c     |  2 ++
 tests/stxr_l.c     |  2 ++
 tests/stxr_s.c     |  2 ++
 tests/subr.c       |  2 ++
 tests/subr_d.c     |  2 ++
 tests/subr_f.c     |  2 ++
 tests/subx.c       |  2 ++
 tests/truncr_d_i.c |  2 ++
 tests/truncr_d_l.c |  2 ++
 tests/truncr_f_i.c |  2 ++
 tests/truncr_f_l.c |  2 ++
 tests/xori.c       |  2 ++
 tests/xorr.c       |  2 ++
 188 files changed, 438 insertions(+), 8 deletions(-)

diff --git a/tests/absr_d.c b/tests/absr_d.c
index 93b10b6..00b8fa4 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 64463bf..e019b5f 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 85d4d8e..756d070 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 a54f756..6ee76e2 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 8c7be62..1121620 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 1ed1f36..4317dfe 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 875e09f..417cd1a 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 2f84d76..c6f39d7 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 2e09527..1114ef9 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 857d927..2fb2454 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 e8bacd0..d1d80b2 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 1b7f88b..a84b6a7 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 85b464f..7b5cc27 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 939e1a0..b9a830b 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 b5253e9..894c275 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 d59e4f4..daab88c 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 281803d..712b118 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 d9c556c..b9d5478 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 13c6a1d..5c07f44 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 36df659..4bfd36e 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 c5be4e3..b4da14e 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 222816a..dbf5fdd 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 f2892ab..d3c2436 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 4ac08a3..91cb8c0 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 23ade09..2ed4d8e 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 4303cae..cb9eacb 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 23c0272..efe0523 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 0d3f160..57371fb 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 7d52531..507dac5 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 5d57bc1..191b649 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 a4caf5b..4269fee 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 21fa546..3d8835d 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 872fbb3..fbdbc3b 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 a011f5a..fcdeb15 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 b4afe71..e90f193 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 d9d2520..901f6c4 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 a1b60a3..2d62609 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 adbafec..eebd3da 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 4ec33c2..9df16fc 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 55cd4a3..608d666 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 00dad50..df7e046 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 a516164..82c2ba7 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 79a9d23..8caa7e0 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 3b06482..73e38a7 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 2e13216..e651586 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 3f29d46..079fda4 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 e43ddf9..011df67 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 6dcc4ea..1e47297 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 364c71c..21c71df 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 c07417c..8bab91e 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 b186a90..f4bacde 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 9a611db..9227f22 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 fcfac6e..25808e5 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 41e6245..f10d90a 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 b494a7d..50af6ad 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 17da71f..cf68ad6 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 a3d8ae3..b5e6b39 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 653eb2d..c1eb9fd 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 106a94c..a3a11b3 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 fd0d439..0ff777e 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 eead53e..1d08e32 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 b648742..49d9062 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 e949c97..57888af 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 4fc5983..f3103dc 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 f00c1ea..649d61f 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 722779c..fea66dc 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 d3cec18..e59382c 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 fa3b0ef..fddce6b 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 e6adf6d..2ab0051 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 4d6048e..ade228b 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 f9d074b..6b04f0e 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 5dffc69..ce4fc7b 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 30ea943..6e872da 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 702f135..e71aeb7 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 84b3639..c1f6f23 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 b20ddd0..d674f82 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 23174d7..1b642c7 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 9c50858..1345bd2 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 5ac2a70..d40d182 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 6ac20db..54a8d28 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 bbdc287..c2e7d18 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 b83382c..399d70d 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 d678c73..9d21cb5 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 0dcf8a6..de519dc 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 37ea022..b8305f7 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 06ea12a..043068d 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 14c3272..af0fe91 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 eeeb860..049eb5f 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 75d74a2..b57830c 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 8f14ea4..5fa5007 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 6f7a9bb..d26a576 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 a111937..5b39af3 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 4ebae54..a42e603 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 70d7f3b..37964da 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 7ea001f..38a7c39 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 a825ab8..9d5de82 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 562e35d..b72cdda 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 ff9abd0..13e5fd4 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 6bb7a59..e389788 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 1cb5efd..f3fa729 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 b7d2ff2..d9d1c47 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 68b082c..12f18bf 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 47fe278..d233694 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 adaf1ee..70eb4a0 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 ac851db..07a5931 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 5f3073a..37c75f0 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 c0776b6..bb68278 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 5f6de99..3de9e5f 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 6a3d0fc..15f0080 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 61daa72..cf668d5 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 049630b..a48f370 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 85a462c..7668778 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 4641080..bb9928b 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 82242af..4271f97 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 db5af67..6bcf632 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 0e91f74..9e65321 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 d6d2def..d1f7b56 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 6383166..bb1a8b2 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 698bcdb..c9376d0 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 35ddf24..31d7b73 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 00a4759..4f7e304 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 edc7190..81c984f 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 c770e7e..366f5b2 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 7267245..38a12fd 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 88aabc6..c48b11f 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 774c682..e4149aa 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 d143ede..ee9f156 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 ca93140..fbb5c09 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 70bcf13..846c552 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 0c821ee..cd774d3 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 32ce923..b7e408b 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 8c25e40..e721af5 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 3861adb..f81aa69 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 0d7d9e0..b4a9aaa 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 58ec949..cb9e63d 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 0b92f92..944f615 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 7f39d3d..452e35d 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 460b14b..945f152 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 6189be2..2d0dd4f 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 cf9c84d..18e27cb 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 566061c..d0e168b 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 24b509f..26110d5 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 e2975c5..c029954 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 25a528e..6310185 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 c7bf313..5a9087a 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 de010c8..cd2420b 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 74c85e1..805d6fb 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 10a5952..a9a0178 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 ba20db6..c536055 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 c0e3d71..8f6dbd4 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 c168b95..b4b5689 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 0ff9c28..64c59fd 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 35e2230..873deb9 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 0c37373..66db831 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 61ae9b6..ff6e6d5 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 c10b7b7..8a703e6 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 2401526..e027192 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 c8bb72e..4a233c6 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 939a3e8..fce9180 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 4d4b272..daab0bd 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 f8d7d75..b894b82 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 817fd64..2f992a6 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 22af0d5..fdad3c2 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 3872ed7..968f0ce 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 ff91a18..450885b 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 0044d82..3e228ed 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 7898204..d76d814 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 a63c335..3933c56 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 5a93679..aea6756 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 e320c92..79dab03 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 af62d7d..8a68241 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 7bc8fa2..64bda5d 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 c88d8cd..8876855 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 f3fb933..e87688a 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 43aeaa9..bf0c476 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 376354f..8260462 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 43c08d5..fa6bb1f 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 2cee201..a93ccd9 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 92b528f..57cf950 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 71259a8..bc611c5 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 410dc26..a7befec 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 cd1bb5b..b88bcbd 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 12aaa91..b21280f 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 1f5dc99..189617a 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 077d7be..3dbf630 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 c5a86f8..7369ae3 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 1071a4c..4bb2ad1 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 a37a570..dd5a390 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;