guile-commits
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Guile-commits] 17/86: Replace jit_int32_t, etc with stdint types


From: Andy Wingo
Subject: [Guile-commits] 17/86: Replace jit_int32_t, etc with stdint types
Date: Wed, 3 Apr 2019 11:38:50 -0400 (EDT)

wingo pushed a commit to branch lightening
in repository guile.

commit f3f71941acb17c5753c18d814a3774fb1216a34d
Author: Andy Wingo <address@hidden>
Date:   Tue Oct 30 13:48:57 2018 +0100

    Replace jit_int32_t, etc with stdint types
---
 check/carg.c      |   2 +-
 check/nodata.c    |   2 +-
 check/setcode.c   |   2 +-
 jit/aarch64-cpu.c | 558 ++++++++++++++++----------------
 jit/aarch64-fpu.c | 298 ++++++++---------
 jit/aarch64.c     | 134 ++++----
 jit/alpha-cpu.c   | 766 ++++++++++++++++++++++----------------------
 jit/alpha-fpu.c   | 434 ++++++++++++-------------
 jit/alpha.c       | 122 +++----
 jit/arm-cpu.c     | 536 +++++++++++++++----------------
 jit/arm-swf.c     | 348 ++++++++++----------
 jit/arm-vfp.c     | 418 ++++++++++++------------
 jit/arm.c         | 140 ++++----
 jit/arm.h         |  14 +-
 jit/hppa-cpu.c    | 804 +++++++++++++++++++++++-----------------------
 jit/hppa-fpu.c    | 262 +++++++--------
 jit/hppa.c        |  96 +++---
 jit/ia64-cpu.c    | 758 +++++++++++++++++++++----------------------
 jit/ia64-fpu.c    | 404 +++++++++++------------
 jit/ia64.c        | 106 +++---
 jit/jit.c         | 156 ++++-----
 jit/mips-cpu.c    | 910 ++++++++++++++++++++++++++--------------------------
 jit/mips-fpu.c    | 552 ++++++++++++++++----------------
 jit/mips.c        | 116 +++----
 jit/ppc-cpu.c     | 802 +++++++++++++++++++++++-----------------------
 jit/ppc-fpu.c     | 382 +++++++++++-----------
 jit/ppc.c         | 114 +++----
 jit/private.h     | 202 ++++++------
 jit/s390-cpu.c    | 758 +++++++++++++++++++++----------------------
 jit/s390-fpu.c    | 324 +++++++++----------
 jit/s390.c        | 134 ++++----
 jit/sparc-cpu.c   | 574 ++++++++++++++++-----------------
 jit/sparc-fpu.c   | 302 ++++++++---------
 jit/sparc.c       | 118 +++----
 jit/x86-cpu.c     | 942 +++++++++++++++++++++++++++---------------------------
 jit/x86-sse.c     | 508 ++++++++++++++---------------
 jit/x86-x87.c     | 370 ++++++++++-----------
 jit/x86.c         | 268 ++++++++--------
 jit/x86.h         |  36 +--
 39 files changed, 6886 insertions(+), 6886 deletions(-)

diff --git a/check/carg.c b/check/carg.c
index 35b897e..ed37b8a 100644
--- a/check/carg.c
+++ b/check/carg.c
@@ -60,7 +60,7 @@ main(int argc, char *argv[])
     void               (*code)(void);
     jit_node_t         *jmp, *pass;
     jit_node_t          *jw,  *jf,  *jd;
-    jit_int32_t                  s1,   s2,   s3,   s4,   s5,   s6,   s7,   s8,
+    int32_t              s1,   s2,   s3,   s4,   s5,   s6,   s7,   s8,
                          s9,  s10,  s11,  s12,  s13,  s14,  s15,  s16;
     jit_node_t          *a1,  *a2,  *a3,  *a4,  *a5,  *a6,  *a7,  *a8,
                         *a9, *a10, *a11, *a12, *a13, *a14, *a15, *a16;
diff --git a/check/nodata.c b/check/nodata.c
index 0e594c3..91ab394 100644
--- a/check/nodata.c
+++ b/check/nodata.c
@@ -21,7 +21,7 @@
 #define  mmap_fd                       -1
 #endif
 
-jit_uint8_t             *data;
+uint8_t                 *data;
 jit_state_t             *_jit;
 jit_word_t               data_length;
 jit_word_t               note_length;
diff --git a/check/setcode.c b/check/setcode.c
index 0047f34..e297187 100644
--- a/check/setcode.c
+++ b/check/setcode.c
@@ -24,7 +24,7 @@
 int
 main(int argc, char *argv[])
 {
-    jit_uint8_t                 *ptr;
+    uint8_t             *ptr;
     jit_state_t                 *_jit;
     jit_word_t           length;
 #if defined(__sgi)
diff --git a/jit/aarch64-cpu.c b/jit/aarch64-cpu.c
index 07b0edb..44eb4a3 100644
--- a/jit/aarch64-cpu.c
+++ b/jit/aarch64-cpu.c
@@ -20,7 +20,7 @@
 #if PROTO
 typedef union {
 /* aarch64-opc.c */
-#  define ui                   jit_uint32_t
+#  define ui                   uint32_t
 #  if __BYTE_ORDER == __LITTLE_ENDIAN
     /* cond2: condition in truly conditional-executed inst.  */
     struct {           ui b:  4; } cond2;
@@ -207,7 +207,7 @@ typedef union {
     struct { ui _:  8; ui b:  5; } b40;
     struct { ui _: 16; ui b:  6; } scale;
 #  endif
-    jit_int32_t                w;
+    int32_t            w;
 #  undef ui
 } instr_t;
 #  define stack_framesize              160
@@ -470,198 +470,198 @@ typedef union {
 #  define CBZ(Rd,Simm19)               ox19(A64_CBZ|XS,Rd,Simm19)
 #  define CBNZ(Rd,Simm19)              ox19(A64_CBNZ|XS,Rd,Simm19)
 #  define NOP()                                ii(0xd503201f)
-static jit_int32_t logical_immediate(jit_word_t);
+static int32_t logical_immediate(jit_word_t);
 #  define oxxx(Op,Rd,Rn,Rm)            _oxxx(_jit,Op,Rd,Rn,Rm)
-static void 
_oxxx(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _oxxx(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define oxxi(Op,Rd,Rn,Imm12)         _oxxi(_jit,Op,Rd,Rn,Imm12)
-static void 
_oxxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _oxxi(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define oxx9(Op,Rd,Rn,Imm9)          _oxx9(_jit,Op,Rd,Rn,Imm9)
-static void 
_oxx9(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _oxx9(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define ox19(Op,Rd,Simm19)           _ox19(_jit,Op,Rd,Simm19)
-static void _ox19(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ox19(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define oc19(Op,Cc,Simm19)           _oc19(_jit,Op,Cc,Simm19)
-static void _oc19(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _oc19(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define o26(Op,Simm26)               _o26(_jit,Op,Simm26)
-static void _oc26(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _oc26(jit_state_t*,int32_t,jit_int32_t);
 #  define ox_x(Op,Rd,Rn)               _ox_x(_jit,Op,Rd,Rn)
-static void _ox_x(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ox_x(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define o_xx(Op,Rd,Rn)               _o_xx(_jit,Op,Rd,Rn)
-static void _o_xx(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _o_xx(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define oxx_(Op,Rn,Rm)               _oxx_(_jit,Op,Rn,Rm)
-static void _oxx_(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _oxx_(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define o_x_(Op,Rn)                  _o_x_(_jit,Op,Rn)
-static void _o_x_(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _o_x_(jit_state_t*,int32_t,jit_int32_t);
 #  define ox_h(Op,Rd,Imm16)            _ox_h(_jit,Op,Rd,Imm16)
-static void _ox_h(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ox_h(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define oxxrs(Op,Rd,Rn,R,S)          _oxxrs(_jit,Op,Rd,Rn,R,S)
-static void _oxxrs(jit_state_t*,jit_int32_t,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_int32_t);
+static void _oxxrs(jit_state_t*,int32_t,jit_int32_t,
+                  int32_t,jit_int32_t,jit_int32_t);
 #  define oxxxc(Op,Rd,Rn,Rm,Cc)                _oxxxc(_jit,Op,Rd,Rn,Rm,Cc)
-static void _oxxxc(jit_state_t*,jit_int32_t,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_int32_t);
+static void _oxxxc(jit_state_t*,int32_t,jit_int32_t,
+                  int32_t,jit_int32_t,jit_int32_t);
 #  define oxxx7(Op,Rt,Rt2,Rn,Simm7)    _oxxx7(_jit,Op,Rt,Rt2,Rn,Simm7)
-static void _oxxx7(jit_state_t*,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _oxxx7(jit_state_t*,int32_t,
+                  int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define nop(i0)                      _nop(_jit,i0)
-static void _nop(jit_state_t*,jit_int32_t);
+static void _nop(jit_state_t*,int32_t);
 #  define addr(r0,r1,r2)               ADD(r0,r1,r2)
 #  define addi(r0,r1,i0)               _addi(_jit,r0,r1,i0)
-static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addcr(r0,r1,r2)              ADDS(r0,r1,r2)
 #  define addci(r0,r1,i0)              _addci(_jit,r0,r1,i0)
-static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addxr(r0,r1,r2)              ADCS(r0,r1,r2)
 #  define addxi(r0,r1,i0)              _addxi(_jit,r0,r1,i0)
-static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subr(r0,r1,r2)               SUB(r0,r1,r2)
 #  define subi(r0,r1,i0)               _subi(_jit,r0,r1,i0)
-static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subcr(r0,r1,r2)              SUBS(r0,r1,r2)
 #  define subci(r0,r1,i0)              _subci(_jit,r0,r1,i0)
-static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subxr(r0,r1,r2)              SBCS(r0,r1,r2)
 #  define subxi(r0,r1,i0)              _subxi(_jit,r0,r1,i0)
-static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rsbi(r0, r1, i0)             _rsbi(_jit, r0, r1, i0)
-static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rsbi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define mulr(r0,r1,r2)               MUL(r0,r1,r2)
 #  define muli(r0,r1,i0)               _muli(_jit,r0,r1,i0)
-static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _muli(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qmulr(r0,r1,r2,r3)           _qmulr(_jit,r0,r1,r2,r3)
-static void _qmulr(jit_state_t*,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_int32_t);
+static void _qmulr(jit_state_t*,int32_t,
+                  int32_t,jit_int32_t,jit_int32_t);
 #  define qmuli(r0,r1,r2,i0)           _qmuli(_jit,r0,r1,r2,i0)
-static void _qmuli(jit_state_t*,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_word_t);
+static void _qmuli(jit_state_t*,int32_t,
+                  int32_t,jit_int32_t,jit_word_t);
 #  define qmulr_u(r0,r1,r2,r3)         _qmulr_u(_jit,r0,r1,r2,r3)
-static void _qmulr_u(jit_state_t*,jit_int32_t,
-                    jit_int32_t,jit_int32_t,jit_int32_t);
+static void _qmulr_u(jit_state_t*,int32_t,
+                    int32_t,jit_int32_t,jit_int32_t);
 #  define qmuli_u(r0,r1,r2,i0)         _qmuli_u(_jit,r0,r1,r2,i0)
-static void _qmuli_u(jit_state_t*,jit_int32_t,
-                    jit_int32_t,jit_int32_t,jit_word_t);
+static void _qmuli_u(jit_state_t*,int32_t,
+                    int32_t,jit_int32_t,jit_word_t);
 #  define divr(r0,r1,r2)               SDIV(r0,r1,r2)
 #  define divi(r0,r1,i0)               _divi(_jit,r0,r1,i0)
-static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define divr_u(r0,r1,r2)             UDIV(r0,r1,r2)
 #  define divi_u(r0,r1,i0)             _divi_u(_jit,r0,r1,i0)
-static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qdivr(r0,r1,r2,r3)           _iqdivr(_jit,1,r0,r1,r2,r3)
 #  define qdivr_u(r0,r1,r2,r3)         _iqdivr(_jit,0,r0,r1,r2,r3)
 static void _iqdivr(jit_state_t*,jit_bool_t,
-                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+                   int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define qdivi(r0,r1,r2,i0)           _qdivi(_jit,r0,r1,r2,i0)
-static void _qdivi(jit_state_t*,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_word_t);
+static void _qdivi(jit_state_t*,int32_t,
+                  int32_t,jit_int32_t,jit_word_t);
 #  define qdivi_u(r0,r1,r2,i0)         _qdivi_u(_jit,r0,r1,r2,i0)
-static void _qdivi_u(jit_state_t*,jit_int32_t,
-                    jit_int32_t,jit_int32_t,jit_word_t);
+static void _qdivi_u(jit_state_t*,int32_t,
+                    int32_t,jit_int32_t,jit_word_t);
 #  define remr(r0,r1,r2)               _remr(_jit,r0,r1,r2)
-static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi(r0,r1,i0)               _remi(_jit,r0,r1,i0)
-static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define remr_u(r0,r1,r2)             _remr_u(_jit,r0,r1,r2)
-static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi_u(r0,r1,i0)             _remi_u(_jit,r0,r1,i0)
-static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define lshr(r0,r1,r2)               LSL(r0,r1,r2)
 #  define lshi(r0,r1,i0)               _lshi(_jit,r0,r1,i0)
-static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rshr(r0,r1,r2)               ASR(r0,r1,r2)
 #  define rshi(r0,r1,i0)               _rshi(_jit,r0,r1,i0)
-static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rshr_u(r0,r1,r2)             LSR(r0,r1,r2)
 #  define rshi_u(r0,r1,i0)             _rshi_u(_jit,r0,r1,i0)
-static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define negr(r0,r1)                  NEG(r0,r1)
 #  define comr(r0,r1)                  MVN(r0,r1)
 #  define andr(r0,r1,r2)               AND(r0,r1,r2)
 #  define andi(r0,r1,i0)               _andi(_jit,r0,r1,i0)
-static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _andi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define orr(r0,r1,r2)                        ORR(r0,r1,r2)
 #  define ori(r0,r1,i0)                        _ori(_jit,r0,r1,i0)
-static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define xorr(r0,r1,r2)               EOR(r0,r1,r2)
 #  define xori(r0,r1,i0)               _xori(_jit,r0,r1,i0)
-static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _xori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldr_c(r0,r1)                 LDRSBI(r0,r1,0)
 #  define ldi_c(r0,i0)                 _ldi_c(_jit,r0,i0)
-static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_c(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_uc(r0,r1)                        _ldr_uc(_jit,r0,r1)
-static void _ldr_uc(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_uc(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_uc(r0,i0)                        _ldi_uc(_jit,r0,i0)
-static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_uc(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_s(r0,r1)                 LDRSHI(r0,r1,0)
 #  define ldi_s(r0,i0)                 _ldi_s(_jit,r0,i0)
-static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_s(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_us(r0,r1)                        _ldr_us(_jit,r0,r1)
-static void _ldr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_us(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_us(r0,i0)                        _ldi_us(_jit,r0,i0)
-static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_us(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_i(r0,r1)                 LDRSWI(r0,r1,0)
 #  define ldi_i(r0,i0)                 _ldi_i(_jit,r0,i0)
-static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_i(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_ui(r0,r1)                        _ldr_ui(_jit,r0,r1)
-static void _ldr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_ui(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_ui(r0,i0)                        _ldi_ui(_jit,r0,i0)
-static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_ui(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_l(r0,r1)                 LDRI(r0,r1,0)
-static void _ldr_l(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_l(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_l(r0,i0)                 _ldi_l(_jit,r0,i0)
-static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_l(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_c(r0,r1,r2)             _ldxr_c(_jit,r0,r1,r2)
-static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_c(r0,r1,i0)             _ldxi_c(_jit,r0,r1,i0)
-static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_c(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_uc(r0,r1,r2)            _ldxr_uc(_jit,r0,r1,r2)
-static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_uc(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_uc(r0,r1,i0)            _ldxi_uc(_jit,r0,r1,i0)
-static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_uc(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_s(r0,r1,r2)             LDRSH(r0,r1,r2)
 #  define ldxi_s(r0,r1,i0)             _ldxi_s(_jit,r0,r1,i0)
-static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_s(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_us(r0,r1,r2)            _ldxr_us(_jit,r0,r1,r2)
-static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_us(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_us(r0,r1,i0)            _ldxi_us(_jit,r0,r1,i0)
-static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_us(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_i(r0,r1,r2)             LDRSW(r0,r1,r2)
 #  define ldxi_i(r0,r1,i0)             _ldxi_i(_jit,r0,r1,i0)
-static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_i(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_ui(r0,r1,r2)            _ldxr_ui(_jit,r0,r1,r2)
-static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_ui(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_ui(r0,r1,i0)            _ldxi_ui(_jit,r0,r1,i0)
-static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_ui(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_l(r0,r1,r2)             LDR(r0,r1,r2)
 #  define ldxi_l(r0,r1,i0)             _ldxi_l(_jit,r0,r1,i0)
-static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_l(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_c(r0,r1)                 STRBI(r1,r0,0)
 #  define sti_c(i0,r0)                 _sti_c(_jit,i0,r0)
-static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_c(jit_state_t*,jit_word_t,int32_t);
 #  define str_s(r0,r1)                 STRHI(r1,r0,0)
 #  define sti_s(i0,r0)                 _sti_s(_jit,i0,r0)
-static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_s(jit_state_t*,jit_word_t,int32_t);
 #  define str_i(r0,r1)                 STRWI(r1,r0,0)
 #  define sti_i(i0,r0)                 _sti_i(_jit,i0,r0)
-static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_i(jit_state_t*,jit_word_t,int32_t);
 #  define str_l(r0,r1)                 STRI(r1,r0,0)
 #  define sti_l(i0,r0)                 _sti_l(_jit,i0,r0)
-static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_l(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_c(r0,r1,r2)             STRB(r2,r1,r0)
 #  define stxi_c(i0,r0,r1)             _stxi_c(_jit,i0,r0,r1)
-static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_c(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_s(r0,r1,r2)             STRH(r2,r1,r0)
 #  define stxi_s(i0,r0,r1)             _stxi_s(_jit,i0,r0,r1)
-static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_s(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_i(r0,r1,r2)             STRW(r2,r1,r0)
 #  define stxi_i(i0,r0,r1)             _stxi_i(_jit,i0,r0,r1)
-static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_i(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_l(r0,r1,r2)             STR(r2,r1,r0)
 #  define stxi_l(i0,r0,r1)             _stxi_l(_jit,i0,r0,r1)
-static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_l(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  if __BYTE_ORDER == __LITTLE_ENDIAN
 #  define htonr_us(r0,r1)              _htonr_us(_jit,r0,r1)
-static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_us(jit_state_t*,int32_t,jit_int32_t);
 #  define htonr_ui(r0,r1)              _htonr_ui(_jit,r0,r1)
-static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ui(jit_state_t*,int32_t,jit_int32_t);
 #    define htonr_ul(r0,r1)            REV(r0,r1)
 #  else
 #    define htonr_us(r0,r1)            extr_us(r0,r1)
@@ -675,15 +675,15 @@ static void 
_htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 #  define extr_i(r0,r1)                        SXTW(r0,r1)
 #  define extr_ui(r0,r1)               UXTW(r0,r1)
 #  define movr(r0,r1)                  _movr(_jit,r0,r1)
-static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr(jit_state_t*,int32_t,jit_int32_t);
 #  define movi(r0,i0)                  _movi(_jit,r0,i0)
-static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
+static void _movi(jit_state_t*,int32_t,jit_word_t);
 #  define movi_p(r0,i0)                        _movi_p(_jit,r0,i0)
-static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
+static jit_word_t _movi_p(jit_state_t*,int32_t,jit_word_t);
 #  define ccr(cc,r0,r1,r2)             _ccr(_jit,cc,r0,r1,r2)
-static void _ccr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ccr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define cci(cc,r0,r1,i0)             _cci(_jit,cc,r0,r1,i0)
-static void _cci(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+static void _cci(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 #  define ltr(r0,r1,r2)                        ccr(CC_LT,r0,r1,r2)
 #  define lti(r0,r1,i0)                        cci(CC_LT,r0,r1,i0)
 #  define ltr_u(r0,r1,r2)              ccr(CC_CC,r0,r1,r2)
@@ -706,10 +706,10 @@ static void 
_cci(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 #  define nei(r0,r1,i0)                        cci(CC_NE,r0,r1,i0)
 #  define bccr(cc,i0,r0,r1)            _bccr(_jit,cc,i0,r0,r1)
 static jit_word_t
-_bccr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+_bccr(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 #  define bcci(cc,i0,r0,i1)            _bcci(_jit,cc,i0,r0,i1)
 static jit_word_t
-_bcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
+_bcci(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_word_t);
 #  define bltr(i0,r0,r1)               bccr(BCC_LT,i0,r0,r1)
 #  define blti(i0,r0,i1)               bcci(BCC_LT,i0,r0,i1)
 #  define bltr_u(i0,r0,r1)             bccr(BCC_CC,i0,r0,r1)
@@ -720,7 +720,7 @@ 
_bcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
 #  define blei_u(i0,r0,i1)             bcci(BCC_LS,i0,r0,i1)
 #  define beqr(i0,r0,r1)               bccr(BCC_EQ,i0,r0,r1)
 #  define beqi(i0,r0,i1)               _beqi(_jit,i0,r0,i1)
-static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _beqi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bger(i0,r0,r1)               bccr(BCC_GE,i0,r0,r1)
 #  define bgei(i0,r0,i1)               bcci(BCC_GE,i0,r0,i1)
 #  define bger_u(i0,r0,r1)             bccr(BCC_CS,i0,r0,r1)
@@ -731,13 +731,13 @@ static jit_word_t 
_beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 #  define bgti_u(i0,r0,i1)             bcci(BCC_HI,i0,r0,i1)
 #  define bner(i0,r0,r1)               bccr(BCC_NE,i0,r0,r1)
 #  define bnei(i0,r0,i1)               _bnei(_jit,i0,r0,i1)
-static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bnei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define baddr(cc,i0,r0,r1)           _baddr(_jit,cc,i0,r0,r1)
 static jit_word_t
-_baddr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+_baddr(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 #  define baddi(cc,i0,r0,i1)           _baddi(_jit,cc,i0,r0,i1)
 static jit_word_t
-_baddi(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
+_baddi(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_word_t);
 #  define boaddr(i0,r0,r1)             baddr(BCC_VS,i0,r0,r1)
 #  define boaddi(i0,r0,i1)             baddi(BCC_VS,i0,r0,i1)
 #  define boaddr_u(i0,r0,r1)           baddr(BCC_HS,i0,r0,r1)
@@ -748,10 +748,10 @@ 
_baddi(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
 #  define bxaddi_u(i0,r0,i1)           baddi(BCC_LO,i0,r0,i1)
 #  define bsubr(cc,i0,r0,r1)           _bsubr(_jit,cc,i0,r0,r1)
 static jit_word_t
-_bsubr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+_bsubr(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 #  define bsubi(cc,i0,r0,i1)           _bsubi(_jit,cc,i0,r0,i1)
 static jit_word_t
-_bsubi(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
+_bsubi(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_word_t);
 #  define bosubr(i0,r0,r1)             bsubr(BCC_VS,i0,r0,r1)
 #  define bosubi(i0,r0,i1)             bsubi(BCC_VS,i0,r0,i1)
 #  define bosubr_u(i0,r0,r1)           bsubr(BCC_LO,i0,r0,r1)
@@ -762,10 +762,10 @@ 
_bsubi(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
 #  define bxsubi_u(i0,r0,i1)           bsubi(BCC_HS,i0,r0,i1)
 #  define bmxr(cc,i0,r0,r1)            _bmxr(_jit,cc,i0,r0,r1)
 static jit_word_t
-_bmxr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+_bmxr(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 #  define bmxi(cc,i0,r0,r1)            _bmxi(_jit,cc,i0,r0,r1)
 static jit_word_t
-_bmxi(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
+_bmxi(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_word_t);
 #  define bmsr(i0,r0,r1)               bmxr(BCC_NE,i0,r0,r1)
 #  define bmsi(i0,r0,i1)               bmxi(BCC_NE,i0,r0,i1)
 #  define bmcr(i0,r0,r1)               bmxr(BCC_EQ,i0,r0,r1)
@@ -785,15 +785,15 @@ static void _prolog(jit_state_t*,jit_node_t*);
 #  define epilog(i0)                   _epilog(_jit,i0)
 static void _epilog(jit_state_t*,jit_node_t*);
 #  define vastart(r0)                  _vastart(_jit, r0)
-static void _vastart(jit_state_t*, jit_int32_t);
+static void _vastart(jit_state_t*, int32_t);
 #  define vaarg(r0, r1)                        _vaarg(_jit, r0, r1)
-static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg(jit_state_t*, int32_t, jit_int32_t);
 #  define patch_at(jump,label)         _patch_at(_jit,jump,label)
 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 #endif
 
 #if CODE
-static jit_int32_t
+static int32_t
 logical_immediate(jit_word_t imm)
 {
     /* There are 5334 possible immediate values, but to avoid the
@@ -826,8 +826,8 @@ logical_immediate(jit_word_t imm)
 }
 
 static void
-_oxxx(jit_state_t *_jit, jit_int32_t Op,
-      jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Rm)
+_oxxx(jit_state_t *_jit, int32_t Op,
+      int32_t Rd, jit_int32_t Rn, jit_int32_t Rm)
 {
     instr_t    i;
     assert(!(Rd &       ~0x1f));
@@ -842,8 +842,8 @@ _oxxx(jit_state_t *_jit, jit_int32_t Op,
 }
 
 static void
-_oxxi(jit_state_t *_jit, jit_int32_t Op,
-      jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Imm12)
+_oxxi(jit_state_t *_jit, int32_t Op,
+      int32_t Rd, jit_int32_t Rn, jit_int32_t Imm12)
 {
     instr_t    i;
     assert(!(Rd    &       ~0x1f));
@@ -858,8 +858,8 @@ _oxxi(jit_state_t *_jit, jit_int32_t Op,
 }
 
 static void
-_oxx9(jit_state_t *_jit, jit_int32_t Op,
-      jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Imm9)
+_oxx9(jit_state_t *_jit, int32_t Op,
+      int32_t Rd, jit_int32_t Rn, jit_int32_t Imm9)
 {
     instr_t    i;
     assert(!(Rd   &       ~0x1f));
@@ -874,7 +874,7 @@ _oxx9(jit_state_t *_jit, jit_int32_t Op,
 }
 
 static void
-_ox19(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, jit_int32_t Simm19)
+_ox19(jit_state_t *_jit, int32_t Op, jit_int32_t Rd, jit_int32_t Simm19)
 {
     instr_t    i;
     assert(!(Rd &         ~0x1f));
@@ -887,7 +887,7 @@ _ox19(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, 
jit_int32_t Simm19)
 }
 
 static void
-_oc19(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Cc, jit_int32_t Simm19)
+_oc19(jit_state_t *_jit, int32_t Op, jit_int32_t Cc, jit_int32_t Simm19)
 {
     instr_t    i;
     assert(!(Cc &          ~0xf));
@@ -900,7 +900,7 @@ _oc19(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Cc, 
jit_int32_t Simm19)
 }
 
 static void
-_o26(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Simm26)
+_o26(jit_state_t *_jit, int32_t Op, jit_int32_t Simm26)
 {
     instr_t    i;
     assert(Simm26 >= -33554432 && Simm26 <= 33554431);
@@ -911,7 +911,7 @@ _o26(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Simm26)
 }
 
 static void
-_ox_x(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, jit_int32_t Rm)
+_ox_x(jit_state_t *_jit, int32_t Op, jit_int32_t Rd, jit_int32_t Rm)
 {
     instr_t    i;
     assert(!(Rd &       ~0x1f));
@@ -924,7 +924,7 @@ _ox_x(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, 
jit_int32_t Rm)
 }
 
 static void
-_o_xx(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, jit_int32_t Rn)
+_o_xx(jit_state_t *_jit, int32_t Op, jit_int32_t Rd, jit_int32_t Rn)
 {
     instr_t    i;
     assert(!(Rd &       ~0x1f));
@@ -937,7 +937,7 @@ _o_xx(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, 
jit_int32_t Rn)
 }
 
 static void
-_oxx_(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rn, jit_int32_t Rm)
+_oxx_(jit_state_t *_jit, int32_t Op, jit_int32_t Rn, jit_int32_t Rm)
 {
     instr_t    i;
     assert(!(Rn &       ~0x1f));
@@ -950,7 +950,7 @@ _oxx_(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rn, 
jit_int32_t Rm)
 }
 
 static void
-_o_x_(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rn)
+_o_x_(jit_state_t *_jit, int32_t Op, jit_int32_t Rn)
 {
     instr_t    i;
     assert(!(Rn & ~0x1f));
@@ -961,7 +961,7 @@ _o_x_(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rn)
 }
 
 static void
-_ox_h(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, jit_int32_t Imm16)
+_ox_h(jit_state_t *_jit, int32_t Op, jit_int32_t Rd, jit_int32_t Imm16)
 {
     instr_t    i;
     assert(!(Rd    &       ~0x1f));
@@ -974,8 +974,8 @@ _ox_h(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Rd, 
jit_int32_t Imm16)
 }
 
 static void
-_oxxrs(jit_state_t *_jit, jit_int32_t Op,
-       jit_int32_t Rd, jit_int32_t Rn, jit_int32_t R, jit_int32_t S)
+_oxxrs(jit_state_t *_jit, int32_t Op,
+       int32_t Rd, jit_int32_t Rn, jit_int32_t R, jit_int32_t S)
 {
     instr_t    i;
     assert(!(Rd &       ~0x1f));
@@ -992,8 +992,8 @@ _oxxrs(jit_state_t *_jit, jit_int32_t Op,
 }
 
 static void
-_oxxxc(jit_state_t *_jit, jit_int32_t Op,
-       jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Rm, jit_int32_t Cc)
+_oxxxc(jit_state_t *_jit, int32_t Op,
+       int32_t Rd, jit_int32_t Rn, jit_int32_t Rm, jit_int32_t Cc)
 {
     instr_t    i;
     assert(!(Rd &       ~0x1f));
@@ -1010,8 +1010,8 @@ _oxxxc(jit_state_t *_jit, jit_int32_t Op,
 }
 
 static void
-_oxxx7(jit_state_t *_jit, jit_int32_t Op,
-       jit_int32_t Rt, jit_int32_t Rt2, jit_int32_t Rn, jit_int32_t Simm7)
+_oxxx7(jit_state_t *_jit, int32_t Op,
+       int32_t Rt, jit_int32_t Rt2, jit_int32_t Rn, jit_int32_t Simm7)
 {
     instr_t    i;
     assert(!(Rt  &       ~0x1f));
@@ -1028,7 +1028,7 @@ _oxxx7(jit_state_t *_jit, jit_int32_t Op,
 }
 
 static void
-_nop(jit_state_t *_jit, jit_int32_t i0)
+_nop(jit_state_t *_jit, int32_t i0)
 {
     for (; i0 > 0; i0 -= 4)
        NOP();
@@ -1036,9 +1036,9 @@ _nop(jit_state_t *_jit, jit_int32_t i0)
 }
 
 static void
-_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         is =  i0 >> 12;
     jit_word_t         in = -i0;
     jit_word_t         iS =  in >> 12;
@@ -1059,9 +1059,9 @@ _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         is =  i0 >> 12;
     jit_word_t         in = -i0;
     jit_word_t         iS =  in >> 12;
@@ -1082,9 +1082,9 @@ _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     addxr(r0, r1, rn(reg));
@@ -1092,9 +1092,9 @@ _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         is = i0 >> 12;
     if (      i0 >= 0 && i0 <= 0xfff)
        SUBI   (r0, r1, i0);
@@ -1109,9 +1109,9 @@ _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         is = i0 >> 12;
     if (      i0 >= 0 && i0 <= 0xfff)
        SUBSI   (r0, r1, i0);
@@ -1126,9 +1126,9 @@ _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     subxr(r0, r1, rn(reg));
@@ -1136,16 +1136,16 @@ _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rsbi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     subi(r0, r1, i0);
     negr(r0, r0);
 }
 
 static void
-_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_muli(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     mulr(r0, r1, rn(reg));
@@ -1153,10 +1153,10 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_qmulr(jit_state_t *_jit, jit_int32_t r0,
-       jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+_qmulr(jit_state_t *_jit, int32_t r0,
+       int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r2 || r0 == r3) {
        reg = jit_get_reg(jit_class_gpr);
        mulr(rn(reg), r2, r3);
@@ -1171,10 +1171,10 @@ _qmulr(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_qmuli(jit_state_t *_jit, jit_int32_t r0,
-       jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+_qmuli(jit_state_t *_jit, int32_t r0,
+       int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     qmulr(r0, r1, r2, rn(reg));
@@ -1182,10 +1182,10 @@ _qmuli(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_qmulr_u(jit_state_t *_jit, jit_int32_t r0,
-        jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+_qmulr_u(jit_state_t *_jit, int32_t r0,
+        int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r2 || r0 == r3) {
        reg = jit_get_reg(jit_class_gpr);
        mulr(rn(reg), r2, r3);
@@ -1200,10 +1200,10 @@ _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_qmuli_u(jit_state_t *_jit, jit_int32_t r0,
-        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+_qmuli_u(jit_state_t *_jit, int32_t r0,
+        int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     qmulr_u(r0, r1, r2, rn(reg));
@@ -1211,9 +1211,9 @@ _qmuli_u(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     divr(r0, r1, rn(reg));
@@ -1221,9 +1221,9 @@ _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     divr_u(r0, r1, rn(reg));
@@ -1232,10 +1232,10 @@ _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 
 static void
 _iqdivr(jit_state_t *_jit, jit_bool_t sign,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
-    jit_int32_t                sv0, rg0;
-    jit_int32_t                sv1, rg1;
+    int32_t            sv0, rg0;
+    int32_t            sv1, rg1;
     if (r0 == r2 || r0 == r3) {
        sv0 = jit_get_reg(jit_class_gpr);
        rg0 = rn(sv0);
@@ -1265,10 +1265,10 @@ _iqdivr(jit_state_t *_jit, jit_bool_t sign,
 }
 
 static void
-_qdivi(jit_state_t *_jit, jit_int32_t r0,
-       jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+_qdivi(jit_state_t *_jit, int32_t r0,
+       int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     qdivr(r0, r1, r2, rn(reg));
@@ -1276,10 +1276,10 @@ _qdivi(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_qdivi_u(jit_state_t *_jit, jit_int32_t r0,
-        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+_qdivi_u(jit_state_t *_jit, int32_t r0,
+        int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     qdivr_u(r0, r1, r2, rn(reg));
@@ -1287,9 +1287,9 @@ _qdivi_u(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r1 || r0 == r2) {
        reg = jit_get_reg(jit_class_gpr);
        divr(rn(reg), r1, r2);
@@ -1305,9 +1305,9 @@ _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     remr(r0, r1, rn(reg));
@@ -1315,9 +1315,9 @@ _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r1 || r0 == r2) {
        reg = jit_get_reg(jit_class_gpr);
        divr_u(rn(reg), r1, r2);
@@ -1333,9 +1333,9 @@ _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     remr_u(r0, r1, rn(reg));
@@ -1343,7 +1343,7 @@ _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (i0 == 0)
        movr(r0, r1);
@@ -1354,7 +1354,7 @@ _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (i0 == 0)
        movr(r0, r1);
@@ -1365,7 +1365,7 @@ _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (i0 == 0)
        movr(r0, r1);
@@ -1376,10 +1376,10 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_andi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
-    jit_int32_t                imm;
+    int32_t            reg;
+    int32_t            imm;
     if (i0 == 0)
        movi(r0, 0);
     else if (i0 == -1)
@@ -1398,10 +1398,10 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
-    jit_int32_t                imm;
+    int32_t            reg;
+    int32_t            imm;
     if (i0 == 0)
        movr(r0, r1);
     else if (i0 == -1)
@@ -1420,10 +1420,10 @@ _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_xori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
-    jit_int32_t                imm;
+    int32_t            reg;
+    int32_t            imm;
     if (i0 == 0)
        movr(r0, r1);
     else if (i0 == -1)
@@ -1443,14 +1443,14 @@ _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 static void
-_htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     htonr_ul(r0, r1);
     rshi_u(r0, r0, 48);
 }
 
 static void
-_htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     htonr_ul(r0, r1);
     rshi_u(r0, r0, 32);
@@ -1458,9 +1458,9 @@ _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 #endif
 
 static void
-_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_c(r0, rn(reg));
@@ -1468,7 +1468,7 @@ _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     LDRBI(r0, r1, 0);
 #if 0
@@ -1477,9 +1477,9 @@ _ldr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_uc(r0, rn(reg));
@@ -1487,9 +1487,9 @@ _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_s(r0, rn(reg));
@@ -1497,7 +1497,7 @@ _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     LDRHI(r0, r1, 0);
 #if 0
@@ -1506,9 +1506,9 @@ _ldr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_us(r0, rn(reg));
@@ -1516,9 +1516,9 @@ _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_i(r0, rn(reg));
@@ -1526,7 +1526,7 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     LDRWI(r0, r1, 0);
 #if 0
@@ -1535,9 +1535,9 @@ _ldr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_ui(r0, rn(reg));
@@ -1545,9 +1545,9 @@ _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_l(r0, rn(reg));
@@ -1555,16 +1555,16 @@ _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     LDRSB(r0, r1, r2);
     extr_c(r0, r0);
 }
 
 static void
-_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= 0 && i0 <= 4095)
        LDRSBI(r0, r1, i0);
     else if (i0 > -256 && i0 < 0)
@@ -1579,7 +1579,7 @@ _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     LDRB(r0, r1, r2);
 #if 0
@@ -1588,9 +1588,9 @@ _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= 0 && i0 <= 4095)
        LDRBI(r0, r1, i0);
     else if (i0 > -256 && i0 < 0)
@@ -1607,9 +1607,9 @@ _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 1));
     if (i0 >= 0 && i0 <= 8191)
        LDRSHI(r0, r1, i0 >> 1);
@@ -1624,7 +1624,7 @@ _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     LDRH(r0, r1, r2);
 #if 0
@@ -1633,9 +1633,9 @@ _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 1));
     if (i0 >= 0 && i0 <= 8191)
        LDRHI(r0, r1, i0 >> 1);
@@ -1653,9 +1653,9 @@ _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 3));
     if (i0 >= 0 && i0 <= 16383)
        LDRSWI(r0, r1, i0 >> 2);
@@ -1670,7 +1670,7 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     LDRW(r0, r1, r2);
 #if 0
@@ -1679,9 +1679,9 @@ _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 3));
     if (i0 >= 0 && i0 <= 16383)
        LDRWI(r0, r1, i0 >> 2);
@@ -1699,9 +1699,9 @@ _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 7));
     if (i0 >= 0 && i0 <= 32767)
        LDRI(r0, r1, i0 >> 3);
@@ -1716,9 +1716,9 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_c(rn(reg), r0);
@@ -1726,9 +1726,9 @@ _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_s(rn(reg), r0);
@@ -1736,9 +1736,9 @@ _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_i(rn(reg), r0);
@@ -1746,9 +1746,9 @@ _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_l(rn(reg), r0);
@@ -1756,9 +1756,9 @@ _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= 0 && i0 <= 4095)
        STRBI(r1, r0, i0);
     else if (i0 > -256 && i0 < 0)
@@ -1772,9 +1772,9 @@ _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 1));
     if (i0 >= 0 && i0 <= 8191)
        STRHI(r1, r0, i0 >> 1);
@@ -1789,9 +1789,9 @@ _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 3));
     if (i0 >= 0 && i0 <= 16383)
        STRWI(r1, r0, i0 >> 2);
@@ -1806,9 +1806,9 @@ _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 7));
     if (i0 >= 0 && i0 <= 32767)
        STRI(r1, r0, i0 >> 3);
@@ -1823,14 +1823,14 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        MOV(r0, r1);
 }
 
 static void
-_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         n0, ibit, nbit;
     n0 = ~i0;
@@ -1939,7 +1939,7 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static jit_word_t
-_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi_p(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         w;
     w = _jit->pc.w;
@@ -1951,18 +1951,18 @@ _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t 
i0)
 }
 
 static void
-_ccr(jit_state_t *_jit, jit_int32_t cc,
-     jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ccr(jit_state_t *_jit, int32_t cc,
+     int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP(r1, r2);
     CSET(r0, cc);
 }
 
 static void
-_cci(jit_state_t *_jit, jit_int32_t cc,
-     jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_cci(jit_state_t *_jit, int32_t cc,
+     int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         is =  i0 >> 12;
     jit_word_t         in = -i0;
     jit_word_t         iS =  in >> 12;
@@ -1984,8 +1984,8 @@ _cci(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_bccr(jit_state_t *_jit, jit_int32_t cc,
-      jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bccr(jit_state_t *_jit, int32_t cc,
+      jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w, d;
     CMP(r0, r1);
@@ -1996,10 +1996,10 @@ _bccr(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_bcci(jit_state_t *_jit, jit_int32_t cc,
-      jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bcci(jit_state_t *_jit, int32_t cc,
+      jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         w, d;
     jit_word_t         is =  i1 >> 12;
     jit_word_t         in = -i1;
@@ -2025,7 +2025,7 @@ _bcci(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_beqi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
     if (i1 == 0) {
@@ -2038,7 +2038,7 @@ _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bnei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
     if (i1 == 0) {
@@ -2051,8 +2051,8 @@ _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_baddr(jit_state_t *_jit, jit_int32_t cc,
-       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_baddr(jit_state_t *_jit, int32_t cc,
+       jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     addcr(r0, r0, r1);
@@ -2062,8 +2062,8 @@ _baddr(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_baddi(jit_state_t *_jit, jit_int32_t cc,
-       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_baddi(jit_state_t *_jit, int32_t cc,
+       jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
     addci(r0, r0, i1);
@@ -2073,8 +2073,8 @@ _baddi(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_bsubr(jit_state_t *_jit, jit_int32_t cc,
-       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bsubr(jit_state_t *_jit, int32_t cc,
+       jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     subcr(r0, r0, r1);
@@ -2084,8 +2084,8 @@ _bsubr(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_bsubi(jit_state_t *_jit, jit_int32_t cc,
-       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bsubi(jit_state_t *_jit, int32_t cc,
+       jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
     subci(r0, r0, i1);
@@ -2095,8 +2095,8 @@ _bsubi(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_bmxr(jit_state_t *_jit, jit_int32_t cc,
-      jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bmxr(jit_state_t *_jit, int32_t cc,
+      jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     TST(r0, r1);
@@ -2106,12 +2106,12 @@ _bmxr(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_bmxi(jit_state_t *_jit, jit_int32_t cc,
-      jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bmxi(jit_state_t *_jit, int32_t cc,
+      jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
-    jit_int32_t                imm;
+    int32_t            reg;
+    int32_t            imm;
     imm = logical_immediate(i1);
     if (imm != -1)
        TSTI(r0, imm);
@@ -2130,7 +2130,7 @@ static void
 _jmpi(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     w = (i0 - _jit->pc.w) >> 2;
     if (w >= -33554432 && w <= 33554431)
        B(w);
@@ -2146,7 +2146,7 @@ static jit_word_t
 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     w = movi_p(rn(reg), i0);
     jmpr(rn(reg));
@@ -2158,7 +2158,7 @@ static void
 _calli(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     w = (i0 - _jit->pc.w) >> 2;
     if (w >= -33554432 && w <= 33554431)
        BL(w);
@@ -2174,7 +2174,7 @@ static jit_word_t
 _calli_p(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     w = movi_p(rn(reg), i0);
     callr(rn(reg));
@@ -2193,9 +2193,9 @@ _calli_p(jit_state_t *_jit, jit_word_t i0)
 static void
 _prolog(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
-       jit_int32_t     frame = -_jitc->function->frame;
+       int32_t frame = -_jitc->function->frame;
        assert(_jitc->function->self.aoff >= frame);
        if (_jitc->function->assume_frame)
            return;
@@ -2310,9 +2310,9 @@ _epilog(jit_state_t *_jit, jit_node_t *node)
 }
 
 static void
-_vastart(jit_state_t *_jit, jit_int32_t r0)
+_vastart(jit_state_t *_jit, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     assert(_jitc->function->self.call & jit_call_varargs);
 
@@ -2345,11 +2345,11 @@ _vastart(jit_state_t *_jit, jit_int32_t r0)
 }
 
 static void
-_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         ge_code;
     jit_word_t         lt_code;
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
 
     assert(_jitc->function->self.call & jit_call_varargs);
 
@@ -2402,9 +2402,9 @@ _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t 
label)
 {
     instr_t             i;
     jit_word_t          d;
-    jit_int32_t                 fc, ff, ffc;
+    int32_t             fc, ff, ffc;
     union {
-       jit_int32_t     *i;
+       int32_t *i;
        jit_word_t       w;
     } u;
     u.w = instr;
diff --git a/jit/aarch64-fpu.c b/jit/aarch64-fpu.c
index 058b98a..4f28668 100644
--- a/jit/aarch64-fpu.c
+++ b/jit/aarch64-fpu.c
@@ -66,65 +66,65 @@
 #  define FDIVS(Rd,Rn,Rm)              osvvv(A64_FDIV,0,Rd,Rn,Rm)
 #  define FDIVD(Rd,Rn,Rm)              osvvv(A64_FDIV,1,Rd,Rn,Rm)
 #  define osvvv(Op,Sz,Rd,Rn,Rm)                _osvvv(_jit,Op,Sz,Rd,Rn,Rm)
-static void _osvvv(jit_state_t*,jit_int32_t,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_int32_t);
+static void _osvvv(jit_state_t*,int32_t,jit_int32_t,
+                  int32_t,jit_int32_t,jit_int32_t);
 #  define osvv_(Op,Sz,Rd,Rn)           _osvv_(_jit,Op,Sz,Rd,Rn)
-static void _osvv_(jit_state_t*,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_int32_t);
+static void _osvv_(jit_state_t*,int32_t,
+                  int32_t,jit_int32_t,jit_int32_t);
 #  define os_vv(Op,Sz,Rn,Rm)           _os_vv(_jit,Op,Sz,Rn,Rm)
-static void _os_vv(jit_state_t*,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_int32_t);
+static void _os_vv(jit_state_t*,int32_t,
+                  int32_t,jit_int32_t,jit_int32_t);
 #  define truncr_f_i(r0,r1)            _truncr_f_i(_jit,r0,r1)
-static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_f_i(jit_state_t*,int32_t,jit_int32_t);
 #  define truncr_f_l(r0,r1)            FCVTSZ_XS(r0,r1)
 #  define truncr_d_i(r0,r1)            _truncr_d_i(_jit,r0,r1)
-static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_d_i(jit_state_t*,int32_t,jit_int32_t);
 #  define truncr_d_l(r0,r1)            FCVTSZ_XD(r0,r1)
 #  define addr_f(r0,r1,r2)             FADDS(r0,r1,r2)
 #  define addi_f(r0,r1,i0)             _addi_f(_jit,r0,r1,i0)
-static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _addi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define subr_f(r0,r1,r2)             FSUBS(r0,r1,r2)
 #  define subi_f(r0,r1,i0)             _subi_f(_jit,r0,r1,i0)
-static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _subi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define rsbr_f(r0, r1, r2)           subr_f(r0, r2, r1)
 #  define rsbi_f(r0, r1, i0)           _rsbi_f(_jit, r0, r1, i0)
-static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _rsbi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define mulr_f(r0,r1,r2)             FMULS(r0,r1,r2)
 #  define muli_f(r0,r1,i0)             _muli_f(_jit,r0,r1,i0)
-static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _muli_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define divr_f(r0,r1,r2)             FDIVS(r0,r1,r2)
 #  define divi_f(r0,r1,i0)             _divi_f(_jit,r0,r1,i0)
-static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _divi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define absr_f(r0,r1)                        FABSS(r0,r1)
 #  define negr_f(r0,r1)                        FNEGS(r0,r1)
 #  define sqrtr_f(r0,r1)               FSQRTS(r0,r1)
 #  define extr_f(r0,r1)                        SCVTFS(r0,r1)
 #  define ldr_f(r0,r1)                 _ldr_f(_jit,r0,r1)
-static void _ldr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_f(r0,i0)                 _ldi_f(_jit,r0,i0)
-static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_f(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_f(r0,r1,r2)             _ldxr_f(_jit,r0,r1,r2)
-static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_f(r0,r1,i0)             _ldxi_f(_jit,r0,r1,i0)
-static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_f(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_f(r0,r1)                 _str_f(_jit,r0,r1)
-static void _str_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _str_f(jit_state_t*,int32_t,jit_int32_t);
 #  define sti_f(i0,r0)                 _sti_f(_jit,i0,r0)
-static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_f(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_f(r0,r1,r2)             _stxr_f(_jit,r0,r1,r2)
-static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_f(i0,r0,r1)             _stxi_f(_jit,i0,r0,r1)
-static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define movr_f(r0,r1)                        _movr_f(_jit,r0,r1)
-static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define movi_f(r0,i0)                        _movi_f(_jit,r0,i0)
-static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t);
+static void _movi_f(jit_state_t*,int32_t,jit_float32_t);
 #  define extr_d_f(r0,r1)              FCVT_SD(r0,r1)
 #  define fccr(cc,r0,r1,r2)            _fccr(_jit,cc,r0,r1,r2)
-static void 
_fccr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _fccr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define fcci(cc,r0,r1,i0)            _fcci(_jit,cc,r0,r1,i0)
 static void _fcci(jit_state_t*,
-                 jit_int32_t,jit_int32_t,jit_int32_t,jit_float32_t);
+                 int32_t,jit_int32_t,jit_int32_t,jit_float32_t);
 #  define ltr_f(r0,r1,r2)              fccr(CC_MI,r0,r1,r2)
 #  define lti_f(r0,r1,i0)              fcci(CC_MI,r0,r1,i0)
 #  define ler_f(r0,r1,r2)              fccr(CC_LS,r0,r1,r2)
@@ -142,27 +142,27 @@ static void _fcci(jit_state_t*,
 #  define unler_f(r0,r1,r2)            fccr(CC_LE,r0,r1,r2)
 #  define unlei_f(r0,r1,i0)            fcci(CC_LE,r0,r1,i0)
 #  define uneqr_f(r0,r1,r2)            _uneqr_f(_jit,r0,r1,r2)
-static void _uneqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _uneqr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define uneqi_f(r0,r1,i0)            _uneqi_f(_jit,r0,r1,i0)
-static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _uneqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define unger_f(r0,r1,r2)            fccr(CC_PL,r0,r1,r2)
 #  define ungei_f(r0,r1,i0)            fcci(CC_PL,r0,r1,i0)
 #  define ungtr_f(r0,r1,r2)            fccr(CC_HI,r0,r1,r2)
 #  define ungti_f(r0,r1,i0)            fcci(CC_HI,r0,r1,i0)
 #  define ltgtr_f(r0,r1,r2)            _ltgtr_f(_jit,r0,r1,r2)
-static void _ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltgtr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ltgti_f(r0,r1,i0)            _ltgti_f(_jit,r0,r1,i0)
-static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _ltgti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define ordr_f(r0,r1,r2)             fccr(CC_VC,r0,r1,r2)
 #  define ordi_f(r0,r1,i0)             fcci(CC_VC,r0,r1,i0)
 #  define unordr_f(r0,r1,r2)           fccr(CC_VS,r0,r1,r2)
 #  define unordi_f(r0,r1,i0)           fcci(CC_VS,r0,r1,i0)
 #define fbccr(cc,i0,r0,r1)             _fbccr(_jit,cc,i0,r0,r1)
 static jit_word_t
-_fbccr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+_fbccr(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 #define fbcci(cc,i0,r0,i1)             _fbcci(_jit,cc,i0,r0,i1)
 static jit_word_t
-_fbcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float32_t);
+_fbcci(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_float32_t);
 #  define bltr_f(i0,r0,r1)             fbccr(BCC_MI,i0,r0,r1)
 #  define blti_f(i0,r0,i1)             fbcci(BCC_MI,i0,r0,i1)
 #  define bler_f(i0,r0,r1)             fbccr(BCC_LS,i0,r0,r1)
@@ -180,66 +180,66 @@ 
_fbcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float32_t);
 #  define bunler_f(i0,r0,r1)           fbccr(BCC_LE,i0,r0,r1)
 #  define bunlei_f(i0,r0,i1)           fbcci(BCC_LE,i0,r0,i1)
 #  define buneqr_f(i0,r0,r1)           _buneqr_f(_jit,i0,r0,r1)
-static jit_word_t _buneqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _buneqr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define buneqi_f(i0,r0,i1)           _buneqi_f(_jit,i0,r0,i1)
-static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define bunger_f(i0,r0,r1)           fbccr(BCC_PL,i0,r0,r1)
 #  define bungei_f(i0,r0,i1)           fbcci(BCC_PL,i0,r0,i1)
 #  define bungtr_f(i0,r0,r1)           fbccr(BCC_HI,i0,r0,r1)
 #  define bungti_f(i0,r0,i1)           fbcci(BCC_HI,i0,r0,i1)
 #  define bltgtr_f(i0,r0,r1)           _bltgtr_f(_jit,i0,r0,r1)
-static jit_word_t _bltgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltgtr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bltgti_f(i0,r0,i1)           _bltgti_f(_jit,i0,r0,i1)
-static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define bordr_f(i0,r0,r1)            fbccr(BCC_VC,i0,r0,r1)
 #  define bordi_f(i0,r0,i1)            fbcci(BCC_VC,i0,r0,i1)
 #  define bunordr_f(i0,r0,r1)          fbccr(BCC_VS,i0,r0,r1)
 #  define bunordi_f(i0,r0,i1)          fbcci(BCC_VS,i0,r0,i1)
 #  define addr_d(r0,r1,r2)             FADDD(r0,r1,r2)
 #  define addi_d(r0,r1,i0)             _addi_d(_jit,r0,r1,i0)
-static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _addi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define subr_d(r0,r1,r2)             FSUBD(r0,r1,r2)
 #  define subi_d(r0,r1,i0)             _subi_d(_jit,r0,r1,i0)
-static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _subi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define rsbr_d(r0, r1, r2)           subr_d(r0, r2, r1)
 #  define rsbi_d(r0, r1, i0)           _rsbi_d(_jit, r0, r1, i0)
-static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _rsbi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define mulr_d(r0,r1,r2)             FMULD(r0,r1,r2)
 #  define muli_d(r0,r1,i0)             _muli_d(_jit,r0,r1,i0)
-static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _muli_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define divr_d(r0,r1,r2)             FDIVD(r0,r1,r2)
 #  define divi_d(r0,r1,i0)             _divi_d(_jit,r0,r1,i0)
-static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _divi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define absr_d(r0,r1)                        FABSD(r0,r1)
 #  define negr_d(r0,r1)                        FNEGD(r0,r1)
 #  define sqrtr_d(r0,r1)               FSQRTD(r0,r1)
 #  define extr_d(r0,r1)                        SCVTFD(r0,r1)
 #  define ldr_d(r0,r1)                 _ldr_d(_jit,r0,r1)
-static void _ldr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_d(r0,i0)                 _ldi_d(_jit,r0,i0)
-static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_d(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_d(r0,r1,r2)             _ldxr_d(_jit,r0,r1,r2)
-static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_d(r0,r1,i0)             _ldxi_d(_jit,r0,r1,i0)
-static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_d(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_d(r0,r1)                 _str_d(_jit,r0,r1)
-static void _str_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _str_d(jit_state_t*,int32_t,jit_int32_t);
 #  define sti_d(i0,r0)                 _sti_d(_jit,i0,r0)
-static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_d(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_d(r0,r1,r2)             _stxr_d(_jit,r0,r1,r2)
-static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_d(i0,r0,r1)             _stxi_d(_jit,i0,r0,r1)
-static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define movr_d(r0,r1)                        _movr_d(_jit,r0,r1)
-static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define movi_d(r0,i0)                        _movi_d(_jit,r0,i0)
-static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t);
+static void _movi_d(jit_state_t*,int32_t,jit_float64_t);
 #  define extr_f_d(r0,r1)              FCVT_DS(r0,r1)
 #  define dccr(cc,r0,r1,r2)            _dccr(_jit,cc,r0,r1,r2)
-static void 
_dccr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _dccr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define dcci(cc,r0,r1,i0)            _dcci(_jit,cc,r0,r1,i0)
 static void _dcci(jit_state_t*,
-                 jit_int32_t,jit_int32_t,jit_int32_t,jit_float64_t);
+                 int32_t,jit_int32_t,jit_int32_t,jit_float64_t);
 #  define ltr_d(r0,r1,r2)              dccr(CC_MI,r0,r1,r2)
 #  define lti_d(r0,r1,i0)              dcci(CC_MI,r0,r1,i0)
 #  define ler_d(r0,r1,r2)              dccr(CC_LS,r0,r1,r2)
@@ -257,27 +257,27 @@ static void _dcci(jit_state_t*,
 #  define unler_d(r0,r1,r2)            dccr(CC_LE,r0,r1,r2)
 #  define unlei_d(r0,r1,i0)            dcci(CC_LE,r0,r1,i0)
 #  define uneqr_d(r0,r1,r2)            _uneqr_d(_jit,r0,r1,r2)
-static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _uneqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define uneqi_d(r0,r1,i0)            _uneqi_d(_jit,r0,r1,i0)
-static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _uneqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define unger_d(r0,r1,r2)            dccr(CC_PL,r0,r1,r2)
 #  define ungei_d(r0,r1,i0)            dcci(CC_PL,r0,r1,i0)
 #  define ungtr_d(r0,r1,r2)            dccr(CC_HI,r0,r1,r2)
 #  define ungti_d(r0,r1,i0)            dcci(CC_HI,r0,r1,i0)
 #  define ltgtr_d(r0,r1,r2)            _ltgtr_d(_jit,r0,r1,r2)
-static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltgtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ltgti_d(r0,r1,i0)            _ltgti_d(_jit,r0,r1,i0)
-static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _ltgti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define ordr_d(r0,r1,r2)             dccr(CC_VC,r0,r1,r2)
 #  define ordi_d(r0,r1,i0)             dcci(CC_VC,r0,r1,i0)
 #  define unordr_d(r0,r1,r2)           dccr(CC_VS,r0,r1,r2)
 #  define unordi_d(r0,r1,i0)           dcci(CC_VS,r0,r1,i0)
 #define dbccr(cc,i0,r0,r1)             _dbccr(_jit,cc,i0,r0,r1)
 static jit_word_t
-_dbccr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
+_dbccr(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_int32_t);
 #define dbcci(cc,i0,r0,i1)             _dbcci(_jit,cc,i0,r0,i1)
 static jit_word_t
-_dbcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float64_t);
+_dbcci(jit_state_t*,int32_t,jit_word_t,jit_int32_t,jit_float64_t);
 #  define bltr_d(i0,r0,r1)             dbccr(BCC_MI,i0,r0,r1)
 #  define blti_d(i0,r0,i1)             dbcci(BCC_MI,i0,r0,i1)
 #  define bler_d(i0,r0,r1)             dbccr(BCC_LS,i0,r0,r1)
@@ -295,29 +295,29 @@ 
_dbcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float64_t);
 #  define bunler_d(i0,r0,r1)           dbccr(BCC_LE,i0,r0,r1)
 #  define bunlei_d(i0,r0,i1)           dbcci(BCC_LE,i0,r0,i1)
 #  define buneqr_d(i0,r0,r1)           _buneqr_d(_jit,i0,r0,r1)
-static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define buneqi_d(i0,r0,i1)           _buneqi_d(_jit,i0,r0,i1)
-static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define bunger_d(i0,r0,r1)           dbccr(BCC_PL,i0,r0,r1)
 #  define bungei_d(i0,r0,i1)           dbcci(BCC_PL,i0,r0,i1)
 #  define bungtr_d(i0,r0,r1)           dbccr(BCC_HI,i0,r0,r1)
 #  define bungti_d(i0,r0,i1)           dbcci(BCC_HI,i0,r0,i1)
 #  define bltgtr_d(i0,r0,r1)           _bltgtr_d(_jit,i0,r0,r1)
-static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bltgti_d(i0,r0,i1)           _bltgti_d(_jit,i0,r0,i1)
-static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define bordr_d(i0,r0,r1)            dbccr(BCC_VC,i0,r0,r1)
 #  define bordi_d(i0,r0,i1)            dbcci(BCC_VC,i0,r0,i1)
 #  define bunordr_d(i0,r0,r1)          dbccr(BCC_VS,i0,r0,r1)
 #  define bunordi_d(i0,r0,i1)          dbcci(BCC_VS,i0,r0,i1)
 #  define vaarg_d(r0, r1)              _vaarg_d(_jit, r0, r1)
-static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg_d(jit_state_t*, int32_t, jit_int32_t);
 #endif
 
 #if CODE
 static void
-_osvvv(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Sz,
-       jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Rm)
+_osvvv(jit_state_t *_jit, int32_t Op, jit_int32_t Sz,
+       int32_t Rd, jit_int32_t Rn, jit_int32_t Rm)
 {
     instr_t    i;
     assert(!(Rd &       ~0x1f));
@@ -334,8 +334,8 @@ _osvvv(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Sz,
 }
 
 static void
-_osvv_(jit_state_t *_jit, jit_int32_t Op,
-       jit_int32_t Sz, jit_int32_t Rd, jit_int32_t Rn)
+_osvv_(jit_state_t *_jit, int32_t Op,
+       int32_t Sz, jit_int32_t Rd, jit_int32_t Rn)
 {
     instr_t    i;
     assert(!(Rd &       ~0x1f));
@@ -350,8 +350,8 @@ _osvv_(jit_state_t *_jit, jit_int32_t Op,
 }
 
 static void
-_os_vv(jit_state_t *_jit, jit_int32_t Op,
-       jit_int32_t Sz, jit_int32_t Rn, jit_int32_t Rm)
+_os_vv(jit_state_t *_jit, int32_t Op,
+       int32_t Sz, jit_int32_t Rn, jit_int32_t Rm)
 {
     instr_t    i;
     assert(!(Rn &       ~0x1f));
@@ -368,9 +368,9 @@ _os_vv(jit_state_t *_jit, jit_int32_t Op,
 #define fopi(name)                                                     \
 static void                                                            \
 _##name##i_f(jit_state_t *_jit,                                                
\
-            jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)          \
+            int32_t r0, jit_int32_t r1, jit_float32_t i0)              \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     movi_f(rn(reg), i0);                                               \
     name##r_f(r0, r1, rn(reg));                                                
\
     jit_unget_reg(reg);                                                        
\
@@ -378,9 +378,9 @@ _##name##i_f(jit_state_t *_jit,                             
                \
 #define dopi(name)                                                     \
 static void                                                            \
 _##name##i_d(jit_state_t *_jit,                                                
\
-            jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)          \
+            int32_t r0, jit_int32_t r1, jit_float64_t i0)              \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     movi_d(rn(reg), i0);                                               \
     name##r_d(r0, r1, rn(reg));                                                
\
     jit_unget_reg(reg);                                                        
\
@@ -388,10 +388,10 @@ _##name##i_d(jit_state_t *_jit,                           
                \
 #define fbopi(name)                                                    \
 static jit_word_t                                                      \
 _b##name##i_f(jit_state_t *_jit,                                       \
-             jit_word_t i0, jit_int32_t r0, jit_float32_t i1)          \
+             jit_word_t i0, int32_t r0, jit_float32_t i1)              \
 {                                                                      \
     jit_word_t         word;                                           \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr|                
\
+    int32_t            reg = jit_get_reg(jit_class_fpr|                \
                                          jit_class_nospill);           \
     movi_f(rn(reg), i1);                                               \
     word = b##name##r_f(i0, r0, rn(reg));                              \
@@ -401,10 +401,10 @@ _b##name##i_f(jit_state_t *_jit,                          
        \
 #define dbopi(name)                                                    \
 static jit_word_t                                                      \
 _b##name##i_d(jit_state_t *_jit,                                       \
-             jit_word_t i0, jit_int32_t r0, jit_float64_t i1)          \
+             jit_word_t i0, int32_t r0, jit_float64_t i1)              \
 {                                                                      \
     jit_word_t         word;                                           \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr|                
\
+    int32_t            reg = jit_get_reg(jit_class_fpr|                \
                                          jit_class_nospill);           \
     movi_d(rn(reg), i1);                                               \
     word = b##name##r_d(i0, r0, rn(reg));                              \
@@ -413,14 +413,14 @@ _b##name##i_d(jit_state_t *_jit,                          
        \
 }
 
 static void
-_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_f_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     FCVTSZ_WS(r0, r1);
     extr_i(r0, r0);
 }
 
 static void
-_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_d_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     FCVTSZ_WD(r0, r1);
     extr_i(r0, r0);
@@ -433,9 +433,9 @@ fopi(mul)
 fopi(div)
 
 static void
-_ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ldr_i(rn(reg), r1);
     FMOVSW(r0, rn(reg));
@@ -443,9 +443,9 @@ _ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ldi_i(rn(reg), i0);
     FMOVSW(r0, rn(reg));
@@ -453,9 +453,9 @@ _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ldxr_i(rn(reg), r1, r2);
     FMOVSW(r0, rn(reg));
@@ -463,9 +463,9 @@ _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ldxi_i(rn(reg), r1, i0);
     FMOVSW(r0, rn(reg));
@@ -473,9 +473,9 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_str_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     FMOVWS(rn(reg), r1);
     str_i(r0, rn(reg));
@@ -483,9 +483,9 @@ _str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     FMOVWS(rn(reg), r0);
     sti_i(i0, rn(reg));
@@ -493,9 +493,9 @@ _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     FMOVWS(rn(reg), r2);
     stxr_i(r0, r1, rn(reg));
@@ -503,9 +503,9 @@ _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     FMOVWS(rn(reg), r1);
     stxi_i(i0, r0, rn(reg));
@@ -513,20 +513,20 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        FMOVS(r0, r1);
 }
 
 static void
-_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0)
+_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t i0)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } u;
-    jit_int32_t                reg;
+    int32_t            reg;
     u.f = i0;
     if (u.i == 0)
        FMOVSW(r0, WZR_REGNO);
@@ -540,18 +540,18 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t 
i0)
 }
 
 static void
-_fccr(jit_state_t *_jit, jit_int32_t cc,
-      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_fccr(jit_state_t *_jit, int32_t cc,
+      int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPES(r1, r2);
     CSET(r0, cc);
 }
 
 static void
-_fcci(jit_state_t *_jit, jit_int32_t cc,
-      jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
+_fcci(jit_state_t *_jit, int32_t cc,
+      int32_t r0, jit_int32_t r1, jit_float32_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     movi_f(rn(reg), i0);
     fccr(cc, r0, r1, rn(reg));
@@ -559,7 +559,7 @@ _fcci(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static void
-_uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_uneqr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     FCMPES(r1, r2);
@@ -572,7 +572,7 @@ _uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(uneq)
 
 static void
-_ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltgtr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     FCMPES(r1, r2);
@@ -585,8 +585,8 @@ _ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(ltgt)
 
 static jit_word_t
-_fbccr(jit_state_t *_jit, jit_int32_t cc,
-       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_fbccr(jit_state_t *_jit, int32_t cc,
+       jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w, d;
     FCMPES(r0, r1);
@@ -597,11 +597,11 @@ _fbccr(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_fbcci(jit_state_t *_jit, jit_int32_t cc,
-       jit_word_t i0, jit_int32_t r0, jit_float32_t i1)
+_fbcci(jit_state_t *_jit, int32_t cc,
+       jit_word_t i0, int32_t r0, jit_float32_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi_f(rn(reg), i1);
     w = fbccr(cc, i0, r0, rn(reg));
@@ -610,7 +610,7 @@ _fbcci(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_buneqr_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         u, v, w;
     FCMPES(r0, r1);
@@ -627,7 +627,7 @@ _buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 fbopi(uneq)
 
 static jit_word_t
-_bltgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltgtr_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         u, v, w;
     FCMPES(r0, r1);
@@ -650,9 +650,9 @@ dopi(mul)
 dopi(div)
 
 static void
-_ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ldr_l(rn(reg), r1);
     FMOVDX(r0, rn(reg));
@@ -660,9 +660,9 @@ _ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ldi_l(rn(reg), i0);
     FMOVDX(r0, rn(reg));
@@ -670,9 +670,9 @@ _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ldxr_l(rn(reg), r1, r2);
     FMOVDX(r0, rn(reg));
@@ -680,9 +680,9 @@ _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ldxi_l(rn(reg), r1, i0);
     FMOVDX(r0, rn(reg));
@@ -690,9 +690,9 @@ _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_str_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_str_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     FMOVXD(rn(reg), r1);
     str_l(r0, rn(reg));
@@ -700,9 +700,9 @@ _str_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     FMOVXD(rn(reg), r0);
     sti_l(i0, rn(reg));
@@ -710,9 +710,9 @@ _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     FMOVXD(rn(reg), r2);
     stxr_l(r0, r1, rn(reg));
@@ -720,9 +720,9 @@ _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     FMOVXD(rn(reg), r1);
     stxi_l(i0, r0, rn(reg));
@@ -730,20 +730,20 @@ _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        FMOVD(r0, r1);
 }
 
 static void
-_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0)
+_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t i0)
 {
     union {
-       jit_int64_t     l;
+       int64_t l;
        jit_float64_t   d;
     } u;
-    jit_int32_t                reg;
+    int32_t            reg;
     u.d = i0;
     if (u.l == 0)
        FMOVDX(r0, XZR_REGNO);
@@ -756,18 +756,18 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t 
i0)
 }
 
 static void
-_dccr(jit_state_t *_jit, jit_int32_t cc,
-      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_dccr(jit_state_t *_jit, int32_t cc,
+      int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPED(r1, r2);
     CSET(r0, cc);
 }
 
 static void
-_dcci(jit_state_t *_jit, jit_int32_t cc,
-      jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
+_dcci(jit_state_t *_jit, int32_t cc,
+      int32_t r0, jit_int32_t r1, jit_float64_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     movi_d(rn(reg), i0);
     dccr(cc, r0, r1, rn(reg));
@@ -775,7 +775,7 @@ _dcci(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static void
-_uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_uneqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     FCMPED(r1, r2);
@@ -788,7 +788,7 @@ _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(uneq)
 
 static void
-_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltgtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     FCMPED(r1, r2);
@@ -801,8 +801,8 @@ _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(ltgt)
 
 static jit_word_t
-_dbccr(jit_state_t *_jit, jit_int32_t cc,
-       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_dbccr(jit_state_t *_jit, int32_t cc,
+       jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w, d;
     FCMPED(r0, r1);
@@ -813,11 +813,11 @@ _dbccr(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_dbcci(jit_state_t *_jit, jit_int32_t cc,
-       jit_word_t i0, jit_int32_t r0, jit_float64_t i1)
+_dbcci(jit_state_t *_jit, int32_t cc,
+       jit_word_t i0, int32_t r0, jit_float64_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi_d(rn(reg), i1);
     w = dbccr(cc, i0, r0, rn(reg));
@@ -826,7 +826,7 @@ _dbcci(jit_state_t *_jit, jit_int32_t cc,
 }
 
 static jit_word_t
-_buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_buneqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         u, v, w;
     FCMPED(r0, r1);
@@ -843,7 +843,7 @@ _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 dbopi(uneq)
 
 static jit_word_t
-_bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         u, v, w;
     FCMPED(r0, r1);
@@ -860,11 +860,11 @@ _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 dbopi(ltgt)
 
 static void
-_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         ge_code;
     jit_word_t         lt_code;
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
 
     assert(_jitc->function->self.call & jit_call_varargs);
 
diff --git a/jit/aarch64.c b/jit/aarch64.c
index dea4c20..194e122 100644
--- a/jit/aarch64.c
+++ b/jit/aarch64.c
@@ -31,17 +31,17 @@ typedef struct jit_va_list {
     jit_pointer_t      stack;
     jit_pointer_t      gptop;
     jit_pointer_t      fptop;
-    jit_int32_t                gpoff;
-    jit_int32_t                fpoff;
-
-    jit_int64_t                x0;
-    jit_int64_t                x1;
-    jit_int64_t                x2;
-    jit_int64_t                x3;
-    jit_int64_t                x4;
-    jit_int64_t                x5;
-    jit_int64_t                x6;
-    jit_int64_t                x7;
+    int32_t            gpoff;
+    int32_t            fpoff;
+
+    int64_t            x0;
+    int64_t            x1;
+    int64_t            x2;
+    int64_t            x3;
+    int64_t            x4;
+    int64_t            x5;
+    int64_t            x6;
+    int64_t            x7;
 
     jit_qreg_t         q0;
     jit_qreg_t         q1;
@@ -155,7 +155,7 @@ _jit_init(jit_state_t *_jit)
 void
 _jit_prolog(jit_state_t *_jit)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
 
     if (_jitc->function)
        jit_epilog();
@@ -175,7 +175,7 @@ _jit_prolog(jit_state_t *_jit)
     _jitc->function->self.aoff = 0;
     _jitc->function->self.call = jit_call_default;
     jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
-             _jitc->reglen * sizeof(jit_int32_t));
+             _jitc->reglen * sizeof(int32_t));
 
     /* _no_link here does not mean the jit_link() call can be removed
      * by rewriting as:
@@ -194,8 +194,8 @@ _jit_prolog(jit_state_t *_jit)
     jit_regset_new(&_jitc->function->regset);
 }
 
-jit_int32_t
-_jit_allocai(jit_state_t *_jit, jit_int32_t length)
+int32_t
+_jit_allocai(jit_state_t *_jit, int32_t length)
 {
     assert(_jitc->function);
     switch (length) {
@@ -213,13 +213,13 @@ _jit_allocai(jit_state_t *_jit, jit_int32_t length)
 }
 
 void
-_jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_allocar(jit_state_t *_jit, int32_t u, jit_int32_t v)
 {
-    jit_int32_t                 r0, r1;
+    int32_t             r0, r1;
     assert(_jitc->function);
     jit_inc_synth_ww(allocar, u, v);
     if (!_jitc->function->allocar) {
-       _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
+       _jitc->function->aoffoff = jit_allocai(sizeof(int32_t));
        _jitc->function->allocar = 1;
     }
     r0 = jit_get_reg(jit_class_gpr);
@@ -258,7 +258,7 @@ _jit_ret(jit_state_t *_jit)
 }
 
 void
-_jit_retr(jit_state_t *_jit, jit_int32_t u)
+_jit_retr(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr, u);
     if (JIT_RET != u)
@@ -278,7 +278,7 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_f(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_f, u);
     if (u != JIT_FRET)
@@ -299,7 +299,7 @@ _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_d(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_d, u);
     if (u != JIT_FRET)
@@ -372,7 +372,7 @@ _jit_ellipsis(jit_state_t *_jit)
 }
 
 void
-_jit_va_push(jit_state_t *_jit, jit_int32_t u)
+_jit_va_push(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(va_push, u);
     jit_pushargr(u);
@@ -383,7 +383,7 @@ jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     assert(!(_jitc->function->self.call & jit_call_varargs));
     if (jit_arg_reg_p(_jitc->function->self.argi))
@@ -402,7 +402,7 @@ jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     assert(!(_jitc->function->self.call & jit_call_varargs));
     if (jit_arg_f_reg_p(_jitc->function->self.argf))
@@ -421,7 +421,7 @@ jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     assert(!(_jitc->function->self.call & jit_call_varargs));
     if (jit_arg_f_reg_p(_jitc->function->self.argf))
@@ -437,7 +437,7 @@ _jit_arg_d(jit_state_t *_jit)
 }
 
 void
-_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_c(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_c, u, v);
@@ -449,7 +449,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_uc(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_uc, u, v);
@@ -461,7 +461,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_s(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_s, u, v);
@@ -473,7 +473,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_us(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_us, u, v);
@@ -485,7 +485,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_i(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_i, u, v);
@@ -497,7 +497,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_ui(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_ui, u, v);
@@ -509,7 +509,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_l(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_l, u, v);
@@ -521,7 +521,7 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargr, u, v);
@@ -535,7 +535,7 @@ _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargi, u, v);
     if (jit_arg_reg_p(v->u.w))
@@ -550,7 +550,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 }
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(getarg_f, u, v);
@@ -562,7 +562,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(putargr_f, u, v);
@@ -576,7 +576,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_fp(putargi_f, u, v);
     if (jit_arg_f_reg_p(v->u.w))
@@ -591,7 +591,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, 
jit_node_t *v)
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(getarg_d, u, v);
@@ -603,7 +603,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(putargr_d, u, v);
@@ -617,7 +617,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_dp(putargi_d, u, v);
     if (jit_arg_reg_p(v->u.w))
@@ -632,7 +632,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, 
jit_node_t *v)
 }
 
 void
-_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr, u);
@@ -651,7 +651,7 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_w(pushargi, u);
     jit_link_prepare();
@@ -670,7 +670,7 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_f(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_f, u);
@@ -689,7 +689,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(_jitc->function);
     jit_inc_synth_f(pushargi_f, u);
     jit_link_prepare();
@@ -708,7 +708,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_d(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_d, u);
@@ -727,7 +727,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(_jitc->function);
     jit_inc_synth_d(pushargi_d, u);
     jit_link_prepare();
@@ -746,9 +746,9 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 }
 
 jit_bool_t
-_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, int32_t regno)
 {
-    jit_int32_t                spec;
+    int32_t            spec;
     spec = jit_class(_rvs[regno].spec);
     if (spec & jit_class_arg) {
        regno = JIT_RA0 - regno;
@@ -765,7 +765,7 @@ _jit_regarg_p(jit_state_t *_jit, jit_node_t *node, 
jit_int32_t regno)
 }
 
 void
-_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
+_jit_finishr(jit_state_t *_jit, int32_t r0)
 {
     jit_node_t         *node;
     assert(_jitc->function);
@@ -800,7 +800,7 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
 }
 
 void
-_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_c(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_c, r0);
     jit_extr_c(r0, JIT_RET);
@@ -808,7 +808,7 @@ _jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_uc(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_uc, r0);
     jit_extr_uc(r0, JIT_RET);
@@ -816,7 +816,7 @@ _jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_s(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_s, r0);
     jit_extr_s(r0, JIT_RET);
@@ -824,7 +824,7 @@ _jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_us(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_us, r0);
     jit_extr_us(r0, JIT_RET);
@@ -832,7 +832,7 @@ _jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_i(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_i, r0);
     jit_extr_i(r0, JIT_RET);
@@ -840,7 +840,7 @@ _jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_ui(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_ui, r0);
     jit_extr_ui(r0, JIT_RET);
@@ -848,7 +848,7 @@ _jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_l(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_l, r0);
     if (r0 != JIT_RET)
@@ -857,7 +857,7 @@ _jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_f(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_f, r0);
     if (r0 != JIT_FRET)
@@ -866,7 +866,7 @@ _jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_d(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_d, r0);
     if (r0 != JIT_FRET)
@@ -881,16 +881,16 @@ _emit_code(jit_state_t *_jit)
     jit_node_t         *temp;
     jit_word_t          word;
     jit_word_t          value;
-    jit_int32_t                 offset;
+    int32_t             offset;
     struct {
        jit_node_t      *node;
-       jit_uint8_t     *data;
+       uint8_t *data;
        jit_word_t       word;
 #if DEVEL_DISASSEMBLER
        jit_word_t       prevw;
 #endif
-       jit_int32_t      const_offset;
-       jit_int32_t      patch_offset;
+       int32_t  const_offset;
+       int32_t  patch_offset;
     } undo;
 #if DEVEL_DISASSEMBLER
     jit_word_t          prevw;
@@ -1536,25 +1536,25 @@ jit_flush(void *fptr, void *tptr)
 }
 
 void
-_emit_ldxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi(rn(r0), rn(r1), i0);
 }
 
 void
-_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     stxi(i0, rn(r0), rn(r1));
 }
 
 void
-_emit_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi_d(rn(r0), rn(r1), i0);
 }
 
 void
-_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     stxi_d(i0, rn(r0), rn(r1));
 }
@@ -1562,7 +1562,7 @@ _emit_stxi_d(jit_state_t *_jit, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 static void
 _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
 {
-    jit_int32_t                 flag;
+    int32_t             flag;
 
     assert(node->flag & jit_flag_node);
     if (node->code == jit_code_movi)
diff --git a/jit/alpha-cpu.c b/jit/alpha-cpu.c
index a590290..48a94de 100644
--- a/jit/alpha-cpu.c
+++ b/jit/alpha-cpu.c
@@ -304,188 +304,188 @@ static void _Opi(jit_state_t*,int,int,unsigned 
int,unsigned int,int);
 #  define NEGQ(ra,rc)                  SUBQ(_R31_REGNO,ra,rc)
 #  define NOT(ra,rc)                   ORNOT(_R31_REGNO,ra,rc)
 #  define nop(i0)                      _nop(_jit,i0)
-static void _nop(jit_state_t*,jit_int32_t);
+static void _nop(jit_state_t*,int32_t);
 #  define movr(r0,r1)                  _movr(_jit,r0,r1)
-static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr(jit_state_t*,int32_t,jit_int32_t);
 #  define movi(r0,i0)                  _movi(_jit,r0,i0)
-static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
+static void _movi(jit_state_t*,int32_t,jit_word_t);
 #  define movi_p(r0,i0)                        _movi_p(_jit,r0,i0)
-static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
+static jit_word_t _movi_p(jit_state_t*,int32_t,jit_word_t);
 #  define negr(r0,r1)                  NEGQ(r1,r0)
 #  define comr(r0,r1)                  NOT(r1,r0)
 #  define addr(r0,r1,r2)               ADDQ(r1,r2,r0)
 #  define addi(r0,r1,i0)               _addi(_jit,r0,r1,i0)
-static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addcr(r0,r1,i0)              _addcr(_jit,r0,r1,i0)
-static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addcr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define addci(r0,r1,i0)              _addci(_jit,r0,r1,i0)
-static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addxr(r0,r1,i0)              _addxr(_jit,r0,r1,i0)
-static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addxr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define addxi(r0,r1,i0)              _addxi(_jit,r0,r1,i0)
-static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subr(r0,r1,r2)               SUBQ(r1,r2,r0)
 #  define subi(r0,r1,i0)               _subi(_jit,r0,r1,i0)
-static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subcr(r0,r1,i0)              _subcr(_jit,r0,r1,i0)
-static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subcr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subci(r0,r1,i0)              _subci(_jit,r0,r1,i0)
-static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subxr(r0,r1,i0)              _subxr(_jit,r0,r1,i0)
-static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subxr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subxi(r0,r1,i0)              _subxi(_jit,r0,r1,i0)
-static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rsbi(r0, r1, i0)             _rsbi(_jit, r0, r1, i0)
-static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t, jit_word_t);
+static void _rsbi(jit_state_t*,int32_t,jit_int32_t, jit_word_t);
 #  define mulr(r0,r1,r2)               MULQ(r1,r2,r0)
 #  define muli(r0,r1,i0)               _muli(_jit,r0,r1,i0)
-static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _muli(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qmulr(r0,r1,r2,r3)           _qmulr(_jit,r0,r1,r2,r3)
-static void _qmulr(jit_state_t*,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_int32_t);
+static void _qmulr(jit_state_t*,int32_t,
+                  int32_t,jit_int32_t,jit_int32_t);
 #  define qmuli(r0,r1,r2,i0)           _qmuli(_jit,r0,r1,r2,i0)
-static void _qmuli(jit_state_t*,jit_int32_t,
-                  jit_int32_t,jit_int32_t,jit_word_t);
+static void _qmuli(jit_state_t*,int32_t,
+                  int32_t,jit_int32_t,jit_word_t);
 #  define qmulr_u(r0,r1,r2,r3)         _qmulr_u(_jit,r0,r1,r2,r3)
-static void _qmulr_u(jit_state_t*,jit_int32_t,
-                    jit_int32_t,jit_int32_t,jit_int32_t);
+static void _qmulr_u(jit_state_t*,int32_t,
+                    int32_t,jit_int32_t,jit_int32_t);
 #  define qmuli_u(r0,r1,r2,i0)         _qmuli_u(_jit,r0,r1,r2,i0)
-static void _qmuli_u(jit_state_t*,jit_int32_t,
-                    jit_int32_t,jit_int32_t,jit_word_t);
+static void _qmuli_u(jit_state_t*,int32_t,
+                    int32_t,jit_int32_t,jit_word_t);
 static jit_word_t __idiv(jit_word_t, jit_word_t);
 #  define divr(r0,r1,r2)               _divr(_jit,r0,r1,r2)
-static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define divi(r0,r1,i0)               _divi(_jit,r0,r1,i0)
-static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static jit_uword_t __udiv(jit_uword_t, jit_uword_t);
 #  define divr_u(r0,r1,r2)             _divr_u(_jit,r0,r1,r2)
-static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define divi_u(r0,r1,i0)             _divi_u(_jit,r0,r1,i0)
-static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static jit_word_t __irem(jit_word_t, jit_word_t);
 #  define remr(r0,r1,r2)               _remr(_jit,r0,r1,r2)
-static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi(r0,r1,i0)               _remi(_jit,r0,r1,i0)
-static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static jit_uword_t __urem(jit_uword_t, jit_uword_t);
 #  define remr_u(r0,r1,r2)             _remr_u(_jit,r0,r1,r2)
-static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi_u(r0,r1,i0)             _remi_u(_jit,r0,r1,i0)
-static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static jit_word_t __idivrem(jit_word_t, jit_word_t, jit_word_t*);
 #  define qdivr(r0,r1,r2,r3)           _qdivr(_jit,r0,r1,r2,r3)
 static void _qdivr(jit_state_t*,
-                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+                  int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define qdivi(r0,r1,r2,i0)           _qdivi(_jit,r0,r1,r2,i0)
 static void _qdivi(jit_state_t*,
-                  jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+                  int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 static jit_word_t __udivrem(jit_uword_t, jit_uword_t, jit_uword_t*);
 #  define qdivr_u(r0,r1,r2,r3)         _qdivr_u(_jit,r0,r1,r2,r3)
 static void _qdivr_u(jit_state_t*,
-                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+                    int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define qdivi_u(r0,r1,r2,i0)         _qdivi_u(_jit,r0,r1,r2,i0)
 static void _qdivi_u(jit_state_t*,
-                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+                    int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 #  define lshr(r0,r1,r2)               SLL(r1,r2,r0)
 #  define lshi(r0,r1,i0)               _lshi(_jit,r0,r1,i0)
-static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rshr(r0,r1,r2)               SRA(r1,r2,r0)
 #  define rshi(r0,r1,i0)               _rshi(_jit,r0,r1,i0)
-static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rshr_u(r0,r1,r2)             SRL(r1,r2,r0)
 #  define rshi_u(r0,r1,i0)             _rshi_u(_jit,r0,r1,i0)
-static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define andr(r0,r1,r2)               AND(r1,r2,r0)
 #  define andi(r0,r1,i0)               _andi(_jit,r0,r1,i0)
-static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _andi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define orr(r0,r1,r2)                        OR(r1,r2,r0)
 #  define ori(r0,r1,i0)                        _ori(_jit,r0,r1,i0)
-static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define xorr(r0,r1,r2)               XOR(r1,r2,r0)
 #  define xori(r0,r1,i0)               _xori(_jit,r0,r1,i0)
-static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _xori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ltr(r0,r1,r2)                        CMPLT(r1,r2,r0)
 #  define lti(r0,r1,i0)                        _lti(_jit,r0,r1,i0)
-static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lti(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ltr_u(r0,r1,r2)              CMPULT(r1,r2,r0)
 #  define lti_u(r0,r1,i0)              _lti_u(_jit,r0,r1,i0)
-static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lti_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ler(r0,r1,r2)                        CMPLE(r1,r2,r0)
 #  define lei(r0,r1,i0)                        _lei(_jit,r0,r1,i0)
-static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ler_u(r0,r1,r2)              CMPULE(r1,r2,r0)
 #  define lei_u(r0,r1,i0)              _lei_u(_jit,r0,r1,i0)
-static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lei_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define eqr(r0,r1,r2)                        CMPEQ(r1,r2,r0)
 #  define eqi(r0,r1,i0)                        _eqi(_jit,r0,r1,i0)
-static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _eqi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ger(r0,r1,r2)                        CMPLE(r2,r1,r0)
 #  define gei(r0,r1,i0)                        _gei(_jit,r0,r1,i0)
-static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ger_u(r0,r1,r2)              CMPULE(r2,r1,r0)
 #  define gei_u(r0,r1,i0)              _gei_u(_jit,r0,r1,i0)
-static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gei_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define gtr(r0,r1,r2)                        CMPLT(r2,r1,r0)
 #  define gti(r0,r1,i0)                        _gti(_jit,r0,r1,i0)
-static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gti(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define gtr_u(r0,r1,r2)              CMPULT(r2,r1,r0)
 #  define gti_u(r0,r1,i0)              _gti_u(_jit,r0,r1,i0)
-static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gti_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ner(r0,r1,r2)                        _ner(_jit,r0,r1,r2)
-static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define nei(r0,r1,i0)                        _nei(_jit,r0,r1,i0)
-static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _nei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define bltr(i0,r0,r1)               _bltr(_jit,i0,r0,r1)
-static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blti(i0,r0,i1)               _blti(_jit,i0,r0,i1)
-static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blti(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bltr_u(i0,r0,r1)             _bltr_u(_jit,i0,r0,r1)
-static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blti_u(i0,r0,i1)             _blti_u(_jit,i0,r0,i1)
-static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blti_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bler(i0,r0,r1)               _bler(_jit,i0,r0,r1)
-static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blei(i0,r0,i1)               _blei(_jit,i0,r0,i1)
-static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bler_u(i0,r0,r1)             _bler_u(_jit,i0,r0,r1)
-static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blei_u(i0,r0,i1)             _blei_u(_jit,i0,r0,i1)
-static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blei_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define beqr(i0,r0,r1)               _beqr(_jit,i0,r0,r1)
-static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define beqi(i0,r0,i1)               _beqi(_jit,i0,r0,i1)
-static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _beqi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bger(i0,r0,r1)               _bger(_jit,i0,r0,r1)
-static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgei(i0,r0,i1)                       _bgei(_jit,i0,r0,i1)
-static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bger_u(i0,r0,r1)             _bger_u(_jit,i0,r0,r1)
-static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgei_u(i0,r0,i1)             _bgei_u(_jit,i0,r0,i1)
-static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgei_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bgtr(i0,r0,r1)               _bgtr(_jit,i0,r0,r1)
-static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgti(i0,r0,i1)               _bgti(_jit,i0,r0,i1)
-static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgti(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bgtr_u(i0,r0,r1)             _bgtr_u(_jit,i0,r0,r1)
-static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgti_u(i0,r0,i1)             _bgti_u(_jit,i0,r0,i1)
-static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgti_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bner(i0,r0,r1)               _bner(_jit,i0,r0,r1)
-static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bnei(i0,r0,i1)               _bnei(_jit,i0,r0,i1)
-static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bnei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define baddr(i0,r0,r1,cc)           _baddr(_jit,i0,r0,r1,cc)
-static jit_word_t _baddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
+static jit_word_t _baddr(jit_state_t*,jit_word_t,int32_t,jit_int32_t,
                         jit_bool_t);
 #  define baddi(i0,r0,i1,cc)           _baddi(_jit,i0,r0,i1,cc)
-static jit_word_t _baddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
+static jit_word_t _baddi(jit_state_t*,jit_word_t,int32_t,jit_word_t,
                         jit_bool_t);
 #  define baddr_u(i0,r0,r1,cc)         _baddr_u(_jit,i0,r0,r1,cc)
-static jit_word_t _baddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
+static jit_word_t _baddr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t,
                           jit_bool_t);
 #  define baddi_u(i0,r0,i1,cc)         _baddi_u(_jit,i0,r0,i1,cc)
-static jit_word_t _baddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
+static jit_word_t _baddi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t,
                           jit_bool_t);
 #  define boaddr(i0,r0,r1)             baddr(i0,r0,r1,1)
 #  define boaddi(i0,r0,i1)             baddi(i0,r0,i1,1)
@@ -496,16 +496,16 @@ static jit_word_t 
_baddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
 #  define bxaddr_u(i0,r0,r1)           baddr_u(i0,r0,r1,0)
 #  define bxaddi_u(i0,r0,i1)           baddi_u(i0,r0,i1,0)
 #  define bsubr(i0,r0,r1,cc)           _bsubr(_jit,i0,r0,r1,cc)
-static jit_word_t _bsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
+static jit_word_t _bsubr(jit_state_t*,jit_word_t,int32_t,jit_int32_t,
                         jit_bool_t);
 #  define bsubi(i0,r0,i1,cc)           _bsubi(_jit,i0,r0,i1,cc)
-static jit_word_t _bsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
+static jit_word_t _bsubi(jit_state_t*,jit_word_t,int32_t,jit_word_t,
                         jit_bool_t);
 #  define bsubr_u(i0,r0,r1,cc)         _bsubr_u(_jit,i0,r0,r1,cc)
-static jit_word_t _bsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
+static jit_word_t _bsubr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t,
                           jit_bool_t);
 #  define bsubi_u(i0,r0,i1,cc)         _bsubi_u(_jit,i0,r0,i1,cc)
-static jit_word_t _bsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
+static jit_word_t _bsubi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t,
                           jit_bool_t);
 #  define bosubr(i0,r0,r1)             bsubr(i0,r0,r1,1)
 #  define bosubi(i0,r0,i1)             bsubi(i0,r0,i1,1)
@@ -516,119 +516,119 @@ static jit_word_t 
_bsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
 #  define bxsubr_u(i0,r0,r1)           bsubr_u(i0,r0,r1,0)
 #  define bxsubi_u(i0,r0,i1)           bsubi_u(i0,r0,i1,0)
 #  define bmxr(i0,r0,r1,cc)            _bmxr(_jit,i0,r0,r1,cc)
-static jit_word_t _bmxr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
+static jit_word_t _bmxr(jit_state_t*,jit_word_t,int32_t,jit_int32_t,
                        jit_bool_t);
 #  define bmxi(i0,r0,i1,cc)            _bmxi(_jit,i0,r0,i1,cc)
-static jit_word_t _bmxi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
+static jit_word_t _bmxi(jit_state_t*,jit_word_t,int32_t,jit_word_t,
                        jit_bool_t);
 #  define bmsr(i0,r0,r1)               bmxr(i0,r0,r1,1)
 #  define bmsi(i0,r0,i1)               bmxi(i0,r0,i1,1)
 #  define bmcr(i0,r0,r1)               bmxr(i0,r0,r1,0)
 #  define bmci(i0,r0,i1)               bmxi(i0,r0,i1,0)
 #  define ldr_c(r0,r1)                 _ldr_c(_jit,r0,r1)
-static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_c(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_c(r0,i0)                 _ldi_c(_jit,r0,i0)
-static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_c(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_uc(r0,r1)                        LDBU(r0,r1,0)
 #  define ldi_uc(r0,i0)                        _ldi_uc(_jit,r0,i0)
-static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_uc(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_s(r0,r1)                 _ldr_s(_jit,r0,r1)
-static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_s(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_s(r0,i0)                 _ldi_s(_jit,r0,i0)
-static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_s(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_us(r0,r1)                        LDWU(r0,r1,0)
 #  define ldi_us(r0,i0)                        _ldi_us(_jit,r0,i0)
-static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_us(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_i(r0,r1)                 LDL(r0,r1,0)
 #  define ldi_i(r0,i0)                 _ldi_i(_jit,r0,i0)
-static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_i(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_ui(r0,r1)                        _ldr_ui(_jit,r0,r1)
-static void _ldr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_ui(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_ui(r0,i0)                        _ldi_ui(_jit,r0,i0)
-static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_ui(jit_state_t*,int32_t,jit_word_t);
 #  define ldr(r0,r1)                   ldr_l(r0,r1)
 #  define ldr_l(r0,r1)                 LDQ(r0,r1,0)
 #  define ldi_l(r0,i0)                 _ldi_l(_jit,r0,i0)
-static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_l(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_c(r0,r1,r2)             _ldxr_c(_jit,r0,r1,r2)
-static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_c(r0,r1,i0)             _ldxi_c(_jit,r0,r1,i0)
-static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_c(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_uc(r0,r1,r2)            _ldxr_uc(_jit,r0,r1,r2)
-static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_uc(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_uc(r0,r1,i0)            _ldxi_uc(_jit,r0,r1,i0)
-static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_uc(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_s(r0,r1,r2)             _ldxr_s(_jit,r0,r1,r2)
-static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_s(r0,r1,i0)             _ldxi_s(_jit,r0,r1,i0)
-static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_s(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_us(r0,r1,r2)            _ldxr_us(_jit,r0,r1,r2)
-static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_us(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_us(r0,r1,i0)            _ldxi_us(_jit,r0,r1,i0)
-static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_us(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_i(r0,r1,r2)             _ldxr_i(_jit,r0,r1,r2)
-static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_i(r0,r1,i0)             _ldxi_i(_jit,r0,r1,i0)
-static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_i(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_ui(r0,r1,r2)            _ldxr_ui(_jit,r0,r1,r2)
-static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_ui(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_ui(r0,r1,i0)            _ldxi_ui(_jit,r0,r1,i0)
-static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_ui(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr(r0,r1,r2)               ldxr_l(r0,r1,r2)
 #  define ldxr_l(r0,r1,r2)             _ldxr_l(_jit,r0,r1,r2)
-static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_l(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi(r0,r1,i0)               ldxi_l(r0,r1,i0)
 #  define ldxi_l(r0,r1,i0)             _ldxi_l(_jit,r0,r1,i0)
-static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_l(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_c(r0,r1)                 STB(r1,r0,0)
 #  define sti_c(i0,r0)                 _sti_c(_jit,i0,r0)
-static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_c(jit_state_t*,jit_word_t,int32_t);
 #  define str_s(r0,r1)                 STW(r1,r0,0)
 #  define sti_s(i0,r0)                 _sti_s(_jit,i0,r0)
-static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_s(jit_state_t*,jit_word_t,int32_t);
 #  define str_i(r0,r1)                 STL(r1,r0,0)
 #  define sti_i(i0,r0)                 _sti_i(_jit,i0,r0)
-static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_i(jit_state_t*,jit_word_t,int32_t);
 #  define str(r0,r1)                   str_l(r0,r1)
 #  define str_l(r0,r1)                 STQ(r1,r0,0)
 #  define sti_l(i0,r0)                 _sti_l(_jit,i0,r0)
-static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_l(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_c(r0,r1,r2)             _stxr_c(_jit,r0,r1,r2)
-static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_c(i0,r0,r1)             _stxi_c(_jit,i0,r0,r1)
-static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_c(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_s(r0,r1,r2)             _stxr_s(_jit,r0,r1,r2)
-static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_s(i0,r0,r1)             _stxi_s(_jit,i0,r0,r1)
-static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_s(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_i(r0,r1,r2)             _stxr_i(_jit,r0,r1,r2)
-static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_i(i0,r0,r1)             _stxi_i(_jit,i0,r0,r1)
-static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_i(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_l(r0,r1,r2)             _stxr_l(_jit,r0,r1,r2)
-static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_l(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi(i0,r0,r1)               stxi_l(i0,r0,r1)
 #  define stxi_l(i0,r0,r1)             _stxi_l(_jit,i0,r0,r1)
-static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_l(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define extr_c(r0,r1)                        _extr_c(_jit,r0,r1)
-static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_c(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_uc(r0,r1)               _extr_uc(_jit,r0,r1)
-static void _extr_uc(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_uc(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_s(r0,r1)                        _extr_s(_jit,r0,r1)
-static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_s(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_us(r0,r1)               _extr_us(_jit,r0,r1)
-static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_us(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_i(r0,r1)                        _extr_i(_jit,r0,r1)
-static void _extr_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_i(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_ui(r0,r1)               _extr_ui(_jit,r0,r1)
-static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_ui(jit_state_t*,int32_t,jit_int32_t);
 #  if __BYTE_ORDER == __LITTLE_ENDIAN
 #    define htonr_us(r0,r1)            _htonr_us(_jit,r0,r1)
-static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_us(jit_state_t*,int32_t,jit_int32_t);
 #    define htonr_ui(r0,r1)            _htonr_ui(_jit,r0,r1)
-static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ui(jit_state_t*,int32_t,jit_int32_t);
 #    define htonr_ul(r0,r1)            _htonr_ul(_jit,r0,r1)
-static void _htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ul(jit_state_t*,int32_t,jit_int32_t);
 #  else
 #    define htonr_us(r0,r1)            extr_us(r0,r1)
 #    define htonr_ui(r0,r1)            extr_ui(r0,r1)
@@ -640,7 +640,7 @@ static void _jmpi(jit_state_t*, jit_word_t);
 #  define jmpi_p(i0)                   _jmpi_p(_jit,i0)
 static jit_word_t _jmpi_p(jit_state_t*, jit_word_t);
 #define callr(r0)                      _callr(_jit,r0)
-static void _callr(jit_state_t*, jit_int32_t);
+static void _callr(jit_state_t*, int32_t);
 #  define calli(i0)                    _calli(_jit,i0)
 static void _calli(jit_state_t*, jit_word_t);
 #  define calli_p(i0)                  _calli_p(_jit,i0)
@@ -650,9 +650,9 @@ static void _prolog(jit_state_t*,jit_node_t*);
 #  define epilog(node)                 _epilog(_jit,node)
 static void _epilog(jit_state_t*,jit_node_t*);
 #  define vastart(r0)                  _vastart(_jit, r0)
-static void _vastart(jit_state_t*, jit_int32_t);
+static void _vastart(jit_state_t*, int32_t);
 #  define vaarg(r0, r1)                        _vaarg(_jit, r0, r1)
-static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg(jit_state_t*, int32_t, jit_int32_t);
 #  define patch_at(jump,label)         _patch_at(_jit,jump,label)
 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 #endif
@@ -719,7 +719,7 @@ _Opi(jit_state_t *_jit, int o, int ra, unsigned int i, 
unsigned int f, int rc)
 }
 
 static void
-_nop(jit_state_t *_jit, jit_int32_t i0)
+_nop(jit_state_t *_jit, int32_t i0)
 {
     for (; i0 > 0; i0 -= 4)
        NOP();
@@ -727,17 +727,17 @@ _nop(jit_state_t *_jit, jit_int32_t i0)
 }
 
 static void
-_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        MOV(r1, r0);
 }
 
 static void
-_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
-    jit_int16_t                s0, s1, s2, s3;
+    int32_t            reg;
+    int16_t            s0, s1, s2, s3;
     s0 = i0;
     s1 = i0 >> 16;
     s2 = i0 >> 32;
@@ -784,11 +784,11 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static jit_word_t
-_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi_p(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
-    jit_int16_t                s0, s1, s2, s3;
+    int32_t            reg;
+    int16_t            s0, s1, s2, s3;
     w = _jit->pc.w;
     reg = jit_get_reg(jit_class_gpr);
     s0 = i0;
@@ -812,9 +812,9 @@ _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        ADDQi(r1, i0, r0);
     else if (_s16_p(i0))
@@ -828,9 +828,9 @@ _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addcr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
     if (r0 == r1) {
@@ -847,9 +847,9 @@ _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
     if (r0 == r1) {
@@ -866,9 +866,9 @@ _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addxr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(jit_carry != _NOREG);
     reg = jit_get_reg(jit_class_gpr);
     movr(rn(reg), rn(jit_carry));
@@ -878,9 +878,9 @@ _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(jit_carry != _NOREG);
     reg = jit_get_reg(jit_class_gpr);
     movr(rn(reg), rn(jit_carry));
@@ -890,9 +890,9 @@ _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        SUBQi(r1, i0, r0);
     else if (_s16_p(-i0))
@@ -906,9 +906,9 @@ _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subcr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
     if (r0 == r1) {
@@ -925,9 +925,9 @@ _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
     if (r0 == r1) {
@@ -944,9 +944,9 @@ _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subxr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(jit_carry != _NOREG);
     reg = jit_get_reg(jit_class_gpr);
     movr(rn(reg), rn(jit_carry));
@@ -956,9 +956,9 @@ _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(jit_carry != _NOREG);
     reg = jit_get_reg(jit_class_gpr);
     movr(rn(reg), rn(jit_carry));
@@ -968,16 +968,16 @@ _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rsbi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     subi(r0, r1, i0);
     negr(r0, r0);
 }
 
 static void
-_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_muli(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        MULQi(r1, i0, r0);
     else {
@@ -989,12 +989,12 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_qmulr(jit_state_t *_jit, jit_int32_t r0,
-       jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+_qmulr(jit_state_t *_jit, int32_t r0,
+       int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     /* The only invalid condition is r0 == r1 */
-    jit_int32_t                t2, t3, s2, s3;
+    int32_t            t2, t3, s2, s3;
     if (r2 == r0 || r2 == r1) {
        s2 = jit_get_reg(jit_class_gpr);
        t2 = rn(s2);
@@ -1027,10 +1027,10 @@ _qmulr(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_qmuli(jit_state_t *_jit, jit_int32_t r0,
-       jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+_qmuli(jit_state_t *_jit, int32_t r0,
+       int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     qmulr(r0, r1, r2, rn(reg));
@@ -1038,10 +1038,10 @@ _qmuli(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_qmulr_u(jit_state_t *_jit, jit_int32_t r0,
-        jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+_qmulr_u(jit_state_t *_jit, int32_t r0,
+        int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r2 || r0 == r3) {
        reg = jit_get_reg(jit_class_gpr);
        mulr(rn(reg), r2, r3);
@@ -1056,10 +1056,10 @@ _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
 }
 
 static void
-_qmuli_u(jit_state_t *_jit, jit_int32_t r0,
-        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+_qmuli_u(jit_state_t *_jit, int32_t r0,
+        int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0)) {
        if (r0 == r2) {
            reg = jit_get_reg(jit_class_gpr);
@@ -1088,7 +1088,7 @@ __idiv(jit_word_t u, jit_word_t v)
 }
 
 static void
-_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     movr(_A0_REGNO, r1);
     movr(_A1_REGNO, r2);
@@ -1097,7 +1097,7 @@ _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     movr(_A0_REGNO, r1);
     movi(_A1_REGNO, i0);
@@ -1112,7 +1112,7 @@ __udiv(jit_uword_t u, jit_uword_t v)
 }
 
 static void
-_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     movr(_A0_REGNO, r1);
     movr(_A1_REGNO, r2);
@@ -1121,7 +1121,7 @@ _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     movr(_A0_REGNO, r1);
     movi(_A1_REGNO, i0);
@@ -1136,7 +1136,7 @@ __irem(jit_word_t u, jit_word_t v)
 }
 
 static void
-_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     movr(_A0_REGNO, r1);
     movr(_A1_REGNO, r2);
@@ -1145,7 +1145,7 @@ _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     movr(_A0_REGNO, r1);
     movi(_A1_REGNO, i0);
@@ -1160,7 +1160,7 @@ __urem(jit_uword_t u, jit_uword_t v)
 }
 
 static void
-_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     movr(_A0_REGNO, r1);
     movr(_A1_REGNO, r2);
@@ -1169,7 +1169,7 @@ _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     movr(_A0_REGNO, r1);
     movi(_A1_REGNO, i0);
@@ -1186,7 +1186,7 @@ __idivrem(jit_word_t u, jit_word_t v, jit_word_t *rem)
 
 static void
 _qdivr(jit_state_t *_jit,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
     movr(_A0_REGNO, r2);
     movr(_A1_REGNO, r3);
@@ -1198,7 +1198,7 @@ _qdivr(jit_state_t *_jit,
 
 static void
 _qdivi(jit_state_t *_jit,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
     movr(_A0_REGNO, r2);
     movi(_A1_REGNO, i0);
@@ -1217,7 +1217,7 @@ __udivrem(jit_uword_t u, jit_uword_t v, jit_uword_t *rem)
 
 static void
 _qdivr_u(jit_state_t *_jit,
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
     movr(_A0_REGNO, r2);
     movr(_A1_REGNO, r3);
@@ -1229,7 +1229,7 @@ _qdivr_u(jit_state_t *_jit,
 
 static void
 _qdivi_u(jit_state_t *_jit,
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
     movr(_A0_REGNO, r2);
     movi(_A1_REGNO, i0);
@@ -1240,30 +1240,30 @@ _qdivi_u(jit_state_t *_jit,
 }
 
 static void
-_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 < 64);
     SLLi(r1, i0, r0);
 }
 
 static void
-_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 < 64);
     SRAi(r1, i0, r0);
 }
 
 static void
-_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 < 64);
     SRLi(r1, i0, r0);
 }
 
 static void
-_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_andi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        ANDi(r1, i0, r0);
     else {
@@ -1275,9 +1275,9 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        ORi(r1, i0, r0);
     else {
@@ -1289,9 +1289,9 @@ _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_xori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        XORi(r1, i0, r0);
     else {
@@ -1303,9 +1303,9 @@ _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lti(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        CMPLTi(r1, i0, r0);
     else {
@@ -1317,9 +1317,9 @@ _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lti_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        CMPULTi(r1, i0, r0);
     else {
@@ -1331,9 +1331,9 @@ _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        CMPLEi(r1, i0, r0);
     else {
@@ -1345,9 +1345,9 @@ _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lei_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         ni0;
     ni0 = -i0;
     if (_u8_p(i0))
@@ -1361,9 +1361,9 @@ _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_eqi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0))
        CMPEQi(r1, i0, r0);
     else {
@@ -1375,9 +1375,9 @@ _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ger(r0, r1, rn(reg));
@@ -1385,9 +1385,9 @@ _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gei_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ger_u(r0, r1, rn(reg));
@@ -1395,9 +1395,9 @@ _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gti(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     gtr(r0, r1, rn(reg));
@@ -1405,9 +1405,9 @@ _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gti_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     gtr_u(r0, r1, rn(reg));
@@ -1415,16 +1415,16 @@ _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPEQ(r1, r2, r0);
     CMPEQi(r0, 0, r0);
 }
 
 static void
-_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_nei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_u8_p(i0)) {
        CMPEQi(r1, i0, r0);
        CMPEQi(r0, 0, r0);
@@ -1438,10 +1438,10 @@ _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static jit_word_t
-_bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     ltr(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1451,10 +1451,10 @@ _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blti(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 == 0) {
        w = _jit->pc.w;
        BLT(r0, ((i0 - w) >> 2) - 1);
@@ -1470,10 +1470,10 @@ _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     ltr_u(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1483,10 +1483,10 @@ _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blti_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     /* FIXME cannot optimize zero because need to return a patcheable address 
*/
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     lti_u(rn(reg), r0, i1);
@@ -1497,10 +1497,10 @@ _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     ler(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1510,10 +1510,10 @@ _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 == 0) {
        w = _jit->pc.w;
        BLE(r0, ((i0 - w) >> 2) - 1);
@@ -1529,10 +1529,10 @@ _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     ler_u(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1542,10 +1542,10 @@ _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blei_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 == 0) {
        w = _jit->pc.w;
        BEQ(r0, ((i0 - w) >> 2) - 1);
@@ -1561,10 +1561,10 @@ _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_beqr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     eqr(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1574,10 +1574,10 @@ _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_beqi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 == 0) {
        w = _jit->pc.w;
        BEQ(r0, ((i0 - w) >> 2) - 1);
@@ -1593,10 +1593,10 @@ _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     ger(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1606,10 +1606,10 @@ _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 == 0) {
        w = _jit->pc.w;
        BGE(r0, ((i0 - w) >> 2) - 1);
@@ -1625,10 +1625,10 @@ _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     ger_u(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1638,10 +1638,10 @@ _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgei_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     /* always true if i1 == 0 */
     if (i0 == 0) {
        w = _jit->pc.w;
@@ -1658,10 +1658,10 @@ _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     gtr(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1671,10 +1671,10 @@ _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgti(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 == 0) {
        w = _jit->pc.w;
        BGT(r0, ((i0 - w) >> 2) - 1);
@@ -1690,10 +1690,10 @@ _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     gtr_u(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1703,10 +1703,10 @@ _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgti_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     gti_u(rn(reg), r0, i1);
     w = _jit->pc.w;
@@ -1716,10 +1716,10 @@ _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bner(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     eqr(rn(reg), r0, r1);
     w = _jit->pc.w;
@@ -1729,10 +1729,10 @@ _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bnei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 == 0) {
        w = _jit->pc.w;
        BNE(r0, ((i0 - w) >> 2) - 1);
@@ -1748,14 +1748,14 @@ _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_baddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_baddr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
        jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
-    jit_int32_t                t3;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
+    int32_t            t3;
     /* t0 = r0 + r1;   overflow = r1 < 0 ? r0 < t0 : t0 < r0 */
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr);
@@ -1780,11 +1780,11 @@ _baddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1,
 }
 
 static jit_word_t
-_baddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_baddi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
        jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = baddr(i0, r0, rn(reg), carry);
@@ -1793,12 +1793,12 @@ _baddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1,
 }
 
 static jit_word_t
-_baddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_baddr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
         jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     addr(rn(t0), r0, r1);
@@ -1815,12 +1815,12 @@ _baddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1,
 }
 
 static jit_word_t
-_baddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_baddi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
         jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     addi(rn(t0), r0, i1);
@@ -1837,14 +1837,14 @@ _baddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1,
 }
 
 static jit_word_t
-_bsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_bsubr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
        jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
-    jit_int32_t                t3;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
+    int32_t            t3;
     /* t0 = r0 - r1;   overflow = 0 < r1 ? r0 < t0 : t0 < r0 */
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr);
@@ -1869,11 +1869,11 @@ _bsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1,
 }
 
 static jit_word_t
-_bsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_bsubi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
        jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bsubr(i0, r0, rn(reg), carry);
@@ -1882,12 +1882,12 @@ _bsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1,
 }
 
 static jit_word_t
-_bsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_bsubr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
         jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     subr(rn(t0), r0, r1);
@@ -1904,12 +1904,12 @@ _bsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1,
 }
 
 static jit_word_t
-_bsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_bsubi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
         jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     subi(rn(t0), r0, i1);
@@ -1926,11 +1926,11 @@ _bsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1,
 }
 
 static jit_word_t
-_bmxr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_bmxr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
       jit_bool_t set)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     andr(rn(t0), r0, r1);
     w = _jit->pc.w;
@@ -1943,11 +1943,11 @@ _bmxr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1,
 }
 
 static jit_word_t
-_bmxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_bmxi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
       jit_bool_t set)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     andi(rn(t0), r0, i1);
     w = _jit->pc.w;
@@ -1960,16 +1960,16 @@ _bmxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1,
 }
 
 static void
-_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_uc(r0, r1);
     extr_c(r0, r0);
 }
 
 static void
-_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0)) {
        LDBU(r0, _R31_REGNO, _u16(i0));
        extr_c(r0, r0);
@@ -1983,9 +1983,9 @@ _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        LDBU(r0, _R31_REGNO, _u16(i0));
     else  {
@@ -1997,16 +1997,16 @@ _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t 
i0)
 }
 
 static void
-_ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_us(r0, r1);
     extr_s(r0, r0);
 }
 
 static void
-_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0)) {
        LDWU(r0, _R31_REGNO, _u16(i0));
        extr_s(r0, r0);
@@ -2020,9 +2020,9 @@ _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        LDWU(r0, _R31_REGNO, _u16(i0));
     else {
@@ -2034,9 +2034,9 @@ _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        LDL(r0, _R31_REGNO, _u16(i0));
     else {
@@ -2048,16 +2048,16 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_i(r0, r1);
     extr_ui(r0, r0);
 }
 
 static void
-_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0)) {
        LDL(r0, _R31_REGNO, _u16(i0));
        extr_ui(r0, r0);
@@ -2071,9 +2071,9 @@ _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        LDQ(r0, _R31_REGNO, _u16(i0));
     else {
@@ -2085,9 +2085,9 @@ _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_c(r0, rn(reg));
@@ -2095,9 +2095,9 @@ _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0)) {
        LDBU(r0, r1, _u16(i0));
        extr_c(r0, r0);
@@ -2111,9 +2111,9 @@ _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_uc(r0, rn(reg));
@@ -2121,9 +2121,9 @@ _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        LDBU(r0, r1, _u16(i0));
     else {
@@ -2135,9 +2135,9 @@ _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_s(r0, rn(reg));
@@ -2145,9 +2145,9 @@ _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0)) {
        LDWU(r0, r1, _u16(i0));
        extr_s(r0, r0);
@@ -2161,9 +2161,9 @@ _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_us(r0, rn(reg));
@@ -2171,9 +2171,9 @@ _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        LDWU(r0, r1, _u16(i0));
     else {
@@ -2185,9 +2185,9 @@ _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_i(r0, rn(reg));
@@ -2195,9 +2195,9 @@ _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        LDL(r0, r1, _u16(i0));
     else {
@@ -2209,9 +2209,9 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_ui(r0, rn(reg));
@@ -2219,9 +2219,9 @@ _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0)) {
        LDL(r0, r1, _u16(i0));
        extr_ui(r0, r0);
@@ -2235,9 +2235,9 @@ _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_l(r0, rn(reg));
@@ -2245,9 +2245,9 @@ _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        LDQ(r0, r1, _u16(i0));
     else {
@@ -2259,9 +2259,9 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        STB(r0, _R31_REGNO, _u16(i0));
     else {
@@ -2273,9 +2273,9 @@ _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        STW(r0, _R31_REGNO, _u16(i0));
     else {
@@ -2287,9 +2287,9 @@ _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        STL(r0, _R31_REGNO, _u16(i0));
     else {
@@ -2301,9 +2301,9 @@ _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        STQ(r0, _R31_REGNO, _u16(i0));
     else {
@@ -2315,9 +2315,9 @@ _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_c(rn(reg), r2);
@@ -2325,9 +2325,9 @@ _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        STB(r1, r0, _u16(i0));
     else {
@@ -2339,9 +2339,9 @@ _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_s(rn(reg), r2);
@@ -2349,9 +2349,9 @@ _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        STW(r1, r0, _u16(i0));
     else {
@@ -2363,9 +2363,9 @@ _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_i(rn(reg), r2);
@@ -2373,9 +2373,9 @@ _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        STL(r1, r0, _u16(i0));
     else {
@@ -2387,9 +2387,9 @@ _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_l(rn(reg), r2);
@@ -2397,9 +2397,9 @@ _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_s16_p(i0))
        STQ(r1, r0, _u16(i0));
     else {
@@ -2411,51 +2411,51 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     lshi(r0, r1, 56);
     rshi(r0, r0, 56);
 }
 
 static void
-_extr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     lshi(r0, r1, 56);
     rshi_u(r0, r0, 56);
 }
 
 static void
-_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     lshi(r0, r1, 48);
     rshi(r0, r0, 48);
 }
 
 static void
-_extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     lshi(r0, r1, 48);
     rshi_u(r0, r0, 48);
 }
 
 static void
-_extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     lshi(r0, r1, 32);
     rshi(r0, r0, 32);
 }
 
 static void
-_extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     lshi(r0, r1, 32);
     rshi_u(r0, r0, 32);
 }
 
 static void
-_htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr);
     EXTBLi(r1, 0, rn(t0));
     EXTBLi(r1, 1, r0);
@@ -2465,12 +2465,12 @@ _htonr_us(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
-    jit_int32_t                t3;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
+    int32_t            t3;
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr);
     t2 = jit_get_reg(jit_class_gpr);
@@ -2491,11 +2491,11 @@ _htonr_ui(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ul(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
     assert(_jitc->function != NULL);
     t0 = jit_get_reg(jit_class_fpr);
     t1 = jit_get_reg(jit_class_gpr);
@@ -2531,7 +2531,7 @@ static jit_word_t
 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     w = movi_p(rn(reg), i0);
     jmpr(rn(reg));
@@ -2540,7 +2540,7 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0)
 }
 
 static void
-_callr(jit_state_t *_jit, jit_int32_t r0)
+_callr(jit_state_t *_jit, int32_t r0)
 {
     if (r0 != _PV_REGNO)
        MOV(r0, _PV_REGNO);
@@ -2578,9 +2578,9 @@ _calli_p(jit_state_t *_jit, jit_word_t i0)
 static void
 _prolog(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
-       jit_int32_t     frame = -_jitc->function->frame;
+       int32_t frame = -_jitc->function->frame;
        assert(_jitc->function->self.aoff >= frame);
        if (_jitc->function->assume_frame)
            return;
@@ -2675,9 +2675,9 @@ _epilog(jit_state_t *_jit, jit_node_t *node)
 }
 
 static void
-_vastart(jit_state_t *_jit, jit_int32_t r0)
+_vastart(jit_state_t *_jit, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     /* Return jit_va_list_t in the register argument */
     addi(r0, _FP_REGNO, _jitc->function->vaoff);
@@ -2699,9 +2699,9 @@ _vastart(jit_state_t *_jit, jit_int32_t r0)
 }
 
 static void
-_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
 
     assert(_jitc->function->self.call & jit_call_varargs);
 
@@ -2730,11 +2730,11 @@ static void
 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
 {
     union {
-       jit_int32_t     *i;
+       int32_t *i;
        jit_word_t       w;
     } u;
     jit_word_t          d;
-    jit_int16_t                s0, s1, s2, s3;
+    int16_t            s0, s1, s2, s3;
     u.w = instr;
     switch (_u6(u.i[0] >> 26)) {
        /*   BLT             BLE             BEQ             BGE */
diff --git a/jit/alpha-fpu.c b/jit/alpha-fpu.c
index 6cf4745..a6d9ac6 100644
--- a/jit/alpha-fpu.c
+++ b/jit/alpha-fpu.c
@@ -300,304 +300,304 @@ static void _Opr(jit_state_t*,int,int,int,unsigned 
int,int);
 #  define FNEGT(ra,rc)                 CPYSN(ra,ra,rc)
 #  define movr_f(r0,r1)                        movr_d(r0,r1)
 #  define movr_d(r0,r1)                        _movr_d(_jit,r0,r1)
-static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define movi_f(r0,i0)                        _movi_f(_jit,r0,i0)
-static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
+static void _movi_f(jit_state_t*,int32_t,jit_float32_t*);
 #  define movi_d(r0,i0)                        _movi_d(_jit,r0,i0)
-static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
+static void _movi_d(jit_state_t*,int32_t,jit_float64_t*);
 #  define absr_f(r0,r1)                        FABS(r1,r0)
 #  define absr_d(r0,r1)                        FABS(r1,r0)
 #  define negr_f(r0,r1)                        FNEGS(r1,r0)
 #  define negr_d(r0,r1)                        FNEGT(r1,r0)
 #  define sqrtr_f(r0,r1)               _sqrtr_f(_jit,r0,r1)
-static void _sqrtr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _sqrtr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define sqrtr_d(r0,r1)               _sqrtr_d(_jit,r0,r1)
-static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _sqrtr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_f_d(r0,r1)              movr_d(r0,r1)
 #  define extr_d_f(r0,r1)              movr_f(r0,r1)
 #  define truncr_f_i(r0,r1)            truncr_d_i(r0,r1)
 #  define truncr_f_l(r0,r1)            truncr_d_l(r0,r1)
 #  define truncr_d_i(r0,r1)            truncr_d_l(r0,r1)
 #  define truncr_d_l(r0,r1)            _truncr_d_l(_jit,r0,r1)
-static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_d_l(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_f(r0,r1)                        _extr_f(_jit,r0,r1)
-static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_d(r0,r1)                        _extr_d(_jit,r0,r1)
-static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define addr_f(r0,r1,r2)             _addr_f(_jit,r0,r1,r2)
-static void _addr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define addi_f(r0,r1,i0)             _addi_f(_jit,r0,r1,i0)
-static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _addi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define addr_d(r0,r1,r2)             _addr_d(_jit,r0,r1,r2)
-static void _addr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define addi_d(r0,r1,i0)             _addi_d(_jit,r0,r1,i0)
-static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _addi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define subr_f(r0,r1,r2)             _subr_f(_jit,r0,r1,r2)
-static void _subr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subi_f(r0,r1,i0)             _subi_f(_jit,r0,r1,i0)
-static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _subi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define subr_d(r0,r1,r2)             _subr_d(_jit,r0,r1,r2)
-static void _subr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subi_d(r0,r1,i0)             _subi_d(_jit,r0,r1,i0)
-static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _subi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define rsbr_f(r0, r1, r2)           subr_f(r0, r2, r1)
 #  define rsbi_f(r0, r1, i0)           _rsbi_f(_jit, r0, r1, i0)
-static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _rsbi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define rsbr_d(r0, r1, r2)           subr_d(r0, r2, r1)
 #  define rsbi_d(r0, r1, i0)           _rsbi_d(_jit, r0, r1, i0)
-static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _rsbi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define mulr_f(r0,r1,r2)             _mulr_f(_jit,r0,r1,r2)
-static void _mulr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _mulr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define muli_f(r0,r1,i0)             _muli_f(_jit,r0,r1,i0)
-static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _muli_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define mulr_d(r0,r1,r2)             _mulr_d(_jit,r0,r1,r2)
-static void _mulr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _mulr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define muli_d(r0,r1,i0)             _muli_d(_jit,r0,r1,i0)
-static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _muli_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define divr_f(r0,r1,r2)             _divr_f(_jit,r0,r1,r2)
-static void _divr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define divi_f(r0,r1,i0)             _divi_f(_jit,r0,r1,i0)
-static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _divi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define divr_d(r0,r1,r2)             _divr_d(_jit,r0,r1,r2)
-static void _divr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define divi_d(r0,r1,i0)             _divi_d(_jit,r0,r1,i0)
-static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _divi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ltr_f(r0,r1,r2)              ltr_d(r0,r1,r2)
 #  define ltr_d(r0,r1,r2)              _ltr_d(_jit,r0,r1,r2)
-static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lti_f(r0,r1,i0)              _lti_f(_jit,r0,r1,i0)
-static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _lti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define lti_d(r0,r1,i0)              _lti_d(_jit,r0,r1,i0)
-static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _lti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ler_f(r0,r1,r2)              ler_d(r0,r1,r2)
 #  define ler_d(r0,r1,r2)              _ler_d(_jit,r0,r1,r2)
-static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lei_f(r0,r1,i0)              _lei_f(_jit,r0,r1,i0)
-static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _lei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define lei_d(r0,r1,i0)              _lei_d(_jit,r0,r1,i0)
-static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _lei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define eqr_f(r0,r1,r2)              eqr_d(r0,r1,r2)
 #  define eqr_d(r0,r1,r2)              _eqr_d(_jit,r0,r1,r2)
-static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _eqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define eqi_f(r0,r1,i0)              _eqi_f(_jit,r0,r1,i0)
-static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _eqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define eqi_d(r0,r1,i0)              _eqi_d(_jit,r0,r1,i0)
-static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _eqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ger_f(r0,r1,r2)              ger_d(r0,r1,r2)
 #  define ger_d(r0,r1,r2)              _ger_d(_jit,r0,r1,r2)
-static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gei_f(r0,r1,i0)              _gei_f(_jit,r0,r1,i0)
-static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _gei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define gei_d(r0,r1,i0)              _gei_d(_jit,r0,r1,i0)
-static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _gei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define gtr_f(r0,r1,r2)              gtr_d(r0,r1,r2)
 #  define gtr_d(r0,r1,r2)              _gtr_d(_jit,r0,r1,r2)
-static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gti_f(r0,r1,i0)              _gti_f(_jit,r0,r1,i0)
-static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _gti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define gti_d(r0,r1,i0)              _gti_d(_jit,r0,r1,i0)
-static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _gti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ner_f(r0,r1,r2)              ner_d(r0,r1,r2)
 #  define ner_d(r0,r1,r2)              _ner_d(_jit,r0,r1,r2)
-static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define nei_f(r0,r1,i0)              _nei_f(_jit,r0,r1,i0)
-static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _nei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define nei_d(r0,r1,i0)              _nei_d(_jit,r0,r1,i0)
-static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _nei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unltr_f(r0,r1,r2)            unltr_d(r0,r1,r2)
 #  define unltr_d(r0,r1,r2)            _unltr_d(_jit,r0,r1,r2)
-static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unltr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unlti_f(r0,r1,i0)            _unlti_f(_jit,r0,r1,i0)
-static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unlti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unlti_d(r0,r1,i0)            _unlti_d(_jit,r0,r1,i0)
-static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unlti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unler_f(r0,r1,r2)            unler_d(r0,r1,r2)
 #  define unler_d(r0,r1,r2)            _unler_d(_jit,r0,r1,r2)
-static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unler_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unlei_f(r0,r1,i0)            _unlei_f(_jit,r0,r1,i0)
-static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unlei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unlei_d(r0,r1,i0)            _unlei_d(_jit,r0,r1,i0)
-static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unlei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define uneqr_f(r0,r1,r2)            uneqr_d(r0,r1,r2)
 #  define uneqr_d(r0,r1,r2)            _uneqr_d(_jit,r0,r1,r2)
-static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _uneqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define uneqi_f(r0,r1,i0)            _uneqi_f(_jit,r0,r1,i0)
-static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _uneqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define uneqi_d(r0,r1,i0)            _uneqi_d(_jit,r0,r1,i0)
-static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _uneqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unger_f(r0,r1,r2)            unger_d(r0,r1,r2)
 #  define unger_d(r0,r1,r2)            _unger_d(_jit,r0,r1,r2)
-static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unger_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ungei_f(r0,r1,i0)            _ungei_f(_jit,r0,r1,i0)
-static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ungei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ungei_d(r0,r1,i0)            _ungei_d(_jit,r0,r1,i0)
-static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ungei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ungtr_f(r0,r1,r2)            ungtr_d(r0,r1,r2)
 #  define ungtr_d(r0,r1,r2)            _ungtr_d(_jit,r0,r1,r2)
-static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ungtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ungti_f(r0,r1,i0)            _ungti_f(_jit,r0,r1,i0)
-static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ungti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ungti_d(r0,r1,i0)            _ungti_d(_jit,r0,r1,i0)
-static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ungti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ltgtr_f(r0,r1,r2)            ltgtr_d(r0,r1,r2)
 #  define ltgtr_d(r0,r1,r2)            _ltgtr_d(_jit,r0,r1,r2)
-static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltgtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ltgti_f(r0,r1,i0)            _ltgti_f(_jit,r0,r1,i0)
-static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ltgti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ltgti_d(r0,r1,i0)            _ltgti_d(_jit,r0,r1,i0)
-static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ltgti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ordr_f(r0,r1,r2)             ordr_d(r0,r1,r2)
 #  define ordr_d(r0,r1,r2)             _ordr_d(_jit,r0,r1,r2)
-static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ordi_f(r0,r1,i0)             _ordi_f(_jit,r0,r1,i0)
-static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ordi_d(r0,r1,i0)             _ordi_d(_jit,r0,r1,i0)
-static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unordr_f(r0,r1,r2)           unordr_d(r0,r1,r2)
 #  define unordr_d(r0,r1,r2)           _unordr_d(_jit,r0,r1,r2)
-static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unordi_f(r0,r1,i0)           _unordi_f(_jit,r0,r1,i0)
-static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unordi_d(r0,r1,i0)           _unordi_d(_jit,r0,r1,i0)
-static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define bltr_f(i0,r0,r1)             bltr_d(i0,r0,r1)
 #  define bltr_d(i0,r0,r1)             _bltr_d(_jit,i0,r0,r1)
-static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blti_f(i0,r0,i1)             _blti_f(_jit,i0,r0,i1)
-static jit_word_t _blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _blti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define blti_d(i0,r0,i1)             _blti_d(_jit,i0,r0,i1)
-static jit_word_t _blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _blti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bler_f(i0,r0,r1)             bler_d(i0,r0,r1)
 #  define bler_d(i0,r0,r1)             _bler_d(_jit,i0,r0,r1)
-static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blei_f(i0,r0,i1)             _blei_f(_jit,i0,r0,i1)
-static jit_word_t _blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _blei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define blei_d(i0,r0,i1)             _blei_d(_jit,i0,r0,i1)
-static jit_word_t _blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _blei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define beqr_f(i0,r0,r1)             beqr_d(i0,r0,r1)
 #  define beqr_d(i0,r0,r1)             _beqr_d(_jit,i0,r0,r1)
-static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define beqi_f(i0,r0,i1)             _beqi_f(_jit,i0,r0,i1)
-static jit_word_t _beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _beqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define beqi_d(i0,r0,i1)             _beqi_d(_jit,i0,r0,i1)
-static jit_word_t _beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _beqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bger_f(i0,r0,r1)             bger_d(i0,r0,r1)
 #  define bger_d(i0,r0,r1)             _bger_d(_jit,i0,r0,r1)
-static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgei_f(i0,r0,i1)             _bgei_f(_jit,i0,r0,i1)
-static jit_word_t _bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bgei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bgei_d(i0,r0,i1)             _bgei_d(_jit,i0,r0,i1)
-static jit_word_t _bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bgei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bgtr_f(i0,r0,r1)             bgtr_d(i0,r0,r1)
 #  define bgtr_d(i0,r0,r1)             _bgtr_d(_jit,i0,r0,r1)
-static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgti_f(i0,r0,i1)             _bgti_f(_jit,i0,r0,i1)
-static jit_word_t _bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bgti_d(i0,r0,i1)             _bgti_d(_jit,i0,r0,i1)
-static jit_word_t _bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bner_f(i0,r0,r1)             bner_d(i0,r0,r1)
 #  define bner_d(i0,r0,r1)             _bner_d(_jit,i0,r0,r1)
-static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bnei_f(i0,r0,i1)             _bnei_f(_jit,i0,r0,i1)
-static jit_word_t _bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bnei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bnei_d(i0,r0,i1)             _bnei_d(_jit,i0,r0,i1)
-static jit_word_t _bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bnei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bunltr_f(i0,r0,r1)           bunltr_d(i0,r0,r1)
 #  define bunltr_d(i0,r0,r1)           _bunltr_d(_jit,i0,r0,r1)
-static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunlti_f(i0,r0,i1)           _bunlti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunlti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bunlti_d(i0,r0,i1)           _bunlti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunlti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bunler_f(i0,r0,r1)           bunler_d(i0,r0,r1)
 #  define bunler_d(i0,r0,r1)           _bunler_d(_jit,i0,r0,r1)
-static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunler_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunlei_f(i0,r0,i1)           _bunlei_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunlei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bunlei_d(i0,r0,i1)           _bunlei_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunlei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define buneqr_f(i0,r0,r1)           buneqr_d(i0,r0,r1)
 #  define buneqr_d(i0,r0,r1)           _buneqr_d(_jit,i0,r0,r1)
-static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define buneqi_f(i0,r0,i1)           _buneqi_f(_jit,i0,r0,i1)
-static jit_word_t 
_buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define buneqi_d(i0,r0,i1)           _buneqi_d(_jit,i0,r0,i1)
-static jit_word_t 
_buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bunger_f(i0,r0,r1)           bunger_d(i0,r0,r1)
 #  define bunger_d(i0,r0,r1)           _bunger_d(_jit,i0,r0,r1)
-static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bungei_f(i0,r0,i1)           _bungei_f(_jit,i0,r0,i1)
-static jit_word_t 
_bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bungei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bungei_d(i0,r0,i1)           _bungei_d(_jit,i0,r0,i1)
-static jit_word_t 
_bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bungei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bungtr_f(i0,r0,r1)           bungtr_d(i0,r0,r1)
 #  define bungtr_d(i0,r0,r1)           _bungtr_d(_jit,i0,r0,r1)
-static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bungti_f(i0,r0,i1)           _bungti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bungti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bungti_d(i0,r0,i1)           _bungti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bungti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bltgtr_f(i0,r0,r1)           bltgtr_d(i0,r0,r1)
 #  define bltgtr_d(i0,r0,r1)           _bltgtr_d(_jit,i0,r0,r1)
-static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bltgti_f(i0,r0,i1)           _bltgti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bltgti_d(i0,r0,i1)           _bltgti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bordr_f(i0,r0,r1)            bordr_d(i0,r0,r1)
 #  define bordr_d(i0,r0,r1)            _bordr_d(_jit,i0,r0,r1)
-static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bordr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bordi_f(i0,r0,i1)            _bordi_f(_jit,i0,r0,i1)
-static jit_word_t _bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bordi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bordi_d(i0,r0,i1)            _bordi_d(_jit,i0,r0,i1)
-static jit_word_t _bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bordi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bunordr_f(i0,r0,r1)          bunordr_d(i0,r0,r1)
 #  define bunordr_d(i0,r0,r1)          _bunordr_d(_jit,i0,r0,r1)
-static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunordi_f(i0,r0,i1)          _bunordi_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunordi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bunordi_d(i0,r0,i1)          _bunordi_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunordi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define ldr_f(r0,r1)                 LDS(r0,r1,0)
 #  define ldi_f(r0,i0)                 _ldi_f(_jit,r0,i0)
-static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_f(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_d(r0,r1)                 LDT(r0,r1,0)
 #  define ldi_d(r0,i0)                 _ldi_d(_jit,r0,i0)
-static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_d(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_f(r0,r1,r2)             _ldxr_f(_jit,r0,r1,r2)
-static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_f(r0,r1,i0)             _ldxi_f(_jit,r0,r1,i0)
-static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_f(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_d(r0,r1,r2)             _ldxr_d(_jit,r0,r1,r2)
-static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_d(r0,r1,i0)             _ldxi_d(_jit,r0,r1,i0)
-static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_d(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_f(r0,r1)                 STS(r1,r0,0)
 #  define sti_f(i0,r0)                 _sti_f(_jit,i0,r0)
-static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_f(jit_state_t*,jit_word_t,int32_t);
 #  define str_d(r0,r1)                 STT(r1,r0,0)
 #  define sti_d(i0,r0)                 _sti_d(_jit,i0,r0)
-static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_d(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_f(r0,r1,r2)             _stxr_f(_jit,r0,r1,r2)
-static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_f(i0,r0,r1)             _stxi_f(_jit,i0,r0,r1)
-static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_d(r0,r1,r2)             _stxr_d(_jit,r0,r1,r2)
-static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_d(i0,r0,r1)             _stxi_d(_jit,i0,r0,r1)
-static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vaarg_d(r0, r1)              _vaarg_d(_jit, r0, r1)
-static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg_d(jit_state_t*, int32_t, jit_int32_t);
 #endif
 
 #if CODE
 #  define fpr_opi(name, type, size)                                    \
 static void                                                            \
 _##name##i_##type(jit_state_t *_jit,                                   \
-                 jit_int32_t r0, jit_int32_t r1,                       \
+                 int32_t r0, jit_int32_t r1,                   \
                  jit_float##size##_t *i0)                              \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     movi_##type(rn(reg), i0);                                          \
     name##r_##type(r0, r1, rn(reg));                                   \
     jit_unget_reg(reg);                                                        
\
@@ -605,11 +605,11 @@ _##name##i_##type(jit_state_t *_jit,                      
                \
 #  define fpr_bopi(name, type, size)                                   \
 static jit_word_t                                                      \
 _b##name##i_##type(jit_state_t *_jit,                                  \
-                 jit_word_t i0, jit_int32_t r0,                        \
+                 jit_word_t i0, int32_t r0,                    \
                  jit_float##size##_t *i1)                              \
 {                                                                      \
     jit_word_t         word;                                           \
-    jit_int32_t                reg = 
jit_get_reg(jit_class_fpr|jit_class_nospill);\
+    int32_t            reg = jit_get_reg(jit_class_fpr|jit_class_nospill);\
     movi_##type(rn(reg), i1);                                          \
     word = b##name##r_##type(i0, r0, rn(reg));                         \
     jit_unget_reg(reg);                                                        
\
@@ -621,20 +621,20 @@ _b##name##i_##type(jit_state_t *_jit,                     
                \
 #  define dbopi(name)                  fpr_bopi(name, d, 64)
 
 static void
-_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        FMOV(r1, r0);
 }
 
 static void
-_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
+_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t *i0)
 {
     union {
-       jit_int32_t      i;
+       int32_t  i;
        jit_float32_t    f;
     } data;
-    jit_int32_t                 reg;
+    int32_t             reg;
 
     if (_jitc->no_data) {
        data.f = *i0;
@@ -649,13 +649,13 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t 
*i0)
 }
 
 static void
-_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
+_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t *i0)
 {
     union {
        jit_word_t       w;
        jit_float64_t    d;
     } data;
-    jit_int32_t                 reg;
+    int32_t             reg;
 
     if (_jitc->no_data) {
        data.d = *i0;
@@ -670,9 +670,9 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t 
*i0)
 }
 
 static void
-_truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_d_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     CVTTQ_SVC(r1, rn(reg));
     TRAPB();
@@ -682,21 +682,21 @@ _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_sqrtr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     SQRTS_SU(r1, r0);
     TRAPB();
 }
 
 static void
-_sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_sqrtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     SQRTT_SU(r1, r0);
     TRAPB();
 }
 
 static void
-_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     stxi_l(-8, _FP_REGNO, r1);
     ldxi_d(r0, _FP_REGNO, -8);
@@ -704,7 +704,7 @@ _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     stxi_l(-8, _FP_REGNO, r1);
     ldxi_d(r0, _FP_REGNO, -8);
@@ -712,7 +712,7 @@ _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_addr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     ADDS_SU(r1, r2, r0);
     TRAPB();
@@ -720,7 +720,7 @@ _addr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(add)
 
 static void
-_addr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     ADDT_SU(r1, r2, r0);
     TRAPB();
@@ -728,7 +728,7 @@ _addr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(add)
 
 static void
-_subr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     SUBS_SU(r1, r2, r0);
     TRAPB();
@@ -737,7 +737,7 @@ fopi(sub)
 fopi(rsb)
 
 static void
-_subr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     SUBT_SU(r1, r2, r0);
     TRAPB();
@@ -746,7 +746,7 @@ dopi(sub)
 dopi(rsb)
 
 static void
-_mulr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_mulr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     MULS_SU(r1, r2, r0);
     TRAPB();
@@ -754,7 +754,7 @@ _mulr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(mul)
 
 static void
-_mulr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_mulr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     MULT_SU(r1, r2, r0);
     TRAPB();
@@ -762,7 +762,7 @@ _mulr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(mul)
 
 static void
-_divr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     DIVS_SU(r1, r2, r0);
     TRAPB();
@@ -770,7 +770,7 @@ _divr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(div)
 
 static void
-_divr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     DIVT_SU(r1, r2, r0);
     TRAPB();
@@ -778,9 +778,9 @@ _divr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(div)
 
 static void
-_ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 0);
@@ -801,9 +801,9 @@ fopi(lt);
 dopi(lt);
 
 static void
-_ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 0);
@@ -824,9 +824,9 @@ fopi(le);
 dopi(le);
 
 static void
-_eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_eqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 0);
@@ -847,9 +847,9 @@ fopi(eq);
 dopi(eq);
 
 static void
-_ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 0);
@@ -870,9 +870,9 @@ fopi(ge);
 dopi(ge);
 
 static void
-_gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 0);
@@ -893,9 +893,9 @@ fopi(gt);
 dopi(gt);
 
 static void
-_ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 1);
@@ -916,9 +916,9 @@ fopi(ne);
 dopi(ne);
 
 static void
-_unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unltr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 1);
@@ -939,9 +939,9 @@ fopi(unlt);
 dopi(unlt);
 
 static void
-_unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unler_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 1);
@@ -962,9 +962,9 @@ fopi(unle);
 dopi(unle);
 
 static void
-_uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_uneqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 1);
@@ -985,9 +985,9 @@ fopi(uneq);
 dopi(uneq);
 
 static void
-_unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unger_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 1);
@@ -1008,9 +1008,9 @@ fopi(unge);
 dopi(unge);
 
 static void
-_ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ungtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 1);
@@ -1031,9 +1031,9 @@ fopi(ungt);
 dopi(ungt);
 
 static void
-_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltgtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 0);
@@ -1054,10 +1054,10 @@ fopi(ltgt);
 dopi(ltgt);
 
 static void
-_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 0);
     CMPTUN_SU(r1, r2, rn(reg));
@@ -1072,10 +1072,10 @@ fopi(ord);
 dopi(ord);
 
 static void
-_unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi(r0, 1);
     CMPTUN_SU(r1, r2, rn(reg));
@@ -1090,9 +1090,9 @@ fopi(unord);
 dopi(unord);
 
 static jit_word_t
-_bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord does not satisfy 
condition */
@@ -1111,9 +1111,9 @@ fbopi(lt);
 dbopi(lt);
 
 static jit_word_t
-_bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord does not satisfy 
condition */
@@ -1132,9 +1132,9 @@ fbopi(le);
 dbopi(le);
 
 static jit_word_t
-_beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_beqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord does not satisfy 
condition */
@@ -1153,9 +1153,9 @@ fbopi(eq);
 dbopi(eq);
 
 static jit_word_t
-_bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord does not satisfy 
condition */
@@ -1174,9 +1174,9 @@ fbopi(ge);
 dbopi(ge);
 
 static jit_word_t
-_bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord does not satisfy 
condition */
@@ -1195,9 +1195,9 @@ fbopi(gt);
 dbopi(gt);
 
 static jit_word_t
-_bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bner_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         u, v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord satisfy condition */
@@ -1219,9 +1219,9 @@ fbopi(ne);
 dbopi(ne);
 
 static jit_word_t
-_bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunltr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         u, v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord satisfy condition */
@@ -1243,9 +1243,9 @@ fbopi(unlt);
 dbopi(unlt);
 
 static jit_word_t
-_bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunler_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         u, v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord satisfy condition */
@@ -1267,9 +1267,9 @@ fbopi(unle);
 dbopi(unle);
 
 static jit_word_t
-_buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_buneqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         u, v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord satisfy condition */
@@ -1291,9 +1291,9 @@ fbopi(uneq);
 dbopi(uneq);
 
 static jit_word_t
-_bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunger_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         u, v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord satisfy condition */
@@ -1315,9 +1315,9 @@ fbopi(unge);
 dbopi(unge);
 
 static jit_word_t
-_bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bungtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         u, v, w;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord satisfy condition */
@@ -1339,10 +1339,10 @@ fbopi(ungt);
 dbopi(ungt);
 
 static jit_word_t
-_bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         u, v, w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord does not satisfy 
condition */
     TRAPB();
@@ -1363,10 +1363,10 @@ fbopi(ltgt);
 dbopi(ltgt);
 
 static jit_word_t
-_bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bordr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord does not satisfy 
condition */
     TRAPB();
@@ -1379,10 +1379,10 @@ fbopi(ord);
 dbopi(ord);
 
 static jit_word_t
-_bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunordr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     CMPTUN_SU(r0, r1, rn(reg));                /* unord satisfy condition */
     TRAPB();
@@ -1395,7 +1395,7 @@ fbopi(unord);
 dbopi(unord);
 
 static void
-_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         reg;
     if (_s16_p(i0))
@@ -1409,7 +1409,7 @@ _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         reg;
     if (_s16_p(i0))
@@ -1423,7 +1423,7 @@ _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         reg;
     reg = jit_get_reg(jit_class_gpr);
@@ -1433,7 +1433,7 @@ _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     jit_word_t         reg;
     if (_s16_p(i0))
@@ -1447,7 +1447,7 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         reg;
     reg = jit_get_reg(jit_class_gpr);
@@ -1457,7 +1457,7 @@ _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     jit_word_t         reg;
     if (_s16_p(i0))
@@ -1471,7 +1471,7 @@ _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
     jit_word_t         reg;
     if (_s16_p(i0))
@@ -1485,7 +1485,7 @@ _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
     jit_word_t         reg;
     if (_s16_p(i0))
@@ -1499,7 +1499,7 @@ _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         reg;
     reg = jit_get_reg(jit_class_gpr);
@@ -1509,7 +1509,7 @@ _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         reg;
     if (_s16_p(i0))
@@ -1523,7 +1523,7 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         reg;
     reg = jit_get_reg(jit_class_gpr);
@@ -1533,7 +1533,7 @@ _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         reg;
     if (_s16_p(i0))
@@ -1547,10 +1547,10 @@ _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         ge_code;
-    jit_int32_t                rg0, rg1, rg2;
+    int32_t            rg0, rg1, rg2;
 
     assert(_jitc->function->self.call & jit_call_varargs);
 
diff --git a/jit/alpha.c b/jit/alpha.c
index 4d49fb9..f994a67 100644
--- a/jit/alpha.c
+++ b/jit/alpha.c
@@ -25,9 +25,9 @@
 #  define I_DISP                       0
 #  define F_DISP                       0
 #else
-#  define C_DISP                       8 - sizeof(jit_int8_t)
-#  define S_DISP                       8 - sizeof(jit_int16_t)
-#  define I_DISP                       8 - sizeof(jit_int32_t)
+#  define C_DISP                       8 - sizeof(int8_t)
+#  define S_DISP                       8 - sizeof(int16_t)
+#  define I_DISP                       8 - sizeof(int32_t)
 #  define F_DISP                       8 - sizeof(jit_float32_t)
 #endif
 
@@ -155,7 +155,7 @@ _jit_init(jit_state_t *_jit)
 void
 _jit_prolog(jit_state_t *_jit)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
 
     if (_jitc->function)
        jit_epilog();
@@ -175,7 +175,7 @@ _jit_prolog(jit_state_t *_jit)
     _jitc->function->self.aoff = -8;
     _jitc->function->self.call = jit_call_default;
     jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
-             _jitc->reglen * sizeof(jit_int32_t));
+             _jitc->reglen * sizeof(int32_t));
 
     /* _no_link here does not mean the jit_link() call can be removed
      * by rewriting as:
@@ -194,8 +194,8 @@ _jit_prolog(jit_state_t *_jit)
     jit_regset_new(&_jitc->function->regset);
 }
 
-jit_int32_t
-_jit_allocai(jit_state_t *_jit, jit_int32_t length)
+int32_t
+_jit_allocai(jit_state_t *_jit, int32_t length)
 {
     assert(_jitc->function != NULL);
     switch (length) {
@@ -213,13 +213,13 @@ _jit_allocai(jit_state_t *_jit, jit_int32_t length)
 }
 
 void
-_jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_allocar(jit_state_t *_jit, int32_t u, jit_int32_t v)
 {
-    jit_int32_t                 reg;
+    int32_t             reg;
     assert(_jitc->function != NULL);
     jit_inc_synth_ww(allocar, u, v);
     if (!_jitc->function->allocar) {
-       _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
+       _jitc->function->aoffoff = jit_allocai(sizeof(int32_t));
        _jitc->function->allocar = 1;
     }
     reg = jit_get_reg(jit_class_gpr);
@@ -246,7 +246,7 @@ _jit_ret(jit_state_t *_jit)
 }
 
 void
-_jit_retr(jit_state_t *_jit, jit_int32_t u)
+_jit_retr(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr, u);
     if (JIT_RET != u)
@@ -266,7 +266,7 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_f(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_f, u);
     if (u != JIT_FRET)
@@ -287,7 +287,7 @@ _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_d(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_d, u);
     if (u != JIT_FRET)
@@ -347,9 +347,9 @@ _jit_ellipsis(jit_state_t *_jit)
 }
 
 void
-_jit_va_push(jit_state_t *_jit, jit_int32_t u)
+_jit_va_push(jit_state_t *_jit, int32_t u)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_inc_synth_w(va_push, u);
     reg = jit_get_reg(jit_class_gpr);
     jit_ldxi(reg, u, offsetof(jit_va_list_t, base));
@@ -364,7 +364,7 @@ jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function != NULL);
     if (jit_arg_reg_p(_jitc->function->self.argi))
        offset = _jitc->function->self.argi++;
@@ -382,7 +382,7 @@ jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function != NULL);
     if (jit_arg_f_reg_p(_jitc->function->self.argi))
        offset = _jitc->function->self.argi++;
@@ -400,7 +400,7 @@ jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function != NULL);
     if (jit_arg_f_reg_p(_jitc->function->self.argi))
        offset = _jitc->function->self.argi++;
@@ -415,7 +415,7 @@ _jit_arg_d(jit_state_t *_jit)
 }
 
 void
-_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_c(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_c, u, v);
@@ -427,7 +427,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_uc(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_uc, u, v);
@@ -439,7 +439,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_s(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_s, u, v);
@@ -451,7 +451,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_us(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_us, u, v);
@@ -463,7 +463,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_i(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_i, u, v);
@@ -475,7 +475,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_ui(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_ui, u, v);
@@ -487,7 +487,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_l(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_l, u, v);
@@ -499,7 +499,7 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargr, u, v);
@@ -513,7 +513,7 @@ _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargi, u, v);
     if (jit_arg_reg_p(v->u.w))
@@ -528,7 +528,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 }
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(getarg_f, u, v);
@@ -540,7 +540,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(putargr_f, u, v);
@@ -554,7 +554,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_fp(putargi_f, u, v);
     if (jit_arg_f_reg_p(v->u.w))
@@ -569,7 +569,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, 
jit_node_t *v)
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(getarg_d, u, v);
@@ -581,7 +581,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(putargr_d, u, v);
@@ -595,7 +595,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_dp(putargi_d, u, v);
     if (jit_arg_f_reg_p(v->u.w))
@@ -610,7 +610,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, 
jit_node_t *v)
 }
 
 void
-_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function != NULL);
     jit_inc_synth_w(pushargr, u);
@@ -627,9 +627,9 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 }
 
 void
-_jit_pushargi(jit_state_t *_jit, jit_int64_t u)
+_jit_pushargi(jit_state_t *_jit, int64_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(_jitc->function != NULL);
     jit_inc_synth_w(pushargi, u);
     jit_link_prepare();
@@ -648,7 +648,7 @@ _jit_pushargi(jit_state_t *_jit, jit_int64_t u)
 }
 
 void
-_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_f(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function != NULL);
     jit_inc_synth_w(pushargr_f, u);
@@ -667,7 +667,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(_jitc->function != NULL);
     jit_inc_synth_f(pushargi_f, u);
     jit_link_prepare();
@@ -686,7 +686,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_d(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function != NULL);
     jit_inc_synth_w(pushargr_d, u);
@@ -705,7 +705,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(_jitc->function != NULL);
     jit_inc_synth_d(pushargi_d, u);
     jit_link_prepare();
@@ -724,9 +724,9 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 }
 
 jit_bool_t
-_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, int32_t regno)
 {
-    jit_int32_t                spec;
+    int32_t            spec;
 
     spec = jit_class(_rvs[regno].spec);
     if (spec & jit_class_arg) {
@@ -746,7 +746,7 @@ _jit_regarg_p(jit_state_t *_jit, jit_node_t *node, 
jit_int32_t regno)
 }
 
 void
-_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
+_jit_finishr(jit_state_t *_jit, int32_t r0)
 {
     jit_node_t         *call;
     assert(_jitc->function != NULL);
@@ -777,7 +777,7 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
 }
 
 void
-_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_c(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_c, r0);
     jit_extr_c(r0, JIT_RET);
@@ -785,7 +785,7 @@ _jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_uc(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_uc, r0);
     jit_extr_uc(r0, JIT_RET);
@@ -793,7 +793,7 @@ _jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_s(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_s, r0);
     jit_extr_s(r0, JIT_RET);
@@ -801,7 +801,7 @@ _jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_us(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_us, r0);
     jit_extr_us(r0, JIT_RET);
@@ -809,7 +809,7 @@ _jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_i(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_i, r0);
     jit_extr_i(r0, JIT_RET);
@@ -817,7 +817,7 @@ _jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_ui(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_ui, r0);
     jit_extr_ui(r0, JIT_RET);
@@ -825,7 +825,7 @@ _jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_l(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_l, r0);
     if (r0 != JIT_RET)
@@ -834,7 +834,7 @@ _jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_f(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_f, r0);
     if (r0 != JIT_FRET)
@@ -843,7 +843,7 @@ _jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_d(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_d, r0);
     if (r0 != JIT_FRET)
@@ -858,16 +858,16 @@ _emit_code(jit_state_t *_jit)
     jit_node_t         *temp;
     jit_word_t          word;
     jit_word_t          value;
-    jit_int32_t                 offset;
+    int32_t             offset;
     struct {
        jit_node_t      *node;
-       jit_uint8_t     *data;
+       uint8_t *data;
        jit_word_t       word;
 #if DEVEL_DISASSEMBLER
        jit_word_t       prevw;
 #endif
-       jit_int32_t      const_offset;
-       jit_int32_t      patch_offset;
+       int32_t  const_offset;
+       int32_t  patch_offset;
     } undo;
 #if DEVEL_DISASSEMBLER
     jit_word_t          prevw;
@@ -1505,25 +1505,25 @@ jit_flush(void *fptr, void *tptr)
 }
 
 void
-_emit_ldxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi(rn(r0), rn(r1), i0);
 }
 
 void
-_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     stxi(i0, rn(r0), rn(r1));
 }
 
 void
-_emit_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi_d(rn(r0), rn(r1), i0);
 }
 
 void
-_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     stxi_d(i0, rn(r0), rn(r1));
 }
@@ -1531,7 +1531,7 @@ _emit_stxi_d(jit_state_t *_jit, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 static void
 _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
 {
-    jit_int32_t                 flag;
+    int32_t             flag;
 
     assert(node->flag & jit_flag_node);
     if (node->code == jit_code_movi)
diff --git a/jit/arm-cpu.c b/jit/arm-cpu.c
index 6f06965..7241703 100644
--- a/jit/arm-cpu.c
+++ b/jit/arm-cpu.c
@@ -836,113 +836,113 @@ static void _torl(jit_state_t*,int,int,int) 
maybe_unused;
        jit_unget_reg(_R0);                                             \
     } while (0)
 #  define nop(i0)                      _nop(_jit,i0)
-static void _nop(jit_state_t*,jit_int32_t);
+static void _nop(jit_state_t*,int32_t);
 #  define movr(r0,r1)                  _movr(_jit,r0,r1)
-static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr(jit_state_t*,int32_t,jit_int32_t);
 #  define movi(r0,i0)                  _movi(_jit,r0,i0)
-static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
+static void _movi(jit_state_t*,int32_t,jit_word_t);
 #  define movi_p(r0,i0)                        _movi_p(_jit,r0,i0)
-static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
+static jit_word_t _movi_p(jit_state_t*,int32_t,jit_word_t);
 #  define comr(r0,r1)                  _comr(_jit,r0,r1)
-static void _comr(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _comr(jit_state_t*,int32_t,jit_int32_t);
 #  define negr(r0,r1)                  _negr(_jit,r0,r1)
-static void _negr(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _negr(jit_state_t*,int32_t,jit_int32_t);
 #  define addr(r0,r1,r2)               _addr(_jit,r0,r1,r2)
-static void _addr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define addi(r0,r1,i0)               _addi(_jit,r0,r1,i0)
-static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addcr(r0,r1,r2)              _addcr(_jit,r0,r1,r2)
-static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addcr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define addci(r0,r1,i0)              _addci(_jit,r0,r1,i0)
-static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addxr(r0,r1,r2)              _addxr(_jit,r0,r1,r2)
-static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addxr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define addxi(r0,r1,i0)              _addxi(_jit,r0,r1,i0)
-static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subr(r0,r1,r2)               _subr(_jit,r0,r1,r2)
-static void _subr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subi(r0,r1,i0)               _subi(_jit,r0,r1,i0)
-static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subcr(r0,r1,r2)              _subcr(_jit,r0,r1,r2)
-static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subcr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subci(r0,r1,i0)              _subci(_jit,r0,r1,i0)
-static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subxr(r0,r1,r2)              _subxr(_jit,r0,r1,r2)
-static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subxr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subxi(r0,r1,i0)              _subxi(_jit,r0,r1,i0)
-static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rsbi(r0, r1, i0)             _rsbi(_jit, r0, r1, i0)
-static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rsbi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define mulr(r0,r1,r2)               _mulr(_jit,r0,r1,r2)
-static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _mulr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define muli(r0,r1,i0)               _muli(_jit,r0,r1,i0)
-static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _muli(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qmulr(r0,r1,r2,r3)           iqmulr(r0,r1,r2,r3,1)
 #  define qmulr_u(r0,r1,r2,r3)         iqmulr(r0,r1,r2,r3,0)
 #  define iqmulr(r0,r1,r2,r3,cc)       _iqmulr(_jit,r0,r1,r2,r3,cc)
-static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_bool_t);
+static void _iqmulr(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_bool_t);
 #  define qmuli(r0,r1,r2,i0)           iqmuli(r0,r1,r2,i0,1)
 #  define qmuli_u(r0,r1,r2,i0)         iqmuli(r0,r1,r2,i0,0)
 #  define iqmuli(r0,r1,r2,i0,cc)       _iqmuli(_jit,r0,r1,r2,i0,cc)
-static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_word_t,jit_bool_t);
+static void _iqmuli(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_word_t,jit_bool_t);
 #  define divrem(d,s,r0,r1,r2)         _divrem(_jit,d,s,r0,r1,r2)
-static void _divrem(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divrem(jit_state_t*,int,int,int32_t,jit_int32_t,jit_int32_t);
 #  define divr(r0,r1,r2)               _divr(_jit,r0,r1,r2)
-static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define divi(r0,r1,i0)               _divi(_jit,r0,r1,i0)
-static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define divr_u(r0,r1,r2)             _divr_u(_jit,r0,r1,r2)
-static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define divi_u(r0,r1,i0)             _divi_u(_jit,r0,r1,i0)
-static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qdivr(r0,r1,r2,r3)           iqdivr(r0,r1,r2,r3,1)
 #  define qdivr_u(r0,r1,r2,r3)         iqdivr(r0,r1,r2,r3,0)
 #  define iqdivr(r0,r1,r2,r3,cc)       _iqdivr(_jit,r0,r1,r2,r3,cc)
-static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_bool_t);
+static void _iqdivr(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_bool_t);
 #  define qdivi(r0,r1,r2,i0)           iqdivi(r0,r1,r2,i0,1)
 #  define qdivi_u(r0,r1,r2,i0)         iqdivi(r0,r1,r2,i0,0)
 #  define iqdivi(r0,r1,r2,i0,cc)       _iqdivi(_jit,r0,r1,r2,i0,cc)
-static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_word_t,jit_bool_t);
+static void _iqdivi(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_word_t,jit_bool_t);
 #  define remr(r0,r1,r2)               _remr(_jit,r0,r1,r2)
-static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi(r0,r1,i0)               _remi(_jit,r0,r1,i0)
-static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define remr_u(r0,r1,r2)             _remr_u(_jit,r0,r1,r2)
-static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi_u(r0,r1,i0)             _remi_u(_jit,r0,r1,i0)
-static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define andr(r0,r1,r2)               _andr(_jit,r0,r1,r2)
-static void _andr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _andr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define andi(r0,r1,i0)               _andi(_jit,r0,r1,i0)
-static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _andi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define orr(r0,r1,r2)                        _orr(_jit,r0,r1,r2)
-static void _orr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _orr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ori(r0,r1,i0)                        _ori(_jit,r0,r1,i0)
-static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define xorr(r0,r1,r2)               _xorr(_jit,r0,r1,r2)
-static void _xorr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _xorr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define xori(r0,r1,i0)               _xori(_jit,r0,r1,i0)
-static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _xori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define lshr(r0,r1,r2)               _lshr(_jit,r0,r1,r2)
-static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _lshr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lshi(r0,r1,i0)               _lshi(_jit,r0,r1,i0)
-static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rshr(r0,r1,r2)               _rshr(_jit,r0,r1,r2)
-static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _rshr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define rshi(r0,r1,i0)               _rshi(_jit,r0,r1,i0)
-static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rshr_u(r0,r1,r2)             _rshr_u(_jit,r0,r1,r2)
-static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _rshr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define rshi_u(r0,r1,i0)             _rshi_u(_jit,r0,r1,i0)
-static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ccr(ct,cf,r0,r1,r2)          _ccr(_jit,ct,cf,r0,r1,r2)
-static void _ccr(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ccr(jit_state_t*,int,int,int32_t,jit_int32_t,jit_int32_t);
 #  define cci(ct,cf,r0,r1,i0)          _cci(_jit,ct,cf,r0,r1,i0)
-static void _cci(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_word_t);
+static void _cci(jit_state_t*,int,int,int32_t,jit_int32_t,jit_word_t);
 #  define ltr(r0, r1, r2)              ccr(ARM_CC_LT,ARM_CC_GE,r0,r1,r2)
 #  define lti(r0, r1, i0)              cci(ARM_CC_LT,ARM_CC_GE,r0,r1,i0)
 #  define ltr_u(r0, r1, r2)            ccr(ARM_CC_LO,ARM_CC_HS,r0,r1,r2)
@@ -962,19 +962,19 @@ static void 
_cci(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_word_t);
 #  define gtr_u(r0, r1, r2)            ccr(ARM_CC_HI,ARM_CC_LS,r0,r1,r2)
 #  define gti_u(r0, r1, i0)            cci(ARM_CC_HI,ARM_CC_LS,r0,r1,i0)
 #  define ner(r0,r1,r2)                        _ner(_jit,r0,r1,r2)
-static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define nei(r0,r1,i0)                        _nei(_jit,r0,r1,i0)
-static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _nei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define jmpr(r0)                     _jmpr(_jit,r0)
-static void _jmpr(jit_state_t*,jit_int32_t);
+static void _jmpr(jit_state_t*,int32_t);
 #  define jmpi(i0)                     _jmpi(_jit,i0)
 static void _jmpi(jit_state_t*,jit_word_t);
 #  define jmpi_p(i0, i1)               _jmpi_p(_jit,i0, i1)
 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t,jit_bool_t);
 #  define bccr(cc,i0,r0,r1)            _bccr(_jit,cc,i0,r0,r1)
-static jit_word_t _bccr(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bccr(jit_state_t*,int,jit_word_t,int32_t,jit_int32_t);
 #  define bcci(cc,i0,r0,i1)            _bcci(_jit,cc,i0,r0,i1)
-static jit_word_t _bcci(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bcci(jit_state_t*,int,jit_word_t,int32_t,jit_word_t);
 #  define bltr(i0, r0, r1)             bccr(ARM_CC_LT,i0,r0,r1)
 #  define blti(i0, r0, i1)             bcci(ARM_CC_LT,i0,r0,i1)
 #  define bltr_u(i0, r0, r1)           bccr(ARM_CC_LO,i0,r0,r1)
@@ -996,9 +996,9 @@ static jit_word_t 
_bcci(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
 #  define bner(i0, r0, r1)             bccr(ARM_CC_NE,i0,r0,r1)
 #  define bnei(i0, r0, i1)             bcci(ARM_CC_NE,i0,r0,i1)
 #  define baddr(cc,i0,r0,r1)           _baddr(_jit,cc,i0,r0,r1)
-static jit_word_t _baddr(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _baddr(jit_state_t*,int,jit_word_t,int32_t,jit_int32_t);
 #  define baddi(cc,i0,r0,r1)           _baddi(_jit,cc,i0,r0,r1)
-static jit_word_t _baddi(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _baddi(jit_state_t*,int,jit_word_t,int32_t,jit_word_t);
 #  define boaddr(i0,r0,r1)             baddr(ARM_CC_VS,i0,r0,r1)
 #  define boaddi(i0,r0,i1)             baddi(ARM_CC_VS,i0,r0,i1)
 #  define boaddr_u(i0,r0,r1)           baddr(ARM_CC_HS,i0,r0,r1)
@@ -1008,9 +1008,9 @@ static jit_word_t 
_baddi(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
 #  define bxaddr_u(i0,r0,r1)           baddr(ARM_CC_LO,i0,r0,r1)
 #  define bxaddi_u(i0,r0,i1)           baddi(ARM_CC_LO,i0,r0,i1)
 #  define bsubr(cc,i0,r0,r1)           _bsubr(_jit,cc,i0,r0,r1)
-static jit_word_t _bsubr(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bsubr(jit_state_t*,int,jit_word_t,int32_t,jit_int32_t);
 #  define bsubi(cc,i0,r0,r1)           _bsubi(_jit,cc,i0,r0,r1)
-static jit_word_t _bsubi(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bsubi(jit_state_t*,int,jit_word_t,int32_t,jit_word_t);
 #  define bosubr(i0,r0,r1)             bsubr(ARM_CC_VS,i0,r0,r1)
 #  define bosubi(i0,r0,i1)             bsubi(ARM_CC_VS,i0,r0,i1)
 #  define bosubr_u(i0,r0,r1)           bsubr(ARM_CC_LO,i0,r0,r1)
@@ -1020,110 +1020,110 @@ static jit_word_t 
_bsubi(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
 #  define bxsubr_u(i0,r0,r1)           bsubr(ARM_CC_HS,i0,r0,r1)
 #  define bxsubi_u(i0,r0,i1)           bsubi(ARM_CC_HS,i0,r0,i1)
 #  define bmxr(cc,i0,r0,r1)            _bmxr(_jit,cc,i0,r0,r1)
-static jit_word_t _bmxr(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bmxr(jit_state_t*,int,jit_word_t,int32_t,jit_int32_t);
 #  define bmxi(cc,i0,r0,r1)            _bmxi(_jit,cc,i0,r0,r1)
-static jit_word_t _bmxi(jit_state_t*,int,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bmxi(jit_state_t*,int,jit_word_t,int32_t,jit_word_t);
 #  define bmsr(i0,r0,r1)               bmxr(ARM_CC_NE,i0,r0,r1)
 #  define bmsi(i0,r0,i1)               bmxi(ARM_CC_NE,i0,r0,i1)
 #  define bmcr(i0,r0,r1)               bmxr(ARM_CC_EQ,i0,r0,r1)
 #  define bmci(i0,r0,i1)               bmxi(ARM_CC_EQ,i0,r0,i1)
 #  define ldr_c(r0,r1)                 _ldr_c(_jit,r0,r1)
-static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_c(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_c(r0,i0)                 _ldi_c(_jit,r0,i0)
-static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_c(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_c(r0,r1,r2)             _ldxr_c(_jit,r0,r1,r2)
-static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_c(r0,r1,i0)             _ldxi_c(_jit,r0,r1,i0)
-static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_c(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldr_uc(r0,r1)                        _ldr_uc(_jit,r0,r1)
-static void _ldr_uc(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_uc(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_uc(r0,i0)                        _ldi_uc(_jit,r0,i0)
-static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_uc(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_uc(r0,r1,r2)            _ldxr_uc(_jit,r0,r1,r2)
-static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_uc(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_uc(r0,r1,i0)            _ldxi_uc(_jit,r0,r1,i0)
-static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_uc(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldr_s(r0,r1)                 _ldr_s(_jit,r0,r1)
-static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_s(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_s(r0,i0)                 _ldi_s(_jit,r0,i0)
-static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_s(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_s(r0,r1,r2)             _ldxr_s(_jit,r0,r1,r2)
-static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_s(r0,r1,i0)             _ldxi_s(_jit,r0,r1,i0)
-static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_s(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldr_us(r0,r1)                        _ldr_us(_jit,r0,r1)
-static void _ldr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_us(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_us(r0,i0)                        _ldi_us(_jit,r0,i0)
-static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_us(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_us(r0,r1,r2)            _ldxr_us(_jit,r0,r1,r2)
-static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_us(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_us(r0,r1,i0)            _ldxi_us(_jit,r0,r1,i0)
-static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_us(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldr_i(r0,r1)                 _ldr_i(_jit,r0,r1)
-static void _ldr_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_i(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_i(r0,i0)                 _ldi_i(_jit,r0,i0)
-static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_i(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_i(r0,r1,r2)             _ldxr_i(_jit,r0,r1,r2)
-static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_i(r0,r1,i0)             _ldxi_i(_jit,r0,r1,i0)
-static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_i(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_c(r0,r1)                 _str_c(_jit,r0,r1)
-static void _str_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _str_c(jit_state_t*,int32_t,jit_int32_t);
 #  define sti_c(i0,r0)                 _sti_c(_jit,i0,r0)
-static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_c(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_c(r0,r1,r2)             _stxr_c(_jit,r0,r1,r2)
-static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_c(r0,r1,i0)             _stxi_c(_jit,r0,r1,i0)
-static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_c(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define str_s(r0,r1)                 _str_s(_jit,r0,r1)
-static void _str_s(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _str_s(jit_state_t*,int32_t,jit_int32_t);
 #  define sti_s(i0,r0)                 _sti_s(_jit,i0,r0)
-static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_s(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_s(r0,r1,r2)             _stxr_s(_jit,r0,r1,r2)
-static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_s(r0,r1,i0)             _stxi_s(_jit,r0,r1,i0)
-static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_s(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define str_i(r0,r1)                 _str_i(_jit,r0,r1)
-static void _str_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _str_i(jit_state_t*,int32_t,jit_int32_t);
 #  define sti_i(i0,r0)                 _sti_i(_jit,i0,r0)
-static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_i(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_i(r0,r1,r2)             _stxr_i(_jit,r0,r1,r2)
-static void _stxr_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxr_i(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxi_i(r0,r1,i0)             _stxi_i(_jit,r0,r1,i0)
-static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_i(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  if __BYTE_ORDER == __LITTLE_ENDIAN
 #  define htonr_us(r0,r1)              _htonr_us(_jit,r0,r1)
-static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_us(jit_state_t*,int32_t,jit_int32_t);
 #  define htonr_ui(r0,r1)              _htonr_ui(_jit,r0,r1)
-static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ui(jit_state_t*,int32_t,jit_int32_t);
 #  else
 #    define htonr_us(r0,r1)            extr_us(r0,r1)
 #    define htonr(r0,r1)               movr(r0,r1)
 #  endif
 #  define extr_c(r0,r1)                        _extr_c(_jit,r0,r1)
-static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_c(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_uc(r0,r1)               _extr_uc(_jit,r0,r1)
-static void _extr_uc(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_uc(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_s(r0,r1)                        _extr_s(_jit,r0,r1)
-static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_s(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_us(r0,r1)               _extr_us(_jit,r0,r1)
-static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_us(jit_state_t*,int32_t,jit_int32_t);
 #  define prolog(i0)                   _prolog(_jit,i0)
 static void _prolog(jit_state_t*,jit_node_t*);
 #  define epilog(i0)                   _epilog(_jit,i0)
 static void _epilog(jit_state_t*,jit_node_t*);
 #  define callr(r0)                    _callr(_jit,r0)
-static void _callr(jit_state_t*,jit_int32_t);
+static void _callr(jit_state_t*,int32_t);
 #  define calli(i0)                    _calli(_jit,i0)
 static void _calli(jit_state_t*,jit_word_t);
 #  define calli_p(i0)                  _calli_p(_jit,i0)
 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 #  define vastart(r0)                  _vastart(_jit, r0)
-static void _vastart(jit_state_t*, jit_int32_t);
+static void _vastart(jit_state_t*, int32_t);
 #  define vaarg(r0, r1)                        _vaarg(_jit, r0, r1)
-static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg(jit_state_t*, int32_t, jit_int32_t);
 #  define patch_at(kind,jump,label)    _patch_at(_jit,kind,jump,label)
-static void _patch_at(jit_state_t*,jit_int32_t,jit_word_t,jit_word_t);
+static void _patch_at(jit_state_t*,int32_t,jit_word_t,jit_word_t);
 #endif
 
 #if CODE
@@ -1406,7 +1406,7 @@ _tcb(jit_state_t *_jit, int cc, int im)
     jit_thumb_t        thumb;
     assert(!(cc & 0xfffffff));
     assert(cc != ARM_CC_AL && cc != ARM_CC_NV);
-    cc = ((jit_uint32_t)cc) >> 6;
+    cc = ((uint32_t)cc) >> 6;
     assert(!(im & (THUMB2_CC_B|cc)));
     thumb.i = THUMB2_CC_B|cc|im;
     iss(thumb.s[0], thumb.s[1]);
@@ -1510,7 +1510,7 @@ _torl(jit_state_t *_jit, int o, int rn, int im)
 }
 
 static void
-_nop(jit_state_t *_jit, jit_int32_t i0)
+_nop(jit_state_t *_jit, int32_t i0)
 {
     if (jit_thumb_p()) {
        for (; i0 > 0; i0 -= 2)
@@ -1524,7 +1524,7 @@ _nop(jit_state_t *_jit, jit_int32_t i0)
 }
 
 static void
-_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1) {
        if (jit_thumb_p())
@@ -1535,7 +1535,7 @@ _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     int                        i;
     if (jit_thumb_p()) {
@@ -1546,9 +1546,9 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
        else if ((i = encode_thumb_immediate(~i0)) != -1)
            T2_MVNI(r0, i);
        else {
-           T2_MOVWI(r0, (jit_uint16_t)i0);
+           T2_MOVWI(r0, (uint16_t)i0);
            if (i0 & 0xffff0000)
-               T2_MOVTI(r0, (jit_uint16_t)((unsigned)i0 >> 16));
+               T2_MOVTI(r0, (uint16_t)((unsigned)i0 >> 16));
        }
     }
     else {
@@ -1559,9 +1559,9 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
        else if ((i = encode_arm_immediate(~i0)) != -1)
            MVNI(r0, i);
        else if (jit_armv6_p()) {
-           MOVWI(r0, (jit_uint16_t)(i0));
+           MOVWI(r0, (uint16_t)(i0));
            if ((i0 & 0xffff0000))
-               MOVTI(r0, (jit_uint16_t)((unsigned)i0 >> 16));
+               MOVTI(r0, (uint16_t)((unsigned)i0 >> 16));
        }
        else
            load_const(0, r0, i0);
@@ -1569,13 +1569,13 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static jit_word_t
-_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi_p(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         w;
     w = _jit->pc.w;
     if (jit_thumb_p()) {
-       T2_MOVWI(r0, (jit_uint16_t)(i0));
-       T2_MOVTI(r0, (jit_uint16_t)((unsigned)i0 >> 16));
+       T2_MOVWI(r0, (uint16_t)(i0));
+       T2_MOVTI(r0, (uint16_t)((unsigned)i0 >> 16));
     }
     else
        load_const(1, r0, 0);
@@ -1583,7 +1583,7 @@ _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_comr(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1) < 8)
@@ -1596,7 +1596,7 @@ _comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_negr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_negr(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1) < 8)
@@ -1609,7 +1609,7 @@ _negr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1|r2) < 8)
@@ -1624,10 +1624,10 @@ _addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1) < 8 && !(i0 & ~7))
            T1_ADDI3(r0, r1, i0);
@@ -1671,7 +1671,7 @@ _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addcr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        /* thumb auto set carry if not inside IT block */
@@ -1685,10 +1685,10 @@ _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8 && !(i0 & ~7))
            T1_ADDI3(r0, r1, i0);
@@ -1728,7 +1728,7 @@ _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addxr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     /* keep setting carry because don't know last ADC */
     if (jit_thumb_p()) {
@@ -1743,10 +1743,10 @@ _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     int                        no_set_flags;
     if (jit_thumb_p()) {
        no_set_flags = jit_no_set_flags();
@@ -1786,7 +1786,7 @@ _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1|r2) < 8)
@@ -1799,10 +1799,10 @@ _subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1) < 8 && !(i0 & ~7))
            T1_SUBI3(r0, r1, i0);
@@ -1846,7 +1846,7 @@ _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subcr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        /* thumb auto set carry if not inside IT block */
@@ -1860,10 +1860,10 @@ _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8 && !(i0 & ~7))
            T1_SUBI3(r0, r1, i0);
@@ -1903,7 +1903,7 @@ _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subxr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     /* keep setting carry because don't know last SBC */
     if (jit_thumb_p()) {
@@ -1918,10 +1918,10 @@ _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     int                        no_set_flags;
     if (jit_thumb_p()) {
        no_set_flags = jit_no_set_flags();
@@ -1961,16 +1961,16 @@ _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rsbi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     subi(r0, r1, i0);
     negr(r0, r0);
 }
 
 static void
-_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_mulr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && r0 == r2 && (r0|r1) < 8)
            T1_MUL(r0, r1);
@@ -1996,9 +1996,9 @@ _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_muli(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     mulr(r0, r1, rn(reg));
@@ -2006,10 +2006,10 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
+_iqmulr(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_int32_t r3, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (r2 == r3) {
            reg = jit_get_reg(jit_class_gpr);
@@ -2059,10 +2059,10 @@ _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
+_iqmuli(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     iqmulr(r0, r1, r2, rn(reg), sign);
@@ -2071,7 +2071,7 @@ _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
 
 static void
 _divrem(jit_state_t *_jit, int div, int sign,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         d;
     jit_word_t         w;
@@ -2101,7 +2101,7 @@ _divrem(jit_state_t *_jit, int div, int sign,
 }
 
 static void
-_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_armv7r_p() && jit_thumb_p())
        T2_SDIV(r0, r1, r2);
@@ -2110,9 +2110,9 @@ _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     divr(r0, r1, rn(reg));
@@ -2120,7 +2120,7 @@ _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_armv7r_p() && jit_thumb_p())
        T2_UDIV(r0, r1, r2);
@@ -2129,9 +2129,9 @@ _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     divr_u(r0, r1, rn(reg));
@@ -2139,8 +2139,8 @@ _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
+_iqdivr(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_int32_t r3,     jit_bool_t sign)
 {
     jit_word_t         d;
     jit_word_t         w;
@@ -2170,10 +2170,10 @@ _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
+_iqdivi(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     iqdivr(r0, r1, r2, rn(reg), sign);
@@ -2181,15 +2181,15 @@ _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     divrem(0, 1, r0, r1, r2);
 }
 
 static void
-_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     remr(r0, r1, rn(reg));
@@ -2197,15 +2197,15 @@ _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     divrem(0, 0, r0, r1, r2);
 }
 
 static void
-_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     remr_u(r0, r1,rn(reg));
@@ -2213,7 +2213,7 @@ _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_andr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1|r2) < 8 && (r0 == r1 || r0 == r2))
@@ -2226,10 +2226,10 @@ _andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_andi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((i = encode_thumb_immediate(i0)) != -1)
            T2_ANDI(r0, r1, i);
@@ -2265,7 +2265,7 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_orr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1|r2) < 8 && (r0 == r1 || r0 == r2))
@@ -2278,10 +2278,10 @@ _orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((i = encode_thumb_immediate(i0)) != -1)
            T2_ORRI(r0, r1, i);
@@ -2313,7 +2313,7 @@ _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_xorr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1|r2) < 8 && (r0 == r1 || r0 == r2))
@@ -2326,10 +2326,10 @@ _xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_xori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((i = encode_thumb_immediate(i0)) != -1)
            T2_EORI(r0, r1, i);
@@ -2361,7 +2361,7 @@ _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_lshr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1)
@@ -2374,7 +2374,7 @@ _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 <= 31);
     if (i0 == 0)
@@ -2390,7 +2390,7 @@ _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_rshr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1)
@@ -2403,7 +2403,7 @@ _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 <= 31);
     if (i0 == 0)
@@ -2419,7 +2419,7 @@ _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_rshr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if (!jit_no_set_flags() && (r0|r1|r2) < 8 && r0 == r1)
@@ -2432,7 +2432,7 @@ _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 <= 31);
     if (i0 == 0)
@@ -2449,7 +2449,7 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 
 static void
 _ccr(jit_state_t *_jit, int ct, int cf,
-     jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+     int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        assert((ct ^ cf) >> 28 == 1);
@@ -2478,10 +2478,10 @@ _ccr(jit_state_t *_jit, int ct, int cf,
 
 static void
 _cci(jit_state_t *_jit, int ct, int cf,
-     jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+     int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (r1 < 7 && !(i0 & 0xffffff00))
            T1_CMPI(r1, i0);
@@ -2527,7 +2527,7 @@ _cci(jit_state_t *_jit, int ct, int cf,
 }
 
 static void
-_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p())
        ccr(ARM_CC_NE, ARM_CC_EQ, r0, r1, r2);
@@ -2538,10 +2538,10 @@ _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_nei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p())
        cci(ARM_CC_NE, ARM_CC_EQ, r0, r1, i0);
     else {
@@ -2564,7 +2564,7 @@ _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_jmpr(jit_state_t *_jit, jit_int32_t r0)
+_jmpr(jit_state_t *_jit, int32_t r0)
 {
     if (jit_thumb_p())
        T1_MOV(_R15_REGNO, r0);
@@ -2577,7 +2577,7 @@ _jmpi(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     w = _jit->pc.w;
     /* if thumb and in thumb mode */
     if (jit_thumb_p() && _jitc->thumb) {
@@ -2611,7 +2611,7 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0, jit_bool_t i1)
 {
     jit_word_t         w;
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1) {
        /* Assume jump is not longer than 23 bits if inside jit */
        w = _jit->pc.w;
@@ -2637,7 +2637,7 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0, jit_bool_t i1)
 }
 
 static jit_word_t
-_bccr(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bccr(jit_state_t *_jit, int cc, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     jit_word_t         d;
@@ -2665,12 +2665,12 @@ _bccr(jit_state_t *_jit, int cc, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bcci(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bcci(jit_state_t *_jit, int cc, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
     jit_word_t         d;
     int                        i;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (r0 < 7 && !(i1 & 0xffffff00))
            T1_CMPI(r0, i1);
@@ -2710,7 +2710,7 @@ _bcci(jit_state_t *_jit, int cc, jit_word_t i0, 
jit_int32_t r0, jit_word_t i1)
 }
 
 static jit_word_t
-_baddr(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_int32_t 
r1)
+_baddr(jit_state_t *_jit, int cc, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     jit_word_t         d;
@@ -2735,12 +2735,12 @@ _baddr(jit_state_t *_jit, int cc, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_baddi(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, int i1)
+_baddi(jit_state_t *_jit, int cc, jit_word_t i0, int32_t r0, int i1)
 {
     int                        i;
     jit_word_t         w;
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (r0 < 8 && !(i1 & ~7))
            T1_ADDI3(r0, r0, i1);
@@ -2785,7 +2785,7 @@ _baddi(jit_state_t *_jit, int cc, jit_word_t i0, 
jit_int32_t r0, int i1)
 }
 
 static jit_word_t
-_bsubr(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_int32_t 
r1)
+_bsubr(jit_state_t *_jit, int cc, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     jit_word_t         d;
@@ -2810,12 +2810,12 @@ _bsubr(jit_state_t *_jit, int cc, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bsubi(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, int i1)
+_bsubi(jit_state_t *_jit, int cc, jit_word_t i0, int32_t r0, int i1)
 {
     int                        i;
     jit_word_t         w;
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (r0 < 8 && !(i1 & ~7))
            T1_SUBI3(r0, r0, i1);
@@ -2860,11 +2860,11 @@ _bsubi(jit_state_t *_jit, int cc, jit_word_t i0, 
jit_int32_t r0, int i1)
 }
 
 static jit_word_t
-_bmxr(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bmxr(jit_state_t *_jit, int cc, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8)
            T1_TST(r0, r1);
@@ -2892,12 +2892,12 @@ _bmxr(jit_state_t *_jit, int cc, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bmxi(jit_state_t *_jit, int cc, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bmxi(jit_state_t *_jit, int cc, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     int                        i;
     jit_word_t         w;
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((i = encode_thumb_immediate(i1)) != -1)
            T2_TSTI(r0, i);
@@ -2944,7 +2944,7 @@ _bmxi(jit_state_t *_jit, int cc, jit_word_t i0, 
jit_int32_t r0, jit_word_t i1)
 }
 
 static void
-_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p())
        T2_LDRSBI(r0, r1, 0);
@@ -2953,9 +2953,9 @@ _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_thumb_p())
@@ -2966,7 +2966,7 @@ _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if ((r0|r1|r2) < 8)
@@ -2979,9 +2979,9 @@ _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
            T2_LDRSBI(r0, r1, i0);
@@ -3025,7 +3025,7 @@ _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p())
        T2_LDRBI(r0, r1, 0);
@@ -3034,9 +3034,9 @@ _ldr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_thumb_p())
@@ -3047,7 +3047,7 @@ _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if ((r0|r1|r2) < 8)
@@ -3060,9 +3060,9 @@ _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8 && i0 >= 0 && i0 < 0x20)
            T1_LDRBI(r0, r1, i0);
@@ -3108,7 +3108,7 @@ _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p())
        T2_LDRSHI(r0, r1, 0);
@@ -3117,9 +3117,9 @@ _ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_thumb_p())
@@ -3130,7 +3130,7 @@ _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if ((r0|r1|r2) < 8)
@@ -3143,9 +3143,9 @@ _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if (jit_ldrt_strt_p() && i0 >= 0 && i0 <= 255)
            T2_LDRSHI(r0, r1, i0);
@@ -3189,7 +3189,7 @@ _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p())
        T2_LDRHI(r0, r1, 0);
@@ -3198,9 +3198,9 @@ _ldr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_thumb_p())
@@ -3211,7 +3211,7 @@ _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if ((r0|r1|r2) < 8)
@@ -3224,9 +3224,9 @@ _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 1) && (i0 >> 1) < 0x20)
            T1_LDRHI(r0, r1, i0 >> 1);
@@ -3272,7 +3272,7 @@ _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p())
        T2_LDRI(r0, r1, 0);
@@ -3281,9 +3281,9 @@ _ldr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_thumb_p())
@@ -3294,7 +3294,7 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if ((r0|r1|r2) < 8)
@@ -3307,9 +3307,9 @@ _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 3) && (i0 >> 2) < 0x20)
            T1_LDRI(r0, r1, i0 >> 2);
@@ -3358,7 +3358,7 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_str_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_str_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p())
        T2_STRBI(r1, r0, 0);
@@ -3367,9 +3367,9 @@ _str_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_thumb_p())
@@ -3380,7 +3380,7 @@ _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if ((r0|r1|r2) < 8)
@@ -3393,9 +3393,9 @@ _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8 && i0 >= 0 && i0 < 0x20)
            T1_STRBI(r1, r0, i0);
@@ -3430,7 +3430,7 @@ _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_str_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_str_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p())
        T2_STRHI(r1, r0, 0);
@@ -3439,9 +3439,9 @@ _str_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_thumb_p())
@@ -3452,7 +3452,7 @@ _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if ((r0|r1|r2) < 8)
@@ -3465,9 +3465,9 @@ _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 1) && (i0 >> 1) < 0x20)
            T1_STRHI(r1, r0, i0 >> 1);
@@ -3502,7 +3502,7 @@ _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_str_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_str_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p())
        T2_STRI(r1, r0, 0);
@@ -3511,9 +3511,9 @@ _str_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_thumb_p())
@@ -3524,7 +3524,7 @@ _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     if (jit_thumb_p()) {
        if ((r0|r1|r2) < 8)
@@ -3537,9 +3537,9 @@ _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8 && i0 >= 0 && !(i0 & 3) && (i0 >> 2) < 0x20)
            T1_STRI(r1, r0, i0 >> 2);
@@ -3578,9 +3578,9 @@ _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 
 #  if __BYTE_ORDER == __LITTLE_ENDIAN
 static void
-_htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8)
            T1_REV(r0, r1);
@@ -3607,9 +3607,9 @@ _htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 
 /* inline glibc htonl (without register clobber) */
 static void
-_htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_thumb_p()) {
        if ((r0|r1) < 8)
            T1_REV(r0, r1);
@@ -3632,7 +3632,7 @@ _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 #endif
 
 static void
-_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p()) {
        if ((r0|r1) < 8)
@@ -3651,7 +3651,7 @@ _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_extr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p()) {
        if ((r0|r1) < 8)
@@ -3668,7 +3668,7 @@ _extr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p()) {
        if ((r0|r1) < 8)
@@ -3687,7 +3687,7 @@ _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_thumb_p()) {
        if ((r0|r1) < 8)
@@ -3706,7 +3706,7 @@ _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_callr(jit_state_t *_jit, jit_int32_t r0)
+_callr(jit_state_t *_jit, int32_t r0)
 {
     if (jit_thumb_p())
        T1_BLX(r0);
@@ -3718,7 +3718,7 @@ static void
 _calli(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     d = ((i0 - _jit->pc.w) >> 2) - 2;
     if (!jit_exchange_p() && !jit_thumb_p() && _s24P(d))
        BLI(d & 0x00ffffff);
@@ -3737,7 +3737,7 @@ static jit_word_t
 _calli_p(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     w = _jit->pc.w;
     movi_p(rn(reg), i0);
@@ -3752,9 +3752,9 @@ _calli_p(jit_state_t *_jit, jit_word_t i0)
 static void
 _prolog(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
-       jit_int32_t     frame = -_jitc->function->frame;
+       int32_t frame = -_jitc->function->frame;
        assert(_jitc->function->self.aoff >= frame);
        if (_jitc->function->assume_frame) {
            if (jit_thumb_p() && !_jitc->thumb)
@@ -3833,7 +3833,7 @@ _epilog(jit_state_t *_jit, jit_node_t *node)
 }
 
 static void
-_vastart(jit_state_t *_jit, jit_int32_t r0)
+_vastart(jit_state_t *_jit, int32_t r0)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
 
@@ -3846,7 +3846,7 @@ _vastart(jit_state_t *_jit, jit_int32_t r0)
 }
 
 static void
-_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
 
@@ -3859,13 +3859,13 @@ _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 
 static void
 _patch_at(jit_state_t *_jit,
-         jit_int32_t kind, jit_word_t instr, jit_word_t label)
+         int32_t kind, jit_word_t instr, jit_word_t label)
 {
     jit_word_t          d;
     jit_thumb_t                 thumb;
     union {
-       jit_int16_t     *s;
-       jit_int32_t     *i;
+       int16_t *s;
+       int32_t *i;
        jit_word_t       w;
     } u;
     u.w = instr;
diff --git a/jit/arm-swf.c b/jit/arm-swf.c
index 3ea2b2b..aee52a5 100644
--- a/jit/arm-swf.c
+++ b/jit/arm-swf.c
@@ -50,98 +50,98 @@ extern int  __aeabi_fcmpun(float, float);
 extern int     __aeabi_dcmpun(double, double);
 #  define swf_ff(i0,r0,r1)             _swf_ff(_jit,i0,r0,r1)
 static void
-_swf_ff(jit_state_t*,float(*)(float),jit_int32_t,jit_int32_t) maybe_unused;
+_swf_ff(jit_state_t*,float(*)(float),int32_t,jit_int32_t) maybe_unused;
 #  define swf_dd(i0,r0,r1)             _swf_dd(_jit,i0,r0,r1)
 static void
-_swf_dd(jit_state_t*,double(*)(double),jit_int32_t,jit_int32_t) maybe_unused;
+_swf_dd(jit_state_t*,double(*)(double),int32_t,jit_int32_t) maybe_unused;
 #  define swf_fff(i0,r0,r1,r2)         _swf_fff(_jit,i0,r0,r1,r2)
 static void _swf_fff(jit_state_t*,float(*)(float,float),
-                    jit_int32_t,jit_int32_t,jit_int32_t);
+                    int32_t,jit_int32_t,jit_int32_t);
 #  define swf_ddd(i0,r0,r1,r2)         _swf_ddd(_jit,i0,r0,r1,r2)
 static void _swf_ddd(jit_state_t*,double(*)(double,double),
-                    jit_int32_t,jit_int32_t,jit_int32_t);
+                    int32_t,jit_int32_t,jit_int32_t);
 #  define swf_fff_(i0,r0,r1,i1)                _swf_fff_(_jit,i0,r0,r1,i1)
 static void _swf_fff_(jit_state_t*,float(*)(float,float),
-                     jit_int32_t,jit_int32_t,jit_float32_t);
+                     int32_t,jit_int32_t,jit_float32_t);
 #  define swf_ddd_(i0,r0,r1,i1)                _swf_ddd_(_jit,i0,r0,r1,i1)
 static void _swf_ddd_(jit_state_t*,double(*)(double,double),
-                     jit_int32_t,jit_int32_t,jit_float64_t);
+                     int32_t,jit_int32_t,jit_float64_t);
 #  define swf_iff(i0,r0,r1,r2)         _swf_iff(_jit,i0,r0,r1,r2)
 static void _swf_iff(jit_state_t*,int(*)(float,float),
-                    jit_int32_t,jit_int32_t,jit_int32_t);
+                    int32_t,jit_int32_t,jit_int32_t);
 #  define swf_idd(i0,r0,r1,r2)         _swf_idd(_jit,i0,r0,r1,r2)
 static void _swf_idd(jit_state_t*,int(*)(double,double),
-                    jit_int32_t,jit_int32_t,jit_int32_t);
+                    int32_t,jit_int32_t,jit_int32_t);
 #  define swf_iff_(i0,r0,r1,r2)                _swf_iff_(_jit,i0,r0,r1,r2)
 static void _swf_iff_(jit_state_t*,int(*)(float,float),
-                     jit_int32_t,jit_int32_t,jit_float32_t);
+                     int32_t,jit_int32_t,jit_float32_t);
 #  define swf_idd_(i0,r0,r1,r2)                _swf_idd_(_jit,i0,r0,r1,r2)
 static void _swf_idd_(jit_state_t*,int(*)(double,double),
-                     jit_int32_t,jit_int32_t,jit_float64_t);
+                     int32_t,jit_int32_t,jit_float64_t);
 #  define swf_iunff(i0,r0,r1,r2)       _swf_iunff(_jit,i0,r0,r1,r2)
 static void _swf_iunff(jit_state_t*,int(*)(float,float),
-                      jit_int32_t,jit_int32_t,jit_int32_t);
+                      int32_t,jit_int32_t,jit_int32_t);
 #  define swf_iundd(i0,r0,r1,r2)       _swf_iundd(_jit,i0,r0,r1,r2)
 static void _swf_iundd(jit_state_t*,int(*)(double,double),
-                      jit_int32_t,jit_int32_t,jit_int32_t);
+                      int32_t,jit_int32_t,jit_int32_t);
 #  define swf_iunff_(i0,r0,r1,i1)      _swf_iunff_(_jit,i0,r0,r1,i1)
 static void _swf_iunff_(jit_state_t*,int(*)(float,float),
-                       jit_int32_t,jit_int32_t,jit_float32_t);
+                       int32_t,jit_int32_t,jit_float32_t);
 #  define swf_iundd_(i0,r0,r1,i1)      _swf_iundd_(_jit,i0,r0,r1,i1)
 static void _swf_iundd_(jit_state_t*,int(*)(double,double),
-                       jit_int32_t,jit_int32_t,jit_float64_t);
+                       int32_t,jit_int32_t,jit_float64_t);
 #  define swf_bff(i0,cc,i1,r0,r1)      _swf_bff(_jit,i0,cc,i1,r0,r1)
 static jit_word_t _swf_bff(jit_state_t*,int(*)(float,float),int,
-                          jit_word_t,jit_int32_t,jit_int32_t);
+                          jit_word_t,int32_t,jit_int32_t);
 #  define swf_bdd(i0,cc,i1,r0,r1)      _swf_bdd(_jit,i0,cc,i1,r0,r1)
 static jit_word_t _swf_bdd(jit_state_t*,int(*)(double,double),int,
-                          jit_word_t,jit_int32_t,jit_int32_t);
+                          jit_word_t,int32_t,jit_int32_t);
 #  define swf_bff_(i0,cc,i1,r0,i2)     _swf_bff_(_jit,i0,cc,i1,r0,i2)
 static jit_word_t _swf_bff_(jit_state_t*,int(*)(float,float),int,
-                           jit_word_t,jit_int32_t,jit_float32_t);
+                           jit_word_t,int32_t,jit_float32_t);
 #  define swf_bdd_(i0,cc,i1,r0,i2)     _swf_bdd_(_jit,i0,cc,i1,r0,i2)
 static jit_word_t _swf_bdd_(jit_state_t*,int(*)(double,double),int,
-                           jit_word_t,jit_int32_t,jit_float64_t);
+                           jit_word_t,int32_t,jit_float64_t);
 #  define swf_bunff(eq,i0,r0,r1)       _swf_bunff(_jit,eq,i0,r0,r1)
 static jit_word_t _swf_bunff(jit_state_t*,int,
-                            jit_word_t,jit_int32_t,jit_int32_t);
+                            jit_word_t,int32_t,jit_int32_t);
 #  define swf_bundd(eq,i0,r0,r1)       _swf_bundd(_jit,eq,i0,r0,r1)
 static jit_word_t _swf_bundd(jit_state_t*,int,
-                            jit_word_t,jit_int32_t,jit_int32_t);
+                            jit_word_t,int32_t,jit_int32_t);
 #  define swf_bunff_(eq,i0,r0,i1)      _swf_bunff_(_jit,eq,i0,r0,i1)
 static jit_word_t _swf_bunff_(jit_state_t*,int,
-                             jit_word_t,jit_int32_t,jit_float32_t);
+                             jit_word_t,int32_t,jit_float32_t);
 #  define swf_bundd_(eq,i0,r0,i1)      _swf_bundd_(_jit,eq,i0,r0,i1)
 static jit_word_t _swf_bundd_(jit_state_t*,int,
-                             jit_word_t,jit_int32_t,jit_float64_t);
+                             jit_word_t,int32_t,jit_float64_t);
 #  define swf_extr_f(r0,r1)            _swf_extr_f(_jit,r0,r1)
-static void _swf_extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_extr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_extr_d(r0,r1)            _swf_extr_d(_jit,r0,r1)
-static void _swf_extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_extr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_extr_d_f(r0,r1)          _swf_extr_d_f(_jit,r0,r1)
-static void _swf_extr_d_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_extr_d_f(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_extr_f_d(r0,r1)          _swf_extr_f_d(_jit,r0,r1)
-static void _swf_extr_f_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_extr_f_d(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_truncr_f_i(r0,r1)                _swf_truncr_f_i(_jit,r0,r1)
-static void _swf_truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_truncr_f_i(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_truncr_d_i(r0,r1)                _swf_truncr_d_i(_jit,r0,r1)
-static void _swf_truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_truncr_d_i(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_movr_f(r0,r1)            _swf_movr_f(_jit,r0,r1)
-static void _swf_movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_movr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_movr_d(r0,r1)            _swf_movr_d(_jit,r0,r1)
-static void _swf_movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_movr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_movi_f(r0,i0)            _swf_movi_f(_jit,r0,i0)
-static void _swf_movi_f(jit_state_t*,jit_int32_t,jit_float32_t);
+static void _swf_movi_f(jit_state_t*,int32_t,jit_float32_t);
 #  define swf_movi_d(r0,i0)            _swf_movi_d(_jit,r0,i0)
-static void _swf_movi_d(jit_state_t*,jit_int32_t,jit_float64_t);
+static void _swf_movi_d(jit_state_t*,int32_t,jit_float64_t);
 #  define swf_absr_f(r0,r1)            _swf_absr_f(_jit,r0,r1)
-static void _swf_absr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_absr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_absr_d(r0,r1)            _swf_absr_d(_jit,r0,r1)
-static void _swf_absr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_absr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_negr_f(r0,r1)            _swf_negr_f(_jit,r0,r1)
-static void _swf_negr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_negr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_negr_d(r0,r1)            _swf_negr_d(_jit,r0,r1)
-static void _swf_negr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_negr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_sqrtr_f(r0,r1)           swf_ff(sqrtf,r0,r1)
 #  define swf_sqrtr_d(r0,r1)           swf_dd(sqrt,r0,r1)
 #  define swf_addr_f(r0,r1,r2)         swf_fff(__addsf3,r0,r1,r2)
@@ -154,10 +154,10 @@ static void 
_swf_negr_d(jit_state_t*,jit_int32_t,jit_int32_t);
 #  define swf_subi_d(r0,r1,i0)         swf_ddd_(__aeabi_dsub,r0,r1,i0)
 #  define swf_rsbr_f(r0, r1, r2)       swf_subr_f(r0, r2, r1)
 #  define swf_rsbi_f(r0, r1, i0)       _swf_rsbi_f(_jit, r0, r1, i0)
-static void _swf_rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _swf_rsbi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define swf_rsbr_d(r0, r1, r2)       swf_subr_d(r0, r2, r1)
 #  define swf_rsbi_d(r0, r1, i0)       _swf_rsbi_d(_jit, r0, r1, i0)
-static void _swf_rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _swf_rsbi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define swf_mulr_f(r0,r1,r2)         swf_fff(__aeabi_fmul,r0,r1,r2)
 #  define swf_muli_f(r0,r1,i0)         swf_fff_(__aeabi_fmul,r0,r1,i0)
 #  define swf_mulr_d(r0,r1,r2)         swf_ddd(__aeabi_dmul,r0,r1,r2)
@@ -187,13 +187,13 @@ static void 
_swf_rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
 #  define swf_gtr_d(r0,r1,r2)          swf_idd(__aeabi_dcmpgt,r0,r1,r2)
 #  define swf_gti_d(r0,r1,i0)          swf_idd_(__aeabi_dcmpgt,r0,r1,i0)
 #  define swf_ner_f(r0,r1,r2)          _swf_ner_f(_jit,r0,r1,r2)
-static void _swf_ner_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_ner_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_nei_f(r0,r1,i0)          _swf_nei_f(_jit,r0,r1,i0)
-static void _swf_nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _swf_nei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define swf_ner_d(r0,r1,r2)          _swf_ner_d(_jit,r0,r1,r2)
-static void _swf_ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_ner_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_nei_d(r0,r1,i0)          _swf_nei_d(_jit,r0,r1,i0)
-static void _swf_nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _swf_nei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define swf_unltr_f(r0,r1,r2)                
swf_iunff(__aeabi_fcmplt,r0,r1,r2)
 #  define swf_unlti_f(r0,r1,i0)                
swf_iunff_(__aeabi_fcmplt,r0,r1,i0)
 #  define swf_unltr_d(r0,r1,r2)                
swf_iundd(__aeabi_dcmplt,r0,r1,r2)
@@ -215,21 +215,21 @@ static void 
_swf_nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
 #  define swf_ungtr_d(r0,r1,r2)                
swf_iundd(__aeabi_dcmpgt,r0,r1,r2)
 #  define swf_ungti_d(r0,r1,i0)                
swf_iundd_(__aeabi_dcmpgt,r0,r1,i0)
 #  define swf_ltgtr_f(r0,r1,r2)                _swf_ltgtr_f(_jit,r0,r1,r2)
-static void _swf_ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_ltgtr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_ltgti_f(r0,r1,i0)                _swf_ltgti_f(_jit,r0,r1,i0)
-static void _swf_ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _swf_ltgti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define swf_ltgtr_d(r0,r1,r2)                _swf_ltgtr_d(_jit,r0,r1,r2)
-static void _swf_ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_ltgtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_ltgti_d(r0,r1,i0)                _swf_ltgti_d(_jit,r0,r1,i0)
-static void _swf_ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _swf_ltgti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define swf_ordr_f(r0,r1,r2)         _swf_ordr_f(_jit,r0,r1,r2)
-static void _swf_ordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_ordr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_ordi_f(r0,r1,i0)         _swf_ordi_f(_jit,r0,r1,i0)
-static void _swf_ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _swf_ordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define swf_ordr_d(r0,r1,r2)         _swf_ordr_d(_jit,r0,r1,r2)
-static void _swf_ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_ordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_ordi_d(r0,r1,i0)         _swf_ordi_d(_jit,r0,r1,i0)
-static void _swf_ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _swf_ordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define swf_unordr_f(r0,r1,r2)       swf_iunff(__aeabi_fcmpun,r0,r1,r2)
 #  define swf_unordi_f(r0,r1,i0)       swf_iunff_(__aeabi_fcmpun,r0,r1,i0)
 #  define swf_unordr_d(r0,r1,r2)       swf_iundd(__aeabi_dcmpun,r0,r1,r2)
@@ -291,39 +291,39 @@ static void 
_swf_ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
 #  define swf_bunordr_d(i0,r0,r1)      
swf_bdd(__aeabi_dcmpun,ARM_CC_NE,i0,r0,r1)
 #  define swf_bunordi_d(i0,r0,i1)      
swf_bdd_(__aeabi_dcmpun,ARM_CC_NE,i0,r0,i1)
 #  define swf_ldr_f(r0,r1)             _swf_ldr_f(_jit,r0,r1)
-static void _swf_ldr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_ldr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_ldr_d(r0,r1)             _swf_ldr_d(_jit,r0,r1)
-static void _swf_ldr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_ldr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_ldi_f(r0,i0)             _swf_ldi_f(_jit,r0,i0)
-static void _swf_ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+static void _swf_ldi_f(jit_state_t*,int32_t,jit_word_t);
 #  define swf_ldi_d(r0,i0)             _swf_ldi_d(_jit,r0,i0)
-static void _swf_ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+static void _swf_ldi_d(jit_state_t*,int32_t,jit_word_t);
 #  define swf_ldxr_f(r0,r1,r2)         _swf_ldxr_f(_jit,r0,r1,r2)
-static void _swf_ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_ldxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_ldxr_d(r0,r1,r2)         _swf_ldxr_d(_jit,r0,r1,r2)
-static void _swf_ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_ldxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_ldxi_f(r0,r1,i0)         _swf_ldxi_f(_jit,r0,r1,i0)
-static void _swf_ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _swf_ldxi_f(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define swf_ldxi_d(r0,r1,i0)         _swf_ldxi_d(_jit,r0,r1,i0)
-static void _swf_ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _swf_ldxi_d(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define swf_str_f(r0,r1)             _swf_str_f(_jit,r0,r1)
-static void _swf_str_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_str_f(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_str_d(r0,r1)             _swf_str_d(_jit,r0,r1)
-static void _swf_str_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _swf_str_d(jit_state_t*,int32_t,jit_int32_t);
 #  define swf_sti_f(r0,i0)             _swf_sti_f(_jit,r0,i0)
-static void _swf_sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+static void _swf_sti_f(jit_state_t*,jit_word_t,int32_t);
 #  define swf_sti_d(r0,i0)             _swf_sti_d(_jit,r0,i0)
-static void _swf_sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+static void _swf_sti_d(jit_state_t*,jit_word_t,int32_t);
 #  define swf_stxr_f(r0,r1,r2)         _swf_stxr_f(_jit,r0,r1,r2)
-static void _swf_stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_stxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_stxr_d(r0,r1,r2)         _swf_stxr_d(_jit,r0,r1,r2)
-static void _swf_stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _swf_stxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define swf_stxi_f(r0,r1,i0)         _swf_stxi_f(_jit,r0,r1,i0)
-static void _swf_stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _swf_stxi_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define swf_stxi_d(r0,r1,i0)         _swf_stxi_d(_jit,r0,r1,i0)
-static void _swf_stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _swf_stxi_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define swf_vaarg_d(r0, r1)          _swf_vaarg_d(_jit, r0, r1)
-static void _swf_vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _swf_vaarg_d(jit_state_t*, int32_t, jit_int32_t);
 #endif
 
 #if CODE
@@ -358,7 +358,7 @@ static void _swf_vaarg_d(jit_state_t*, jit_int32_t, 
jit_int32_t);
 #define swf_call_with_get_reg(function, label)                         \
     do {                                                               \
        jit_word_t      d;                                              \
-       jit_int32_t     reg;                                            \
+       int32_t reg;                                            \
        if (!jit_exchange_p()) {                                        \
            if (jit_thumb_p())                                          \
                d = (((jit_word_t)function - _jit->pc.w) >> 1) - 2;     \
@@ -561,7 +561,7 @@ __aeabi_dcmpun(double u, double v)
 
 static void
 _swf_ff(jit_state_t *_jit, float(*i0)(float),
-       jit_int32_t r0, jit_int32_t r1)
+       int32_t r0, jit_int32_t r1)
 {
     jit_get_reg_args();
     if (jit_fpr_p(r1))
@@ -578,7 +578,7 @@ _swf_ff(jit_state_t *_jit, float(*i0)(float),
 
 static void
 _swf_dd(jit_state_t *_jit, double (*i0)(double),
-       jit_int32_t r0, jit_int32_t r1)
+       int32_t r0, jit_int32_t r1)
 {
     jit_get_reg_args();
     if (jit_fpr_p(r1)) {
@@ -611,7 +611,7 @@ _swf_dd(jit_state_t *_jit, double (*i0)(double),
 
 static void
 _swf_fff(jit_state_t *_jit, float (*i0)(float, float),
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_get_reg_args();
     if (jit_fpr_p(r1))
@@ -632,7 +632,7 @@ _swf_fff(jit_state_t *_jit, float (*i0)(float, float),
 
 static void
 _swf_ddd(jit_state_t *_jit, double (*i0)(double, double),
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_get_reg_args();
     if (jit_fpr_p(r1)) {
@@ -677,10 +677,10 @@ _swf_ddd(jit_state_t *_jit, double (*i0)(double, double),
 
 static void
 _swf_fff_(jit_state_t *_jit, float (*i0)(float, float),
-         jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
+         int32_t r0, jit_int32_t r1, jit_float32_t i1)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
     jit_get_reg_args();
@@ -699,10 +699,10 @@ _swf_fff_(jit_state_t *_jit, float (*i0)(float, float),
 }
 
 static void
-_swf_rsbi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t 
i0)
+_swf_rsbi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float32_t i0)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
     jit_get_reg_args();
@@ -722,10 +722,10 @@ _swf_rsbi_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_float32_t i0)
 
 static void
 _swf_ddd_(jit_state_t *_jit, double (*i0)(double, double),
-         jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
+         int32_t r0, jit_int32_t r1, jit_float64_t i1)
 {
     union {
-       jit_int32_t     i[2];
+       int32_t i[2];
        jit_float64_t   d;
     } data;
     jit_get_reg_args();
@@ -762,10 +762,10 @@ _swf_ddd_(jit_state_t *_jit, double (*i0)(double, double),
 }
 
 static void
-_swf_rsbi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t 
i0)
+_swf_rsbi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float64_t i0)
 {
     union {
-       jit_int32_t     i[2];
+       int32_t i[2];
        jit_float64_t   d;
     } data;
     jit_get_reg_args();
@@ -802,7 +802,7 @@ _swf_rsbi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_float64_t i0)
 
 static void
 _swf_iff(jit_state_t *_jit, int (*i0)(float, float),
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_get_reg_args();
     if (jit_fpr_p(r1))
@@ -820,7 +820,7 @@ _swf_iff(jit_state_t *_jit, int (*i0)(float, float),
 
 static void
 _swf_idd(jit_state_t *_jit, int (*i0)(double, double),
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_get_reg_args();
     if (jit_fpr_p(r1)) {
@@ -854,10 +854,10 @@ _swf_idd(jit_state_t *_jit, int (*i0)(double, double),
 
 static void
 _swf_iff_(jit_state_t *_jit, int (*i0)(float, float),
-         jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
+         int32_t r0, jit_int32_t r1, jit_float32_t i1)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
     jit_get_reg_args();
@@ -874,10 +874,10 @@ _swf_iff_(jit_state_t *_jit, int (*i0)(float, float),
 
 static void
 _swf_idd_(jit_state_t *_jit, int (*i0)(double, double),
-         jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
+         int32_t r0, jit_int32_t r1, jit_float64_t i1)
 {
     union {
-       jit_int32_t     i[2];
+       int32_t i[2];
        jit_float64_t   d;
     } data;
     jit_get_reg_args();
@@ -903,7 +903,7 @@ _swf_idd_(jit_state_t *_jit, int (*i0)(double, double),
 
 static void
 _swf_iunff(jit_state_t *_jit, int (*i0)(float, float),
-          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+          int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         instr;
     jit_get_reg_args();
@@ -948,7 +948,7 @@ _swf_iunff(jit_state_t *_jit, int (*i0)(float, float),
 
 static void
 _swf_iundd(jit_state_t *_jit, int (*i0)(double, double),
-          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+          int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         instr;
     jit_get_reg_args();
@@ -1025,11 +1025,11 @@ _swf_iundd(jit_state_t *_jit, int (*i0)(double, double),
 
 static void
 _swf_iunff_(jit_state_t *_jit, int (*i0)(float, float),
-           jit_int32_t r0, jit_int32_t r1, jit_float32_t i1)
+           int32_t r0, jit_int32_t r1, jit_float32_t i1)
 {
     jit_word_t         instr;
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
     jit_get_reg_args();
@@ -1069,11 +1069,11 @@ _swf_iunff_(jit_state_t *_jit, int (*i0)(float, float),
 
 static void
 _swf_iundd_(jit_state_t *_jit, int (*i0)(double, double),
-           jit_int32_t r0, jit_int32_t r1, jit_float64_t i1)
+           int32_t r0, jit_int32_t r1, jit_float64_t i1)
 {
     jit_word_t         instr;
     union {
-       jit_int32_t     i[2];
+       int32_t i[2];
        jit_float64_t   d;
     } data;
     jit_get_reg_args();
@@ -1131,7 +1131,7 @@ _swf_iundd_(jit_state_t *_jit, int (*i0)(double, double),
 
 static jit_word_t
 _swf_bff(jit_state_t *_jit, int (*i0)(float, float), int cc,
-        jit_word_t i1, jit_int32_t r0, jit_int32_t r1)
+        jit_word_t i1, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w, d;
     jit_get_reg_args();
@@ -1164,7 +1164,7 @@ _swf_bff(jit_state_t *_jit, int (*i0)(float, float), int 
cc,
 
 static jit_word_t
 _swf_bdd(jit_state_t *_jit, int (*i0)(double, double), int cc,
-        jit_word_t i1, jit_int32_t r0, jit_int32_t r1)
+        jit_word_t i1, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w, d;
     jit_get_reg_args();
@@ -1213,10 +1213,10 @@ _swf_bdd(jit_state_t *_jit, int (*i0)(double, double), 
int cc,
 
 static jit_word_t
 _swf_bff_(jit_state_t *_jit, int (*i0)(float, float), int cc,
-         jit_word_t i1, jit_int32_t r0, jit_float32_t i2)
+         jit_word_t i1, int32_t r0, jit_float32_t i2)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
     jit_word_t         w, d;
@@ -1248,11 +1248,11 @@ _swf_bff_(jit_state_t *_jit, int (*i0)(float, float), 
int cc,
 
 static jit_word_t
 _swf_bdd_(jit_state_t *_jit, int (*i0)(double, double), int cc,
-         jit_word_t i1, jit_int32_t r0, jit_float64_t i2)
+         jit_word_t i1, int32_t r0, jit_float64_t i2)
 {
     jit_word_t         w, d;
     union {
-       jit_int32_t     i[2];
+       int32_t i[2];
        jit_float64_t   d;
     } data;
     jit_get_reg_args();
@@ -1292,7 +1292,7 @@ _swf_bdd_(jit_state_t *_jit, int (*i0)(double, double), 
int cc,
 
 static jit_word_t
 _swf_bunff(jit_state_t *_jit, int eq,
-          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+          jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w, d, j0, j1;
     jit_get_reg_args();
@@ -1362,7 +1362,7 @@ _swf_bunff(jit_state_t *_jit, int eq,
 
 static jit_word_t
 _swf_bundd(jit_state_t *_jit, int eq,
-          jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+          jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w, d, j0, j1;
     jit_get_reg_args();
@@ -1464,10 +1464,10 @@ _swf_bundd(jit_state_t *_jit, int eq,
 
 static jit_word_t
 _swf_bunff_(jit_state_t *_jit, int eq,
-           jit_word_t i0, jit_int32_t r0, jit_float32_t i1)
+           jit_word_t i0, int32_t r0, jit_float32_t i1)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
     jit_word_t         w, d, j0, j1;
@@ -1533,11 +1533,11 @@ _swf_bunff_(jit_state_t *_jit, int eq,
 
 static jit_word_t
 _swf_bundd_(jit_state_t *_jit, int eq,
-           jit_word_t i0, jit_int32_t r0, jit_float64_t i1)
+           jit_word_t i0, int32_t r0, jit_float64_t i1)
 {
     jit_word_t         w, d, j0, j1;
     union {
-       jit_int32_t     i[2];
+       int32_t i[2];
        jit_float64_t   d;
     } data;
     jit_get_reg_args();
@@ -1619,7 +1619,7 @@ _swf_bundd_(jit_state_t *_jit, int eq,
 }
 
 static void
-_swf_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_extr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     jit_get_reg_args();
     movr(_R0_REGNO, r1);
@@ -1632,7 +1632,7 @@ _swf_extr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_extr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     jit_get_reg_args();
     movr(_R0_REGNO, r1);
@@ -1653,7 +1653,7 @@ _swf_extr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_extr_d_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_extr_d_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     jit_get_reg_args();
     if (jit_fpr_p(r1)) {
@@ -1677,7 +1677,7 @@ _swf_extr_d_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_extr_f_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     jit_get_reg_args();
     if (jit_fpr_p(r1))
@@ -1701,7 +1701,7 @@ _swf_extr_f_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_truncr_f_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
 #if !NAN_TO_INT_IS_ZERO
     jit_word_t         is_nan;
@@ -1755,7 +1755,7 @@ _swf_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_truncr_d_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
 #if !NAN_TO_INT_IS_ZERO
     jit_word_t         is_nan;
@@ -1819,9 +1819,9 @@ _swf_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_movr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 != r1) {
        if (jit_fpr_p(r1)) {
            reg = jit_get_reg(jit_class_gpr);
@@ -1840,9 +1840,9 @@ _swf_movr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_movr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 != r1) {
        if (jit_fpr_p(r1)) {
            if (!jit_thumb_p() && jit_armv5e_p() &&
@@ -1887,13 +1887,13 @@ _swf_movr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0)
+_swf_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t i0)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
-    jit_int32_t                reg;
+    int32_t            reg;
     data.f = i0;
     if (jit_fpr_p(r0)) {
        reg = jit_get_reg(jit_class_gpr);
@@ -1906,11 +1906,11 @@ _swf_movi_f(jit_state_t *_jit, jit_int32_t r0, 
jit_float32_t i0)
 }
 
 static void
-_swf_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0)
+_swf_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     union {
-       jit_int32_t     i[2];
+       int32_t i[2];
        jit_float64_t   d;
     } data;
     data.d = i0;
@@ -1938,9 +1938,9 @@ _swf_movi_d(jit_state_t *_jit, jit_int32_t r0, 
jit_float64_t i0)
 }
 
 static void
-_swf_absr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_absr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        reg = jit_get_reg(jit_class_gpr);
        swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
@@ -1963,9 +1963,9 @@ _swf_absr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_absr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
            r0 != r1 && (reg = jit_get_reg_pair()) != JIT_NOREG) {
@@ -2010,9 +2010,9 @@ _swf_absr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_negr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_negr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        reg = jit_get_reg(jit_class_gpr);
        swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
@@ -2035,9 +2035,9 @@ _swf_negr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_negr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
            r0 != r1 && (reg = jit_get_reg_pair()) != JIT_NOREG) {
@@ -2082,93 +2082,93 @@ _swf_negr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_swf_ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_ner_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     swf_iff(__aeabi_fcmpeq, r0, r1, r2);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_nei_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
+_swf_nei_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float32_t i0)
 {
     swf_iff_(__aeabi_fcmpeq, r0, r1, i0);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_ner_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     swf_idd(__aeabi_dcmpeq, r0, r1, r2);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_nei_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
+_swf_nei_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float64_t i0)
 {
     swf_idd_(__aeabi_dcmpeq, r0, r1, i0);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_ltgtr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     swf_iunff(__aeabi_fcmpeq, r0, r1, r2);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ltgti_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t 
i0)
+_swf_ltgti_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float32_t i0)
 {
     swf_iunff_(__aeabi_fcmpeq, r0, r1, i0);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_ltgtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     swf_iundd(__aeabi_dcmpeq, r0, r1, r2);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ltgti_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t 
i0)
+_swf_ltgti_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float64_t i0)
 {
     swf_iundd_(__aeabi_dcmpeq, r0, r1, i0);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_ordr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     swf_iff(__aeabi_fcmpun, r0, r1, r2);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ordi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float32_t 
i0)
+_swf_ordi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float32_t i0)
 {
     swf_iff_(__aeabi_fcmpun, r0, r1, i0);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_ordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     swf_idd(__aeabi_dcmpun, r0, r1, r2);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ordi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t 
i0)
+_swf_ordi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float64_t i0)
 {
     swf_idd_(__aeabi_dcmpun, r0, r1, i0);
     xori(r0, r0, 1);
 }
 
 static void
-_swf_ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_ldr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        reg = jit_get_reg(jit_class_gpr);
        ldxi_i(rn(reg), r1, 0);
@@ -2180,9 +2180,9 @@ _swf_ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_swf_ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_ldr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        if (!jit_thumb_p() && jit_armv5e_p() &&
            (reg = jit_get_reg_pair()) != JIT_NOREG) {
@@ -2208,9 +2208,9 @@ _swf_ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_swf_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_swf_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        reg = jit_get_reg(jit_class_gpr);
        ldi_i(rn(reg), i0);
@@ -2222,9 +2222,9 @@ _swf_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t 
i0)
 }
 
 static void
-_swf_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_swf_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
     if (jit_fpr_p(r0) && !jit_thumb_p() && jit_armv5e_p() &&
        (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
        movi(rn(rg0), i0);
@@ -2254,9 +2254,9 @@ _swf_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t 
i0)
 }
 
 static void
-_swf_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_ldxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        reg = jit_get_reg(jit_class_gpr);
        ldxr_i(rn(reg), r1, r2);
@@ -2268,9 +2268,9 @@ _swf_ldxr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 }
 
 static void
-_swf_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_ldxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
     if (jit_fpr_p(r0)) {
        if (!jit_thumb_p() && jit_armv5e_p() &&
            (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
@@ -2304,9 +2304,9 @@ _swf_ldxr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 }
 
 static void
-_swf_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_swf_ldxi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        reg = jit_get_reg(jit_class_gpr);
        ldxi_i(rn(reg), r1, i0);
@@ -2318,9 +2318,9 @@ _swf_ldxi_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_word_t i0)
 }
 
 static void
-_swf_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_swf_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
     if (jit_fpr_p(r0)) {
        if (!jit_thumb_p() && jit_armv5e_p() &&
            ((i0 >= 0 && i0 <= 255) || (i0 < 0 && i0 >= -255)) &&
@@ -2387,9 +2387,9 @@ _swf_ldxi_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_word_t i0)
 }
 
 static void
-_swf_str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_str_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        reg = jit_get_reg(jit_class_gpr);
        swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
@@ -2401,9 +2401,9 @@ _swf_str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_swf_str_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_str_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        if (!jit_thumb_p() && jit_armv5e_p() &&
            (reg = jit_get_reg_pair()) != JIT_NOREG) {
@@ -2431,9 +2431,9 @@ _swf_str_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_swf_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_swf_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        reg = jit_get_reg(jit_class_gpr);
        swf_ldrin(rn(reg), _FP_REGNO, swf_off(r0) + 8);
@@ -2445,9 +2445,9 @@ _swf_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0)
 }
 
 static void
-_swf_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_swf_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
     if (jit_fpr_p(r0)) {
        if (!jit_thumb_p() && jit_armv5e_p() &&
            (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
@@ -2484,9 +2484,9 @@ _swf_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0)
 }
 
 static void
-_swf_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_stxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r2)) {
        reg = jit_get_reg(jit_class_gpr);
        swf_ldrin(rn(reg), _FP_REGNO, swf_off(r2) + 8);
@@ -2498,9 +2498,9 @@ _swf_stxr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 }
 
 static void
-_swf_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_swf_stxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
     if (jit_fpr_p(r2)) {
        if (!jit_thumb_p() && jit_armv5e_p() &&
            (rg0 = jit_get_reg_pair()) != JIT_NOREG) {
@@ -2534,9 +2534,9 @@ _swf_stxr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 }
 
 static void
-_swf_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_swf_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        reg = jit_get_reg(jit_class_gpr);
        swf_ldrin(rn(reg), _FP_REGNO, swf_off(r1) + 8);
@@ -2548,9 +2548,9 @@ _swf_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_swf_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_swf_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
     if (jit_fpr_p(r1)) {
        if (!jit_thumb_p() && jit_armv5e_p() &&
            ((i0 >= 0 && i0 <= 255) || (i0 < 0 && i0 >= -255)) &&
@@ -2618,9 +2618,9 @@ _swf_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_swf_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_swf_vaarg_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     assert(_jitc->function->self.call & jit_call_varargs);
 
diff --git a/jit/arm-vfp.c b/jit/arm-vfp.c
index 2964ef4..d290727 100644
--- a/jit/arm-vfp.c
+++ b/jit/arm-vfp.c
@@ -467,25 +467,25 @@ static void _cc_vorsl(jit_state_t*,int,int,int,int,int);
 #  define CC_VSTR_F64(cc,r0,r1,i0)     
cc_vldst(cc,ARM_VSTR|ARM_V_F64|ARM_P,r0,r1,i0)
 #  define VSTR_F64(r0,r1,i0)           CC_VSTR_F64(ARM_CC_AL,r0,r1,i0)
 #  define vfp_movr_f(r0,r1)            _vfp_movr_f(_jit,r0,r1)
-static void _vfp_movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_movr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_movr_d(r0,r1)            _vfp_movr_d(_jit,r0,r1)
-static void _vfp_movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_movr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_movi_f(r0,i0)            _vfp_movi_f(_jit,r0,i0)
-static void _vfp_movi_f(jit_state_t*,jit_int32_t,jit_float32_t);
+static void _vfp_movi_f(jit_state_t*,int32_t,jit_float32_t);
 #  define vfp_movi_d(r0,i0)            _vfp_movi_d(_jit,r0,i0)
-static void _vfp_movi_d(jit_state_t*,jit_int32_t,jit_float64_t);
+static void _vfp_movi_d(jit_state_t*,int32_t,jit_float64_t);
 #  define vfp_extr_f(r0,r1)            _vfp_extr_f(_jit,r0,r1)
-static void _vfp_extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_extr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_extr_d(r0,r1)            _vfp_extr_d(_jit,r0,r1)
-static void _vfp_extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_extr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_extr_d_f(r0,r1)          _vfp_extr_d_f(_jit,r0,r1)
-static void _vfp_extr_d_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_extr_d_f(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_extr_f_d(r0,r1)          _vfp_extr_f_d(_jit,r0,r1)
-static void _vfp_extr_f_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_extr_f_d(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_truncr_f_i(r0,r1)                _vfp_truncr_f_i(_jit,r0,r1)
-static void _vfp_truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_truncr_f_i(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_truncr_d_i(r0,r1)                _vfp_truncr_d_i(_jit,r0,r1)
-static void _vfp_truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_truncr_d_i(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_absr_f(r0,r1)            VABS_F32(r0,r1)
 #  define vfp_absr_d(r0,r1)            VABS_F64(r0,r1)
 #  define vfp_negr_f(r0,r1)            VNEG_F32(r0,r1)
@@ -494,318 +494,318 @@ static void 
_vfp_truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
 #  define vfp_sqrtr_d(r0,r1)           VSQRT_F64(r0,r1)
 #  define vfp_addr_f(r0,r1,r2)         VADD_F32(r0,r1,r2)
 #  define vfp_addi_f(r0,r1,i0)         _vfp_addi_f(_jit,r0,r1,i0)
-static void _vfp_addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_addi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_addr_d(r0,r1,r2)         VADD_F64(r0,r1,r2)
 #  define vfp_addi_d(r0,r1,i0)         _vfp_addi_d(_jit,r0,r1,i0)
-static void _vfp_addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_addi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_subr_f(r0,r1,r2)         VSUB_F32(r0,r1,r2)
 #  define vfp_subi_f(r0,r1,i0)         _vfp_subi_f(_jit,r0,r1,i0)
-static void _vfp_subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_subi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_subr_d(r0,r1,r2)         VSUB_F64(r0,r1,r2)
 #  define vfp_subi_d(r0,r1,i0)         _vfp_subi_d(_jit,r0,r1,i0)
-static void _vfp_subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_subi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_rsbr_f(r0,r1,r2)         vfp_subr_f(r0,r2,r1)
 #  define vfp_rsbi_f(r0,r1,i0)         _vfp_rsbi_f(_jit,r0,r1,i0)
-static void _vfp_rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_rsbi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_rsbr_d(r0,r1,r2)         vfp_subr_d(r0,r2,r1)
 #  define vfp_rsbi_d(r0,r1,i0)         _vfp_rsbi_d(_jit,r0,r1,i0)
-static void _vfp_rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_rsbi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_mulr_f(r0,r1,r2)         VMUL_F32(r0,r1,r2)
 #  define vfp_muli_f(r0,r1,i0)         _vfp_muli_f(_jit,r0,r1,i0)
-static void _vfp_muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_muli_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_mulr_d(r0,r1,r2)         VMUL_F64(r0,r1,r2)
 #  define vfp_muli_d(r0,r1,i0)         _vfp_muli_d(_jit,r0,r1,i0)
-static void _vfp_muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_muli_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_divr_f(r0,r1,r2)         VDIV_F32(r0,r1,r2)
 #  define vfp_divi_f(r0,r1,i0)         _vfp_divi_f(_jit,r0,r1,i0)
-static void _vfp_divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_divi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_divr_d(r0,r1,r2)         VDIV_F64(r0,r1,r2)
 #  define vfp_divi_d(r0,r1,i0)         _vfp_divi_d(_jit,r0,r1,i0)
-static void _vfp_divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_divi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_cmp_f(r0,r1)             _vfp_cmp_f(_jit,r0,r1)
-static void _vfp_cmp_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_cmp_f(jit_state_t*,int32_t,jit_int32_t);
 #  define vfp_cmp_d(r0,r1)             _vfp_cmp_d(_jit,r0,r1)
-static void _vfp_cmp_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _vfp_cmp_d(jit_state_t*,int32_t,jit_int32_t);
 #  define vcmp01_x(c0,c1,r0)           _vcmp01_x(_jit,c0,c1,r0)
-static void _vcmp01_x(jit_state_t*,int,int,jit_int32_t);
+static void _vcmp01_x(jit_state_t*,int,int,int32_t);
 #  define vcmp01_f(c0,c1,r0,r1,r2)     _vcmp01_f(_jit,c0,c1,r0,r1,r2)
-static void 
_vcmp01_f(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vcmp01_f(jit_state_t*,int,int,int32_t,jit_int32_t,jit_int32_t);
 #  define vcmp01_d(c0,c1,r0,r1,r2)     _vcmp01_d(_jit,c0,c1,r0,r1,r2)
-static void 
_vcmp01_d(jit_state_t*,int,int,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vcmp01_d(jit_state_t*,int,int,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_ltr_f(r0,r1,r2)          vcmp01_f(ARM_CC_PL,ARM_CC_MI,r0,r1,r2)
 #  define vfp_lti_f(r0,r1,i0)          _vfp_lti_f(_jit,r0,r1,i0)
-static void _vfp_lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_lti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_ltr_d(r0,r1,r2)          vcmp01_d(ARM_CC_PL,ARM_CC_MI,r0,r1,r2)
 #  define vfp_lti_d(r0,r1,i0)          _vfp_lti_d(_jit,r0,r1,i0)
-static void _vfp_lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_lti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_ler_f(r0,r1,r2)          vcmp01_f(ARM_CC_HS,ARM_CC_LS,r0,r1,r2)
 #  define vfp_lei_f(r0,r1,i0)          _vfp_lei_f(_jit,r0,r1,i0)
-static void _vfp_lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_lei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_ler_d(r0,r1,r2)          vcmp01_d(ARM_CC_HS,ARM_CC_LS,r0,r1,r2)
 #  define vfp_lei_d(r0,r1,i0)          _vfp_lei_d(_jit,r0,r1,i0)
-static void _vfp_lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_lei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_eqr_f(r0,r1,r2)          vcmp01_f(ARM_CC_NE,ARM_CC_EQ,r0,r1,r2)
 #  define vfp_eqi_f(r0,r1,i0)          _vfp_eqi_f(_jit,r0,r1,i0)
-static void _vfp_eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_eqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_eqr_d(r0,r1,r2)          vcmp01_d(ARM_CC_NE,ARM_CC_EQ,r0,r1,r2)
 #  define vfp_eqi_d(r0,r1,i0)          _vfp_eqi_d(_jit,r0,r1,i0)
-static void _vfp_eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_eqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_ger_f(r0,r1,r2)          vcmp01_f(ARM_CC_LT,ARM_CC_GE,r0,r1,r2)
 #  define vfp_gei_f(r0,r1,i0)          _vfp_gei_f(_jit,r0,r1,i0)
-static void _vfp_gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_gei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_ger_d(r0,r1,r2)          vcmp01_d(ARM_CC_LT,ARM_CC_GE,r0,r1,r2)
 #  define vfp_gei_d(r0,r1,i0)          _vfp_gei_d(_jit,r0,r1,i0)
-static void _vfp_gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_gei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_gtr_f(r0,r1,r2)          vcmp01_f(ARM_CC_LE,ARM_CC_GT,r0,r1,r2)
 #  define vfp_gti_f(r0,r1,i0)          _vfp_gti_f(_jit,r0,r1,i0)
-static void _vfp_gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_gti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_gtr_d(r0,r1,r2)          vcmp01_d(ARM_CC_LE,ARM_CC_GT,r0,r1,r2)
 #  define vfp_gti_d(r0,r1,i0)          _vfp_gti_d(_jit,r0,r1,i0)
-static void _vfp_gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_gti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_ner_f(r0,r1,r2)          vcmp01_f(ARM_CC_EQ,ARM_CC_NE,r0,r1,r2)
 #  define vfp_nei_f(r0,r1,i0)          _vfp_nei_f(_jit,r0,r1,i0)
-static void _vfp_nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_nei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_ner_d(r0,r1,r2)          vcmp01_d(ARM_CC_EQ,ARM_CC_NE,r0,r1,r2)
 #  define vfp_nei_d(r0,r1,i0)          _vfp_nei_d(_jit,r0,r1,i0)
-static void _vfp_nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_nei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vcmp10_x(c0,r0)              _vcmp10_x(_jit,c0,r0)
-static void _vcmp10_x(jit_state_t*,int,jit_int32_t);
+static void _vcmp10_x(jit_state_t*,int,int32_t);
 #  define vcmp_10_f(c0,r0,r1,r2)       _vcmp_10_f(_jit,c0,r0,r1,r2)
-static void _vcmp_10_f(jit_state_t*,int,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vcmp_10_f(jit_state_t*,int,int32_t,jit_int32_t,jit_int32_t);
 #  define vcmp_10_d(c0,r0,r1,r2)       _vcmp_10_d(_jit,c0,r0,r1,r2)
-static void _vcmp_10_d(jit_state_t*,int,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vcmp_10_d(jit_state_t*,int,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_unltr_f(r0,r1,r2)                vcmp_10_f(ARM_CC_GE,r0,r1,r2)
 #  define vfp_unlti_f(r0,r1,i0)                _vfp_unlti_f(_jit,r0,r1,i0)
-static void _vfp_unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_unlti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_unltr_d(r0,r1,r2)                vcmp_10_d(ARM_CC_GE,r0,r1,r2)
 #  define vfp_unlti_d(r0,r1,i0)                _vfp_unlti_d(_jit,r0,r1,i0)
-static void _vfp_unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_unlti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_unler_f(r0,r1,r2)                vcmp_10_f(ARM_CC_GT,r0,r1,r2)
 #  define vfp_unlei_f(r0,r1,i0)                _vfp_unlei_f(_jit,r0,r1,i0)
-static void _vfp_unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_unlei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_unler_d(r0,r1,r2)                vcmp_10_d(ARM_CC_GT,r0,r1,r2)
 #  define vfp_unlei_d(r0,r1,i0)                _vfp_unlei_d(_jit,r0,r1,i0)
-static void _vfp_unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_unlei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_uneqr_x(r0)              _vfp_uneqr_x(_jit,r0)
-static void _vfp_uneqr_x(jit_state_t*,jit_int32_t);
+static void _vfp_uneqr_x(jit_state_t*,int32_t);
 #  define vfp_uneqr_f(r0,r1,r2)                _vfp_uneqr_f(_jit,r0,r1,r2)
-static void _vfp_uneqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_uneqr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_uneqi_f(r0,r1,i0)                _vfp_uneqi_f(_jit,r0,r1,i0)
-static void _vfp_uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_uneqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_uneqr_d(r0,r1,r2)                _vfp_uneqr_d(_jit,r0,r1,r2)
-static void _vfp_uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_uneqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_uneqi_d(r0,r1,i0)                _vfp_uneqi_d(_jit,r0,r1,i0)
-static void _vfp_uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_uneqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vcmp_01_x(c0,r0)             _vcmp_01_x(_jit,c0,r0)
-static void _vcmp_01_x(jit_state_t*,int,jit_int32_t);
+static void _vcmp_01_x(jit_state_t*,int,int32_t);
 #  define vcmp_01_f(c0,r0,r1,r2)       _vcmp_01_f(_jit,c0,r0,r1,r2)
-static void _vcmp_01_f(jit_state_t*,int,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vcmp_01_f(jit_state_t*,int,int32_t,jit_int32_t,jit_int32_t);
 #  define vcmp_01_d(c0,r0,r1,r2)       _vcmp_01_d(_jit,c0,r0,r1,r2)
-static void _vcmp_01_d(jit_state_t*,int,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vcmp_01_d(jit_state_t*,int,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_unger_f(r0,r1,r2)                vcmp_01_f(ARM_CC_CS,r0,r1,r2)
 #  define vfp_ungei_f(r0,r1,i0)                _vfp_ungei_f(_jit,r0,r1,i0)
-static void _vfp_ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_ungei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_unger_d(r0,r1,r2)                vcmp_01_d(ARM_CC_CS,r0,r1,r2)
 #  define vfp_ungei_d(r0,r1,i0)                _vfp_ungei_d(_jit,r0,r1,i0)
-static void _vfp_ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_ungei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_ungtr_f(r0,r1,r2)                vcmp_01_f(ARM_CC_HI,r0,r1,r2)
 #  define vfp_ungti_f(r0,r1,i0)                _vfp_ungti_f(_jit,r0,r1,i0)
-static void _vfp_ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_ungti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_ungtr_d(r0,r1,r2)                vcmp_01_d(ARM_CC_HI,r0,r1,r2)
 #  define vfp_ungti_d(r0,r1,i0)                _vfp_ungti_d(_jit,r0,r1,i0)
-static void _vfp_ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_ungti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_ltgtr_x(r0)              _vfp_ltgtr_x(_jit,r0)
-static void _vfp_ltgtr_x(jit_state_t*,jit_int32_t);
+static void _vfp_ltgtr_x(jit_state_t*,int32_t);
 #  define vfp_ltgtr_f(r0,r1,r2)                _vfp_ltgtr_f(_jit,r0,r1,r2)
-static void _vfp_ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_ltgtr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_ltgti_f(r0,r1,i0)                _vfp_ltgti_f(_jit,r0,r1,i0)
-static void _vfp_ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_ltgti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_ltgtr_d(r0,r1,r2)                _vfp_ltgtr_d(_jit,r0,r1,r2)
-static void _vfp_ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_ltgtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_ltgti_d(r0,r1,i0)                _vfp_ltgti_d(_jit,r0,r1,i0)
-static void _vfp_ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_ltgti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_ordr_f(r0,r1,r2)         _vfp_ordr_f(_jit,r0,r1,r2)
-static void _vfp_ordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_ordr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_ordi_f(r0,r1,i0)         _vfp_ordi_f(_jit,r0,r1,i0)
-static void _vfp_ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_ordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_ordr_d(r0,r1,r2)         _vfp_ordr_d(_jit,r0,r1,r2)
-static void _vfp_ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_ordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_ordi_d(r0,r1,i0)         _vfp_ordi_d(_jit,r0,r1,i0)
-static void _vfp_ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_ordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vfp_unordr_f(r0,r1,r2)       _vfp_unordr_f(_jit,r0,r1,r2)
-static void _vfp_unordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_unordr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_unordi_f(r0,r1,i0)       _vfp_unordi_f(_jit,r0,r1,i0)
-static void _vfp_unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
+static void _vfp_unordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t);
 #  define vfp_unordr_d(r0,r1,r2)       _vfp_unordr_d(_jit,r0,r1,r2)
-static void _vfp_unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_unordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_unordi_d(r0,r1,i0)       _vfp_unordi_d(_jit,r0,r1,i0)
-static void _vfp_unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
+static void _vfp_unordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t);
 #  define vbcmp_x(cc,i0)               _vbcmp_x(_jit,cc,i0)
 static jit_word_t _vbcmp_x(jit_state_t*,int,jit_word_t);
 #  define vbcmp_f(cc,i0,r0,r1)         _vbcmp_f(_jit,cc,i0,r0,r1)
 static jit_word_t
-_vbcmp_f(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
+_vbcmp_f(jit_state_t*,int,jit_word_t,int32_t,jit_int32_t);
 #  define vbcmp_x(cc,i0)               _vbcmp_x(_jit,cc,i0)
 static jit_word_t _vbcmp_x(jit_state_t*,int,jit_word_t);
 #  define vbcmp_d(cc,i0,r0,r1)         _vbcmp_d(_jit,cc,i0,r0,r1)
 static jit_word_t
-_vbcmp_d(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
+_vbcmp_d(jit_state_t*,int,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_bltr_f(i0,r0,r1)         vbcmp_f(ARM_CC_MI,i0,r0,r1)
 #  define vfp_blti_f(i0,r0,i1)         _vfp_blti_f(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+static jit_word_t _vfp_blti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bltr_d(i0,r0,r1)         vbcmp_d(ARM_CC_MI,i0,r0,r1)
-static jit_word_t 
_vfp_blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+static jit_word_t _vfp_blti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_blti_d(i0,r0,i1)         _vfp_blti_d(_jit,i0,r0,i1)
 #  define vfp_bler_f(i0,r0,r1)         vbcmp_f(ARM_CC_LS,i0,r0,r1)
 #  define vfp_blei_f(i0,r0,i1)         _vfp_blei_f(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+static jit_word_t _vfp_blei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bler_d(i0,r0,r1)         vbcmp_d(ARM_CC_LS,i0,r0,r1)
 #  define vfp_blei_d(i0,r0,i1)         _vfp_blei_d(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+static jit_word_t _vfp_blei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_beqr_f(i0,r0,r1)         vbcmp_f(ARM_CC_EQ,i0,r0,r1)
 #  define vfp_beqi_f(i0,r0,i1)         _vfp_beqi_f(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+static jit_word_t _vfp_beqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_beqr_d(i0,r0,r1)         vbcmp_d(ARM_CC_EQ,i0,r0,r1)
 #  define vfp_beqi_d(i0,r0,i1)         _vfp_beqi_d(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+static jit_word_t _vfp_beqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bger_f(i0,r0,r1)         vbcmp_f(ARM_CC_GE,i0,r0,r1)
 #  define vfp_bgei_f(i0,r0,i1)         _vfp_bgei_f(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+static jit_word_t _vfp_bgei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bger_d(i0,r0,r1)         vbcmp_d(ARM_CC_GE,i0,r0,r1)
 #  define vfp_bgei_d(i0,r0,i1)         _vfp_bgei_d(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+static jit_word_t _vfp_bgei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bgtr_f(i0,r0,r1)         vbcmp_f(ARM_CC_GT,i0,r0,r1)
 #  define vfp_bgti_f(i0,r0,i1)         _vfp_bgti_f(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+static jit_word_t _vfp_bgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bgtr_d(i0,r0,r1)         vbcmp_d(ARM_CC_GT,i0,r0,r1)
 #  define vfp_bgti_d(i0,r0,i1)         _vfp_bgti_d(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+static jit_word_t _vfp_bgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bner_f(i0,r0,r1)         vbcmp_f(ARM_CC_NE,i0,r0,r1)
 #  define vfp_bnei_f(i0,r0,i1)         _vfp_bnei_f(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+static jit_word_t _vfp_bnei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bner_d(i0,r0,r1)         vbcmp_d(ARM_CC_NE,i0,r0,r1)
 #  define vfp_bnei_d(i0,r0,i1)         _vfp_bnei_d(_jit,i0,r0,i1)
-static jit_word_t 
_vfp_bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+static jit_word_t _vfp_bnei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vbncmp_x(cc,i0)              _vbncmp_x(_jit,cc,i0)
 static jit_word_t _vbncmp_x(jit_state_t*,int,jit_word_t);
 #  define vbncmp_f(cc,i0,r0,r1)                _vbncmp_f(_jit,cc,i0,r0,r1)
 static jit_word_t
-_vbncmp_f(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
+_vbncmp_f(jit_state_t*,int,jit_word_t,int32_t,jit_int32_t);
 #  define vbncmp_d(cc,i0,r0,r1)                _vbncmp_d(_jit,cc,i0,r0,r1)
 static jit_word_t
-_vbncmp_d(jit_state_t*,int,jit_word_t,jit_int32_t,jit_int32_t);
+_vbncmp_d(jit_state_t*,int,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_bunltr_f(i0,r0,r1)       vbncmp_f(ARM_CC_GE,i0,r0,r1)
 #  define vfp_bunlti_f(i0,r0,i1)       _vfp_bunlti_f(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+_vfp_bunlti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bunltr_d(i0,r0,r1)       vbncmp_d(ARM_CC_GE,i0,r0,r1)
 #  define vfp_bunlti_d(i0,r0,i1)       _vfp_bunlti_d(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+_vfp_bunlti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bunler_f(i0,r0,r1)       vbncmp_f(ARM_CC_GT,i0,r0,r1)
 #  define vfp_bunlei_f(i0,r0,i1)       _vfp_bunlei_f(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+_vfp_bunlei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bunler_d(i0,r0,r1)       vbncmp_d(ARM_CC_GT,i0,r0,r1)
 #  define vfp_bunlei_d(i0,r0,i1)       _vfp_bunlei_d(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+_vfp_bunlei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_buneqr_x(i0)             _vfp_buneqr_x(_jit,i0)
 static jit_word_t _vfp_buneqr_x(jit_state_t*,jit_word_t);
 #  define vfp_buneqr_f(i0,r0,r1)       _vfp_buneqr_f(_jit,i0,r0,r1)
 static jit_word_t
-_vfp_buneqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+_vfp_buneqr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_buneqi_f(i0,r0,i1)       _vfp_buneqi_f(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+_vfp_buneqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_buneqr_d(i0,r0,r1)       _vfp_buneqr_d(_jit,i0,r0,r1)
 static jit_word_t
-_vfp_buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+_vfp_buneqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_buneqi_d(i0,r0,i1)       _vfp_buneqi_d(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+_vfp_buneqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bunger_x(i0)             _vfp_bunger_x(_jit,i0)
 static jit_word_t _vfp_bunger_x(jit_state_t*,jit_word_t);
 #  define vfp_bunger_f(i0,r0,r1)       _vfp_bunger_f(_jit,i0,r0,r1)
 static jit_word_t
-_vfp_bunger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+_vfp_bunger_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_bungei_f(i0,r0,i1)       _vfp_bungei_f(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+_vfp_bungei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bunger_d(i0,r0,r1)       _vfp_bunger_d(_jit,i0,r0,r1)
 static jit_word_t
-_vfp_bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+_vfp_bunger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_bungei_d(i0,r0,i1)       _vfp_bungei_d(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+_vfp_bungei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bungtr_f(i0,r0,r1)       vbcmp_f(ARM_CC_HI,i0,r0,r1)
 #  define vfp_bungti_f(i0,r0,i1)       _vfp_bungti_f(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+_vfp_bungti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bungtr_d(i0,r0,r1)       vbcmp_d(ARM_CC_HI,i0,r0,r1)
 #  define vfp_bungti_d(i0,r0,i1)       _vfp_bungti_d(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+_vfp_bungti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bltgtr_x(i0)             _vfp_bltgtr_x(_jit,i0)
 static jit_word_t _vfp_bltgtr_x(jit_state_t*,jit_word_t);
 #  define vfp_bltgtr_f(i0,r0,r1)       _vfp_bltgtr_f(_jit,i0,r0,r1)
 static jit_word_t
-_vfp_bltgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+_vfp_bltgtr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_bltgti_f(i0,r0,i1)       _vfp_bltgti_f(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+_vfp_bltgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bltgtr_d(i0,r0,r1)       _vfp_bltgtr_d(_jit,i0,r0,r1)
 static jit_word_t
-_vfp_bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+_vfp_bltgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_bltgti_d(i0,r0,i1)       _vfp_bltgti_d(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+_vfp_bltgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bordr_f(i0,r0,r1)                vbcmp_f(ARM_CC_VC,i0,r0,r1)
 #  define vfp_bordi_f(i0,r0,i1)                _vfp_bordi_f(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+_vfp_bordi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bordr_d(i0,r0,r1)                vbcmp_d(ARM_CC_VC,i0,r0,r1)
 #  define vfp_bordi_d(i0,r0,i1)                _vfp_bordi_d(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+_vfp_bordi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_bunordr_f(i0,r0,r1)      vbcmp_f(ARM_CC_VS,i0,r0,r1)
 #  define vfp_bunordi_f(i0,r0,i1)      _vfp_bunordi_f(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
+_vfp_bunordi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t);
 #  define vfp_bunordr_d(i0,r0,r1)      vbcmp_d(ARM_CC_VS,i0,r0,r1)
 #  define vfp_bunordi_d(i0,r0,i1)      _vfp_bunordi_d(_jit,i0,r0,i1)
 static jit_word_t
-_vfp_bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
+_vfp_bunordi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t);
 #  define vfp_ldr_f(r0,r1)             VLDR_F32(r0,r1,0)
 #  define vfp_ldr_d(r0,r1)             VLDR_F64(r0,r1,0)
 #  define vfp_ldi_f(r0,i0)             _vfp_ldi_f(_jit,r0,i0)
-static void _vfp_ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+static void _vfp_ldi_f(jit_state_t*,int32_t,jit_word_t);
 #  define vfp_ldi_d(r0,i0)             _vfp_ldi_d(_jit,r0,i0)
-static void _vfp_ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+static void _vfp_ldi_d(jit_state_t*,int32_t,jit_word_t);
 #  define vfp_ldxr_f(r0,r1,r2)         _vfp_ldxr_f(_jit,r0,r1,r2)
-static void _vfp_ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_ldxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_ldxr_d(r0,r1,r2)         _vfp_ldxr_d(_jit,r0,r1,r2)
-static void _vfp_ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_ldxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_ldxi_f(r0,r1,i0)         _vfp_ldxi_f(_jit,r0,r1,i0)
-static void _vfp_ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _vfp_ldxi_f(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define vfp_ldxi_d(r0,r1,i0)         _vfp_ldxi_d(_jit,r0,r1,i0)
-static void _vfp_ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _vfp_ldxi_d(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define vfp_str_f(r0,r1)             VSTR_F32(r1,r0,0)
 #  define vfp_str_d(r0,r1)             VSTR_F64(r1,r0,0)
 #  define vfp_sti_f(i0,r0)             _vfp_sti_f(_jit,i0,r0)
-static void _vfp_sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+static void _vfp_sti_f(jit_state_t*,jit_word_t,int32_t);
 #  define vfp_sti_d(i0,r0)             _vfp_sti_d(_jit,i0,r0)
-static void _vfp_sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+static void _vfp_sti_d(jit_state_t*,jit_word_t,int32_t);
 #  define vfp_stxr_f(r0,r1,r2)         _vfp_stxr_f(_jit,r0,r1,r2)
-static void _vfp_stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_stxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_stxr_d(r0,r1,r2)         _vfp_stxr_d(_jit,r0,r1,r2)
-static void _vfp_stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _vfp_stxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define vfp_stxi_f(i0,r0,r1)         _vfp_stxi_f(_jit,i0,r0,r1)
-static void _vfp_stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _vfp_stxi_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_stxi_d(i0,r0,r1)         _vfp_stxi_d(_jit,i0,r0,r1)
-static void _vfp_stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _vfp_stxi_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vfp_vaarg_d(r0, r1)          _vfp_vaarg_d(_jit, r0, r1)
-static void _vfp_vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vfp_vaarg_d(jit_state_t*, int32_t, jit_int32_t);
 #endif
 
 #if CODE
@@ -1205,7 +1205,7 @@ _cc_vorsl(jit_state_t *_jit, int cc, int o, int r0, int 
r1, int i0)
 }
 
 static void
-_vfp_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_movr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1) {
        if (jit_fpr_p(r1)) {
@@ -1222,7 +1222,7 @@ _vfp_movr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_vfp_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_movr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1) {
        if (jit_fpr_p(r1)) {
@@ -1243,14 +1243,14 @@ _vfp_movr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_vfp_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0)
+_vfp_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t i0)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } u;
-    jit_int32_t                reg;
-    jit_int32_t                code;
+    int32_t            reg;
+    int32_t            code;
     u.f = i0;
     if (jit_fpr_p(r0)) {
        /* float arguments are packed, for others,
@@ -1271,14 +1271,14 @@ _vfp_movi_f(jit_state_t *_jit, jit_int32_t r0, 
jit_float32_t i0)
 }
 
 static void
-_vfp_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0)
+_vfp_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t i0)
 {
     union {
-       jit_int32_t     i[2];
+       int32_t i[2];
        jit_float64_t   d;
     } u;
-    jit_int32_t                code;
-    jit_int32_t                rg0, rg1;
+    int32_t            code;
+    int32_t            rg0, rg1;
     u.d = i0;
     if (jit_fpr_p(r0)) {
        if ((code = encode_vfp_double(1, 0, u.i[0], u.i[1])) != -1 ||
@@ -1301,9 +1301,9 @@ _vfp_movi_d(jit_state_t *_jit, jit_int32_t r0, 
jit_float64_t i0)
 }
 
 static void
-_vfp_extr_d_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_extr_d_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        if (jit_fpr_p(r0))
            VCVT_F64_F32(r0, r1);
@@ -1327,9 +1327,9 @@ _vfp_extr_d_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_vfp_extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_extr_f_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        if (jit_fpr_p(r0))
            VCVT_F32_F64(r0, r1);
@@ -1353,9 +1353,9 @@ _vfp_extr_f_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_vfp_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_extr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        VMOV_V_I32(r0, r1);
        VCVT_F32_S32(r0, r0);
@@ -1370,9 +1370,9 @@ _vfp_extr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_vfp_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_extr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        VMOV_V_I32(r0, r1);
        VCVT_F64_S32(r0, r0);
@@ -1387,9 +1387,9 @@ _vfp_extr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_vfp_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_truncr_f_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     if (jit_fpr_p(r1))
        VCVT_S32_F32(rn(reg), r1);
@@ -1402,9 +1402,9 @@ _vfp_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_vfp_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_truncr_d_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     if (jit_fpr_p(r1))
        VCVT_S32_F64(rn(reg), r1);
@@ -1419,9 +1419,9 @@ _vfp_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 #  define fopi(name)                                                   \
 static void                                                            \
 _vfp_##name##i_f(jit_state_t *_jit,                                    \
-                jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)      \
+                int32_t r0, jit_int32_t r1, jit_float32_t i0)  \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     vfp_movi_f(rn(reg), i0);                                           \
     vfp_##name##r_f(r0, r1, rn(reg));                                  \
     jit_unget_reg(reg);                                                        
\
@@ -1429,9 +1429,9 @@ _vfp_##name##i_f(jit_state_t *_jit,                       
                \
 #  define dopi(name)                                                   \
 static void                                                            \
 _vfp_##name##i_d(jit_state_t *_jit,                                    \
-                jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)      \
+                int32_t r0, jit_int32_t r1, jit_float64_t i0)  \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     vfp_movi_d(rn(reg), i0);                                           \
     vfp_##name##r_d(r0, r1, rn(reg));                                  \
     jit_unget_reg(reg);                                                        
\
@@ -1439,10 +1439,10 @@ _vfp_##name##i_d(jit_state_t *_jit,                     
                \
 #  define fbopi(name)                                                  \
 static jit_word_t                                                      \
 _vfp_b##name##i_f(jit_state_t *_jit,                                   \
-                 jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)     \
+                 int32_t r0, jit_int32_t r1, jit_float32_t i0) \
 {                                                                      \
     jit_word_t         word;                                           \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr|                
\
+    int32_t            reg = jit_get_reg(jit_class_fpr|                \
                                          jit_class_nospill);           \
     vfp_movi_f(rn(reg), i0);                                           \
     word = vfp_b##name##r_f(r0, r1, rn(reg));                          \
@@ -1452,10 +1452,10 @@ _vfp_b##name##i_f(jit_state_t *_jit,                    
                \
 #  define dbopi(name)                                                  \
 static jit_word_t                                                      \
 _vfp_b##name##i_d(jit_state_t *_jit,                                   \
-                 jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)     \
+                 int32_t r0, jit_int32_t r1, jit_float64_t i0) \
 {                                                                      \
     jit_word_t         word;                                           \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr|                
\
+    int32_t            reg = jit_get_reg(jit_class_fpr|                \
                                          jit_class_nospill);           \
     vfp_movi_d(rn(reg), i0);                                           \
     word = vfp_b##name##r_d(r0, r1, rn(reg));                          \
@@ -1475,9 +1475,9 @@ fopi(div)
 dopi(div)
 
 static void
-_vfp_cmp_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_cmp_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
     if (jit_fpr_p(r0)) {
        if (jit_fpr_p(r1))
            VCMP_F32(r0, r1);
@@ -1504,9 +1504,9 @@ _vfp_cmp_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_vfp_cmp_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_cmp_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                rg0, rg1;
+    int32_t            rg0, rg1;
     if (jit_fpr_p(r0)) {
        if (jit_fpr_p(r1))
            VCMP_F64(r0, r1);
@@ -1533,7 +1533,7 @@ _vfp_cmp_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_vcmp01_x(jit_state_t *_jit, int c0, int c1, jit_int32_t r0)
+_vcmp01_x(jit_state_t *_jit, int c0, int c1, int32_t r0)
 {
     VMRS(_R15_REGNO);
     if (jit_thumb_p()) {
@@ -1571,7 +1571,7 @@ _vcmp01_x(jit_state_t *_jit, int c0, int c1, jit_int32_t 
r0)
 
 static void
 _vcmp01_f(jit_state_t *_jit, int c0, int c1,
-         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+         int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_f(r1, r2);
     vcmp01_x(c0, c1, r0);
@@ -1579,14 +1579,14 @@ _vcmp01_f(jit_state_t *_jit, int c0, int c1,
 
 static void
 _vcmp01_d(jit_state_t *_jit, int c0, int c1,
-         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+         int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_d(r1, r2);
     vcmp01_x(c0, c1, r0);
 }
 
 static void
-_vcmp10_x(jit_state_t *_jit, int cc, jit_int32_t r0)
+_vcmp10_x(jit_state_t *_jit, int cc, int32_t r0)
 {
     if (jit_thumb_p()) {
        if (r0 < 8) {
@@ -1610,7 +1610,7 @@ _vcmp10_x(jit_state_t *_jit, int cc, jit_int32_t r0)
 }
 static void
 _vcmp_10_f(jit_state_t *_jit, int cc,
-          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+          int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_f(r1, r2);
     vcmp10_x(cc, r0);
@@ -1618,7 +1618,7 @@ _vcmp_10_f(jit_state_t *_jit, int cc,
 
 static void
 _vcmp_10_d(jit_state_t *_jit, int cc,
-          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+          int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_d(r1, r2);
     vcmp10_x(cc, r0);
@@ -1642,7 +1642,7 @@ fopi(unle)
 dopi(unle)
 
 static void
-_vfp_uneqr_x(jit_state_t *_jit, jit_int32_t r0)
+_vfp_uneqr_x(jit_state_t *_jit, int32_t r0)
 {
     VMRS(_R15_REGNO);
     if (jit_thumb_p()) {
@@ -1668,7 +1668,7 @@ _vfp_uneqr_x(jit_state_t *_jit, jit_int32_t r0)
 }
 
 static void
-_vfp_uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_uneqr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_f(r1, r2);
     vfp_uneqr_x(r0);
@@ -1677,7 +1677,7 @@ _vfp_uneqr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 fopi(uneq)
 
 static void
-_vfp_uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_uneqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_d(r1, r2);
     vfp_uneqr_x(r0);
@@ -1686,7 +1686,7 @@ _vfp_uneqr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 dopi(uneq)
 
 static void
-_vcmp_01_x(jit_state_t *_jit, int cc, jit_int32_t r0)
+_vcmp_01_x(jit_state_t *_jit, int cc, int32_t r0)
 {
     if (jit_thumb_p()) {
        if (r0 < 8) {
@@ -1711,7 +1711,7 @@ _vcmp_01_x(jit_state_t *_jit, int cc, jit_int32_t r0)
 
 static void
 _vcmp_01_f(jit_state_t *_jit, int cc,
-          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+          int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_f(r1, r2);
     vcmp_01_x(cc, r0);
@@ -1719,7 +1719,7 @@ _vcmp_01_f(jit_state_t *_jit, int cc,
 
 static void
 _vcmp_01_d(jit_state_t *_jit, int cc,
-          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+          int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_d(r1, r2);
     vcmp_01_x(cc, r0);
@@ -1731,7 +1731,7 @@ fopi(ungt)
 dopi(ungt)
 
 static void
-_vfp_ltgtr_x(jit_state_t *_jit, jit_int32_t r0)
+_vfp_ltgtr_x(jit_state_t *_jit, int32_t r0)
 {
     VMRS(_R15_REGNO);
     if (jit_thumb_p()) {
@@ -1757,7 +1757,7 @@ _vfp_ltgtr_x(jit_state_t *_jit, jit_int32_t r0)
 }
 
 static void
-_vfp_ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_ltgtr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_f(r1, r2);
     vfp_ltgtr_x(r0);
@@ -1766,7 +1766,7 @@ _vfp_ltgtr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 fopi(ltgt)
 
 static void
-_vfp_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_ltgtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_d(r1, r2);
     vfp_ltgtr_x(r0);
@@ -1775,7 +1775,7 @@ _vfp_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 dopi(ltgt)
 
 static void
-_vfp_ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_ordr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_f(r1, r2);
     vcmp10_x(ARM_CC_VS, r0);
@@ -1784,7 +1784,7 @@ _vfp_ordr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 fopi(ord)
 
 static void
-_vfp_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_ordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_d(r1, r2);
     vcmp10_x(ARM_CC_VS, r0);
@@ -1793,7 +1793,7 @@ _vfp_ordr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 dopi(ord)
 
 static void
-_vfp_unordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t 
r2)
+_vfp_unordr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_f(r1, r2);
     vcmp_01_x(ARM_CC_VS, r0);
@@ -1802,7 +1802,7 @@ _vfp_unordr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 fopi(unord)
 
 static void
-_vfp_unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t 
r2)
+_vfp_unordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     vfp_cmp_d(r1, r2);
     vcmp_01_x(ARM_CC_VS, r0);
@@ -1832,7 +1832,7 @@ _vbcmp_x(jit_state_t *_jit, int cc, jit_word_t i0)
 
 static jit_word_t
 _vbcmp_f(jit_state_t *_jit, int cc,
-        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+        jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_f(r0, r1);
     return (vbcmp_x(cc, i0));
@@ -1840,7 +1840,7 @@ _vbcmp_f(jit_state_t *_jit, int cc,
 
 static jit_word_t
 _vbcmp_d(jit_state_t *_jit, int cc,
-        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+        jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_d(r0, r1);
     return (vbcmp_x(cc, i0));
@@ -1872,7 +1872,7 @@ _vbncmp_x(jit_state_t *_jit, int cc, jit_word_t i0)
 
 static jit_word_t
 _vbncmp_f(jit_state_t *_jit, int cc,
-         jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+         jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_f(r0, r1);
     return (vbncmp_x(cc, i0));
@@ -1880,7 +1880,7 @@ _vbncmp_f(jit_state_t *_jit, int cc,
 
 static jit_word_t
 _vbncmp_d(jit_state_t *_jit, int cc,
-         jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+         jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_d(r0, r1);
     return (vbncmp_x(cc, i0));
@@ -1934,7 +1934,7 @@ _vfp_buneqr_x(jit_state_t *_jit, jit_word_t i0)
 }
 
 static jit_word_t
-_vfp_buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_vfp_buneqr_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_f(r0, r1);
     return (vfp_buneqr_x(i0));
@@ -1943,7 +1943,7 @@ _vfp_buneqr_f(jit_state_t *_jit, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 fbopi(uneq)
 
 static jit_word_t
-_vfp_buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_vfp_buneqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_d(r0, r1);
     return (vfp_buneqr_x(i0));
@@ -1976,7 +1976,7 @@ _vfp_bunger_x(jit_state_t *_jit, jit_word_t i0)
 }
 
 static jit_word_t
-_vfp_bunger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_vfp_bunger_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_f(r0, r1);
     return (vfp_bunger_x(i0));
@@ -1985,7 +1985,7 @@ _vfp_bunger_f(jit_state_t *_jit, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 fbopi(unge)
 
 static jit_word_t
-_vfp_bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_vfp_bunger_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_d(r0, r1);
     return (vfp_bunger_x(i0));
@@ -2023,7 +2023,7 @@ _vfp_bltgtr_x(jit_state_t *_jit, jit_word_t i0)
 }
 
 static jit_word_t
-_vfp_bltgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_vfp_bltgtr_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_f(r0, r1);
     return (vfp_bltgtr_x(i0));
@@ -2034,7 +2034,7 @@ dbopi(ungt)
 fbopi(ltgt)
 
 static jit_word_t
-_vfp_bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_vfp_bltgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     vfp_cmp_d(r0, r1);
     return (vfp_bltgtr_x(i0));
@@ -2047,9 +2047,9 @@ fbopi(unord)
 dbopi(unord)
 
 static void
-_vfp_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_vfp_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                gpr;
+    int32_t            gpr;
     if (jit_fpr_p(r0)) {
        gpr = jit_get_reg(jit_class_gpr);
        movi(rn(gpr), i0);
@@ -2061,9 +2061,9 @@ _vfp_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t 
i0)
 }
 
 static void
-_vfp_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_vfp_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_fpr_p(r0))
@@ -2076,9 +2076,9 @@ _vfp_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t 
i0)
 }
 
 static void
-_vfp_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_ldxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        reg = jit_get_reg(jit_class_gpr);
        addr(rn(reg), r1, r2);
@@ -2090,9 +2090,9 @@ _vfp_ldxr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 }
 
 static void
-_vfp_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_ldxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     if (jit_fpr_p(r0))
@@ -2105,9 +2105,9 @@ _vfp_ldxr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 }
 
 static void
-_vfp_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_vfp_ldxi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        if (i0 >= 0) {
            assert(!(i0 & 3));
@@ -2138,9 +2138,9 @@ _vfp_ldxi_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_word_t i0)
 }
 
 static void
-_vfp_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_vfp_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        if (i0 >= 0) {
            assert(!(i0 & 3));
@@ -2176,9 +2176,9 @@ _vfp_ldxi_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_word_t i0)
 }
 
 static void
-_vfp_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_vfp_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r0)) {
        reg = jit_get_reg(jit_class_gpr);
        movi(rn(reg), i0);
@@ -2190,9 +2190,9 @@ _vfp_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0)
 }
 
 static void
-_vfp_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_vfp_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     if (jit_fpr_p(r0))
@@ -2205,9 +2205,9 @@ _vfp_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0)
 }
 
 static void
-_vfp_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_stxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r2)) {
        reg = jit_get_reg(jit_class_gpr);
        addr(rn(reg), r0, r1);
@@ -2219,9 +2219,9 @@ _vfp_stxr_f(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 }
 
 static void
-_vfp_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_vfp_stxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     if (jit_fpr_p(r2))
@@ -2234,9 +2234,9 @@ _vfp_stxr_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_int32_t r2)
 }
 
 static void
-_vfp_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_vfp_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        if (i0 >= 0) {
            assert(!(i0 & 3));
@@ -2267,9 +2267,9 @@ _vfp_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_vfp_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_vfp_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_fpr_p(r1)) {
        if (i0 >= 0) {
            assert(!(i0 & 3));
@@ -2305,9 +2305,9 @@ _vfp_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_vfp_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vfp_vaarg_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     assert(_jitc->function->self.call & jit_call_varargs);
 
diff --git a/jit/arm.c b/jit/arm.c
index ee98c47..9aeff94 100644
--- a/jit/arm.c
+++ b/jit/arm.c
@@ -50,8 +50,8 @@
  * Types
  */
 typedef union _jit_thumb_t {
-    jit_int32_t                i;
-    jit_int16_t                s[2];
+    int32_t            i;
+    int16_t            s[2];
 } jit_thumb_t;
 
 typedef jit_pointer_t  jit_va_list;
@@ -66,13 +66,13 @@ static jit_node_t 
*_jit_make_arg_f(jit_state_t*,jit_node_t*);
 #define jit_make_arg_d(node)           _jit_make_arg_d(_jit,node)
 static jit_node_t *_jit_make_arg_d(jit_state_t*,jit_node_t*);
 #define jit_get_reg_pair()             _jit_get_reg_pair(_jit)
-static jit_int32_t _jit_get_reg_pair(jit_state_t*);
+static int32_t _jit_get_reg_pair(jit_state_t*);
 #define jit_unget_reg_pair(rn)         _jit_unget_reg_pair(_jit,rn)
-static void _jit_unget_reg_pair(jit_state_t*,jit_int32_t);
+static void _jit_unget_reg_pair(jit_state_t*,int32_t);
 # define must_align_p(node)            _must_align_p(_jit, node)
 static jit_bool_t _must_align_p(jit_state_t*,jit_node_t*);
 #define load_const(uniq,r0,i0)         _load_const(_jit,uniq,r0,i0)
-static void _load_const(jit_state_t*,jit_bool_t,jit_int32_t,jit_word_t);
+static void _load_const(jit_state_t*,jit_bool_t,int32_t,jit_word_t);
 #define flush_consts()                 _flush_consts(_jit)
 static void _flush_consts(jit_state_t*);
 #define invalidate_consts()            _invalidate_consts(_jit)
@@ -206,7 +206,7 @@ jit_get_cpu(void)
 void
 _jit_init(jit_state_t *_jit)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     static jit_bool_t  first = 1;
 
     _jitc->reglen = jit_size(_rvs) - 1;
@@ -229,7 +229,7 @@ _jit_init(jit_state_t *_jit)
 void
 _jit_prolog(jit_state_t *_jit)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
 
     if (_jitc->function)
        jit_epilog();
@@ -255,7 +255,7 @@ _jit_prolog(jit_state_t *_jit)
        _jitc->function->self.aoff = 0;
     _jitc->function->self.call = jit_call_default;
     jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
-             _jitc->reglen * sizeof(jit_int32_t));
+             _jitc->reglen * sizeof(int32_t));
 
     /* _no_link here does not mean the jit_link() call can be removed
      * by rewriting as:
@@ -274,8 +274,8 @@ _jit_prolog(jit_state_t *_jit)
     jit_regset_new(&_jitc->function->regset);
 }
 
-jit_int32_t
-_jit_allocai(jit_state_t *_jit, jit_int32_t length)
+int32_t
+_jit_allocai(jit_state_t *_jit, int32_t length)
 {
     assert(_jitc->function);
     switch (length) {
@@ -293,13 +293,13 @@ _jit_allocai(jit_state_t *_jit, jit_int32_t length)
 }
 
 void
-_jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_allocar(jit_state_t *_jit, int32_t u, jit_int32_t v)
 {
-    jit_int32_t                 reg;
+    int32_t             reg;
     assert(_jitc->function);
     jit_inc_synth_ww(allocar, u, v);
     if (!_jitc->function->allocar) {
-       _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
+       _jitc->function->aoffoff = jit_allocai(sizeof(int32_t));
        _jitc->function->allocar = 1;
     }
     reg = jit_get_reg(jit_class_gpr);
@@ -326,7 +326,7 @@ _jit_ret(jit_state_t *_jit)
 }
 
 void
-_jit_retr(jit_state_t *_jit, jit_int32_t u)
+_jit_retr(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr, u);
     if (JIT_RET != u)
@@ -346,7 +346,7 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_f(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_f, u);
     if (jit_cpu.abi) {
@@ -378,7 +378,7 @@ _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_d(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_d, u);
     if (jit_cpu.abi) {
@@ -438,7 +438,7 @@ _jit_arg_register_p(jit_state_t *_jit, jit_node_t *u)
 static jit_node_t *
 _jit_make_arg(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
     if (jit_arg_reg_p(_jitc->function->self.argi))
        offset = _jitc->function->self.argi++;
     else {
@@ -458,7 +458,7 @@ _jit_make_arg(jit_state_t *_jit, jit_node_t *node)
 jit_node_t *
 _jit_make_arg_f(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
     if (jit_cpu.abi && !(_jitc->function->self.call & jit_call_varargs)) {
        if (jit_arg_f_reg_p(_jitc->function->self.argf)) {
            offset = _jitc->function->self.argf++;
@@ -487,7 +487,7 @@ done:
 jit_node_t *
 _jit_make_arg_d(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
     if (jit_cpu.abi && !(_jitc->function->self.call & jit_call_varargs)) {
        if (jit_arg_d_reg_p(_jitc->function->self.argf)) {
            if (_jitc->function->self.argf & 1)
@@ -550,7 +550,7 @@ _jit_ellipsis(jit_state_t *_jit)
 }
 
 void
-_jit_va_push(jit_state_t *_jit, jit_int32_t u)
+_jit_va_push(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(va_push, u);
     jit_pushargr(u);
@@ -579,7 +579,7 @@ _jit_arg_d(jit_state_t *_jit)
 }
 
 void
-_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_c(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_c, u, v);
@@ -593,7 +593,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_uc(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_uc, u, v);
@@ -607,7 +607,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_s(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_s, u, v);
@@ -621,7 +621,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_us(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_us, u, v);
@@ -635,7 +635,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_i(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_i, u, v);
@@ -649,7 +649,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargr, u, v);
@@ -665,7 +665,7 @@ _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargi, u, v);
     if (jit_swf_p()) {
@@ -686,7 +686,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 }
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(getarg_f, u, v);
@@ -708,7 +708,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(putargr_f, u, v);
@@ -732,7 +732,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_fp(putargi_f, u, v);
     if (jit_cpu.abi) {
@@ -764,7 +764,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, 
jit_node_t *v)
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(getarg_d, u, v);
@@ -786,7 +786,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(putargr_d, u, v);
@@ -810,7 +810,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_dp(putargi_d, u, v);
     if (jit_cpu.abi) {
@@ -842,7 +842,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, 
jit_node_t *v)
 }
 
 void
-_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr, u);
@@ -861,7 +861,7 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_w(pushargi, u);
     jit_link_prepare();
@@ -880,7 +880,7 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_f(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_f, u);
@@ -908,7 +908,7 @@ done:
 void
 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(_jitc->function);
     jit_inc_synth_f(pushargi_f, u);
     jit_link_prepare();
@@ -943,7 +943,7 @@ done:
 }
 
 void
-_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_d(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_d, u);
@@ -979,7 +979,7 @@ done:
 void
 _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(_jitc->function);
     jit_inc_synth_d(pushargi_d, u);
     jit_link_prepare();
@@ -1015,9 +1015,9 @@ done:
 }
 
 jit_bool_t
-_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, int32_t regno)
 {
-    jit_int32_t                spec;
+    int32_t            spec;
     spec = jit_class(_rvs[regno].spec);
     if (spec & jit_class_arg) {
        regno = JIT_RA0 - regno;
@@ -1034,7 +1034,7 @@ _jit_regarg_p(jit_state_t *_jit, jit_node_t *node, 
jit_int32_t regno)
 }
 
 void
-_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
+_jit_finishr(jit_state_t *_jit, int32_t r0)
 {
     jit_node_t         *node;
     assert(_jitc->function);
@@ -1069,7 +1069,7 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
 }
 
 void
-_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_c(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_c, r0);
     jit_extr_c(r0, JIT_RET);
@@ -1077,7 +1077,7 @@ _jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_uc(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_uc, r0);
     jit_extr_uc(r0, JIT_RET);
@@ -1085,7 +1085,7 @@ _jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_s(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_s, r0);
     jit_extr_s(r0, JIT_RET);
@@ -1093,7 +1093,7 @@ _jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_us(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_us, r0);
     jit_extr_us(r0, JIT_RET);
@@ -1101,7 +1101,7 @@ _jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_i(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_i, r0);
     if (r0 != JIT_RET)
@@ -1110,7 +1110,7 @@ _jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_f(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_f, r0);
     if (jit_cpu.abi) {
@@ -1123,7 +1123,7 @@ _jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_d(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_d, r0);
     if (jit_cpu.abi) {
@@ -1141,21 +1141,21 @@ _emit_code(jit_state_t *_jit)
     jit_node_t         *node;
     jit_node_t         *temp;
     jit_word_t          word;
-    jit_int32_t                 value;
-    jit_int32_t                 offset;
+    int32_t             value;
+    int32_t             offset;
     struct {
        jit_node_t      *node;
-       jit_uint8_t     *data;
+       uint8_t *data;
        jit_word_t       word;
 #if DEVEL_DISASSEMBLER
        jit_word_t       prevw;
 #endif
        jit_uword_t      thumb;
 #if DISASSEMBLER
-       jit_int32_t      info_offset;
+       int32_t  info_offset;
 #endif
-       jit_int32_t      const_offset;
-       jit_int32_t      patch_offset;
+       int32_t  const_offset;
+       int32_t  patch_offset;
     } undo;
 #if DEVEL_DISASSEMBLER
     jit_word_t          prevw;
@@ -1974,7 +1974,7 @@ _emit_code(jit_state_t *_jit)
        if (!jit_thumb_p() &&
            (node->code == jit_code_movi || node->code == jit_code_calli)) {
            /* calculate where to patch word */
-           value = *(jit_int32_t *)word;
+           value = *(int32_t *)word;
            assert((value & 0x0f700000) == ARM_LDRI);
            /* offset may become negative (-4) if last instruction
             * before unconditional branch and data following
@@ -2016,19 +2016,19 @@ jit_flush(void *fptr, void *tptr)
 }
 
 void
-_emit_ldxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi_i(rn(r0), rn(r1), i0);
 }
 
 void
-_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     stxi_i(i0, rn(r0), rn(r1));
 }
 
 void
-_emit_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (jit_swf_p())
        swf_ldxi_d(rn(r0), rn(r1), i0);
@@ -2037,7 +2037,7 @@ _emit_ldxi_d(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1, jit_word_t i0)
 }
 
 void
-_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     if (jit_swf_p())
        swf_stxi_d(i0, rn(r0), rn(r1));
@@ -2045,7 +2045,7 @@ _emit_stxi_d(jit_state_t *_jit, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
        vfp_stxi_d(i0, rn(r0), rn(r1));
 }
 
-static jit_int32_t
+static int32_t
 _jit_get_reg_pair(jit_state_t *_jit)
 {
     /*   bypass jit_get_reg() with argument or'ed with jit_class_chk
@@ -2081,7 +2081,7 @@ _jit_get_reg_pair(jit_state_t *_jit)
 }
 
 static void
-_jit_unget_reg_pair(jit_state_t *_jit, jit_int32_t reg)
+_jit_unget_reg_pair(jit_state_t *_jit, int32_t reg)
 {
     jit_unget_reg(reg);
     switch (reg) {
@@ -2119,14 +2119,14 @@ _must_align_p(jit_state_t *_jit, jit_node_t *node)
 }
 
 static void
-_load_const(jit_state_t *_jit, jit_bool_t uniq, jit_int32_t r0, jit_word_t i0)
+_load_const(jit_state_t *_jit, jit_bool_t uniq, int32_t r0, jit_word_t i0)
 {
     jit_word_t          w;
     jit_word_t          d;
     jit_word_t          base;
-    jit_int32_t                *data;
-    jit_int32_t                 size;
-    jit_int32_t                 offset;
+    int32_t            *data;
+    int32_t             size;
+    int32_t             offset;
 
     assert(!jit_thumb_p());
     if (!uniq) {
@@ -2145,7 +2145,7 @@ _load_const(jit_state_t *_jit, jit_bool_t uniq, 
jit_int32_t r0, jit_word_t i0)
         */
 
        /* search in previous constant pool */
-       if ((data = (jit_int32_t *)_jitc->consts.data)) {
+       if ((data = (int32_t *)_jitc->consts.data)) {
            w = (jit_word_t)data;
            /* maximum backwards offset */
            base = (_jit->pc.w + 8) - 4092;
@@ -2196,7 +2196,7 @@ static void
 _flush_consts(jit_state_t *_jit)
 {
     jit_word_t          word;
-    jit_int32_t                 offset;
+    int32_t             offset;
 
     /* if no forward constants */
     if (!_jitc->consts.length)
@@ -2243,8 +2243,8 @@ _invalidate_consts(jit_state_t *_jit)
 static void
 _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
 {
-    jit_int32_t                 flag;
-    jit_int32_t                 kind;
+    int32_t             flag;
+    int32_t             kind;
 
     assert(node->flag & jit_flag_node);
     if (node->code == jit_code_movi) {
diff --git a/jit/arm.h b/jit/arm.h
index 496e89b..a456254 100644
--- a/jit/arm.h
+++ b/jit/arm.h
@@ -105,18 +105,18 @@ typedef enum {
 } jit_reg_t;
 
 typedef struct {
-    jit_uint32_t version       : 4;
-    jit_uint32_t extend                : 1;
+    uint32_t version   : 4;
+    uint32_t extend            : 1;
     /* only generate thumb instructions for thumb2 */
-    jit_uint32_t thumb         : 1;
-    jit_uint32_t vfp           : 3;
-    jit_uint32_t neon          : 1;
-    jit_uint32_t abi           : 2;
+    uint32_t thumb             : 1;
+    uint32_t vfp               : 3;
+    uint32_t neon              : 1;
+    uint32_t abi               : 2;
     /* use strt+offset instead of str.w?
      * on special cases it causes a SIGILL at least on qemu, probably
      * due to some memory ordering constraint not being respected, so,
      * disable by default */
-    jit_uint32_t ldrt_strt     : 1;
+    uint32_t ldrt_strt : 1;
 } jit_cpu_t;
 
 /*
diff --git a/jit/hppa-cpu.c b/jit/hppa-cpu.c
index 4318f06..59ec844 100644
--- a/jit/hppa-cpu.c
+++ b/jit/hppa-cpu.c
@@ -48,142 +48,142 @@ typedef struct udiv {
 #define _CR11_REGNO            11
 #define ii(v)                  *_jit->pc.ui++ = v
 #define f1(o,b,t,i)                    _f1(_jit,o,b,t,i)
-static void _f1(jit_state_t*,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f1(jit_state_t*,int32_t,
+               int32_t,jit_int32_t,jit_int32_t);
 #define f2(o,b,r,i,j)                  _f2(_jit,o,b,r,i,j)
-static void _f2(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f2(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f3(o,b,t,i,j)                  _f3(_jit,o,b,t,i,j)
-static void _f3(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f3(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t);
 #define f4(o,b,x,s,u,y,c,z,m,t)                _f4(_jit,o,b,x,s,u,y,c,z,m,t)
-static void _f4(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f4(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f5(o,b,i,s,a,y,c,z,m,t)                _f5(_jit,o,b,i,s,a,y,c,z,m,t)
-static void _f5(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f5(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f6(o,b,r,s,a,x,c,y,m,i)                _f6(_jit,o,b,r,s,a,x,c,y,m,i)
-static void _f6(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f6(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f7(o,r,i)                      _f7(_jit,o,r,i)
-static void _f7(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f7(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define f8(o,r2,r1,cf,e1,x,e2,y,d,t)   _f8(_jit,o,r2,r1,cf,e1,x,e2,y,d,t)
-static void _f8(jit_state_t*,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f8(jit_state_t*,int32_t,
+               int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t);
 #define f9(o,r,t,cf,e1,im)             _f9(_jit,o,r,t,cf,e1,im)
 static void _f9(jit_state_t*,
-               jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t);
+               int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t);
 #define f10(o,r2,r1,u,v,w,x,sa,y,t)    _f10(_jit,o,r2,r1,u,v,w,x,sa,y,t)
-static void _f10(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f10(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f11(o,r2,r1,c,x,y,z,u,t)       _f11(_jit,o,r2,r1,c,x,y,z,u,t)
-static void _f11(jit_state_t*,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f11(jit_state_t*,int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f12(o,r,t,c,x,se,y,c1,z,clen)  _f12(_jit,o,r,t,c,x,se,y,c1,z,clen)
-static void _f12(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f12(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f13(o,t,r,c,x,nz,c1,clen)      _f13(_jit,o,t,r,c,x,nz,c1,clen)
-static void _f13(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f13(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t);
 #define f13x(o,t,i,c,x,nz,c1,clen)     _f13x(_jit,o,t,i,c,x,nz,c1,clen)
-static void _f13x(jit_state_t*,jit_int32_t,jit_int32_t,
-                 jit_int32_t,jit_int32_t,jit_int32_t,
-                 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f13x(jit_state_t*,int32_t,jit_int32_t,
+                 int32_t,jit_int32_t,jit_int32_t,
+                 int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f14(o,r2,r1,c,x,cp,y,cpos,t)   _f14(_jit,o,r2,r1,c,x,cp,y,cpos,t)
-static void _f14(jit_state_t*,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f14(jit_state_t*,int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f15(o,r,t,c,c1,p,se,pos,clen)  _f15(_jit,o,r,t,c,c1,p,se,pos,clen)
-static void _f15(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f15(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f16(o,t,r,c,c1,cp,nz,cpos,clen)        
_f16(_jit,o,t,r,c,c1,cp,nz,cpos,clen)
-static void _f16(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f16(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f16x(o,t,i,c,c1,cp,nz,cpos,clen) _f16x(_jit,o,t,i,c,c1,cp,nz,cpos,clen)
-static void _f16x(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f16x(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f17(o,r2,r1,c,i,n)             _f17(_jit,o,r2,r1,c,i,n)
-static void _f17(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f17(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f17x(o,r2,r1,c,i,n)            _f17x(_jit,o,r2,r1,c,i,n)
-static void _f17x(jit_state_t*,jit_int32_t,jit_int32_t,
-                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f17x(jit_state_t*,int32_t,jit_int32_t,
+                 int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f18(o,p,r,c,i,n)               _f18(_jit,o,p,r,c,i,n)
-static void _f18(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f18(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f19(o,b,s,i,n)                 _f19(_jit,o,b,s,i,n)
-static void _f19(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f19(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f20(o,t,i,g,n)                 _f20(_jit,o,t,i,g,n)
-static void _f20(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f20(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t);
 #define f21(o,t,x,y,n)                 _f21(_jit,o,t,x,y,n)
-static void _f21(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f21(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t);
 #define f22(o,b,x,r,n,p)               _f22(_jit,o,b,x,r,n,p)
-static void _f22(jit_state_t*,jit_int32_t,jit_int32_t,
-               jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f22(jit_state_t*,int32_t,jit_int32_t,
+               int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f23(o,a,b,c,d,e,f,g,h)         _f23(_jit,o,a,b,c,d,e,f,g,h)
-static void _f23(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f23(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f24(o,b,x,s,y,m,r)             _f24(_jit,o,b,x,s,y,m,r)
-static void _f24(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f24(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f25(o,b,i,s,y,m,r)             _f25(_jit,o,b,i,s,y,m,r)
-static void _f25(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f25(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f26(o,b,x,s,y,m,r)             _f26(_jit,o,b,x,s,y,m,r)
-static void _f26(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f26(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f27(o,i,j)                     _f27(_jit,o,i,j)
-static void _f27(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t) 
maybe_unused;
+static void _f27(jit_state_t*,int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f28(o,i)                       _f28(_jit,o,i)
-static void _f28(jit_state_t*,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f28(jit_state_t*,int32_t,jit_int32_t) maybe_unused;
 #define f29(o,r,x,s,y,t)               _f29(_jit,o,r,x,s,y,t)
-static void _f29(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f29(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f30(o,b,r,s,x,y,t)             _f30(_jit,o,b,r,s,x,y,t)
-static void _f30(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f30(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f31(o,t,r,v,x,y)               _f31(_jit,o,t,r,v,x,y)
-static void _f31(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f31(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f33(o,x,r,y,z,u)               _f33(_jit,o,x,r,y,z,u)
-static void _f33(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f33(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f34(o,o1,x,sf,n,o2)            _f34(_jit,o,o1,x,sf,n,o2)
-static void _f34(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f34(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f35(o,op,x,sf,n,t)             _f35(_jit,o,op,x,sf,n,t)
-static void _f35(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f35(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f36(o,r,o1,x,sf,n,o2)          _f36(_jit,o,r,o1,x,sf,n,o2)
-static void _f36(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f36(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f37(o,r2,r1,o1,x,sf,n,o2)      _f37(_jit,o,r2,r1,o1,x,sf,n,o2)
-static void _f37(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f37(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f38(o,s,u,n)                   _f38(_jit,o,s,u,n)
-static void _f38(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f38(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 /* nulify next instruction if condition is met with addition */
 #define ADD_CF_NV              0       /* never */
 #define ADD_CF_EQ              2       /* O1 == -O2 (word) */
@@ -641,13 +641,13 @@ static void _f38(jit_state_t*,jit_int32_t,
 #define UXOR(r1,r2,t)          f8(0x2,r2,r1,LOG_CC_NV,0,1,1,2,0,t)
 #define XOR(r1,r2,t)           f8(0x2,r2,r1,LOG_CC_NV,0,1,0,2,0,t)
 #  define nop(c)                       _nop(_jit,c)
-static void _nop(jit_state_t*,jit_int32_t);
+static void _nop(jit_state_t*,int32_t);
 #define movr(r0,r1)            _movr(_jit,r0,r1)
-static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr(jit_state_t*,int32_t,jit_int32_t);
 #define movi(r0,i0)            _movi(_jit,r0,i0)
-static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
+static void _movi(jit_state_t*,int32_t,jit_word_t);
 #define movi_p(r0,i0)          _movi_p(_jit,r0,i0)
-static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
+static jit_word_t _movi_p(jit_state_t*,int32_t,jit_word_t);
 #define comr(r0,r1)            UADDCM(_R0_REGNO,r1,r0)
 #define negr(r0,r1)            SUB(_R0_REGNO,r1,r0)
 #define extr_c(r0,r1)          EXTRWR(r1,31,8,r0)
@@ -662,98 +662,98 @@ static jit_word_t 
_movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 #endif
 #define addr(r0,r1,r2)         ADD(r1,r2,r0)
 #define addi(r0,r1,i0)         _addi(_jit,r0,r1,i0)
-static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define addcr(r0,r1,r2)                addr(r0,r1,r2)
 #define addci(r0,r1,i0)                _addci(_jit,r0,r1,i0)
-static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define addxr(r0,r1,r2)                ADD_C(r1,r2,r0)
 #define addxi(r0,r1,i0)                _addxi(_jit,r0,r1,i0)
-static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define subr(r0,r1,r2)         SUB(r1,r2,r0)
 #define subi(r0,r1,i0)         _subi(_jit,r0,r1,i0)
-static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define subcr(r0,r1,r2)                subr(r0,r1,r2)
 #define subci(r0,r1,i0)                _subci(_jit,r0,r1,i0)
-static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define subxr(r0,r1,r2)                SUB_B(r1,r2,r0)
 #define subxi(r0,r1,i0)                _subxi(_jit,r0,r1,i0)
-static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define rsbi(r0, r1, i0)       _rsbi(_jit, r0, r1, i0)
-static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rsbi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define mulr(r0,r1,r2)         _mulr(_jit,r0,r1,r2)
-static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _mulr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define muli(r0,r1,i0)         _muli(_jit,r0,r1,i0)
-static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _muli(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static long long __llmul(int, int);
 #define qmulr(r0,r1,r2,r3)     _qmulr(_jit,r0,r1,r2,r3)
 static void _qmulr(jit_state_t*,
-                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+                  int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define qmuli(r0,r1,r2,i0)     _qmuli(_jit,r0,r1,r2,i0)
 static void _qmuli(jit_state_t*,
-                  jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+                  int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 #define qmulr_u(r0,r1,r2,r3)   _qmulr_u(_jit,r0,r1,r2,r3)
 static void _qmulr_u(jit_state_t*,
-                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+                    int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define qmuli_u(r0,r1,r2,i0)   _qmuli_u(_jit,r0,r1,r2,i0)
 static void _qmuli_u(jit_state_t*,
-                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+                    int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 static int __idiv(int, int);
 #define divr(r0,r1,r2)         _divr(_jit,r0,r1,r2)
-static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define divi(r0,r1,i0)         _divi(_jit,r0,r1,i0)
-static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static unsigned int __udiv(unsigned int, unsigned int);
 #define divr_u(r0,r1,r2)       _divr_u(_jit,r0,r1,r2)
-static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define divi_u(r0,r1,i0)       _divi_u(_jit,r0,r1,i0)
-static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static int __irem(int, int);
 #define remr(r0,r1,r2)         _remr(_jit,r0,r1,r2)
-static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define remi(r0,r1,i0)         _remi(_jit,r0,r1,i0)
-static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static unsigned int __urem(unsigned int, unsigned int);
 #define remr_u(r0,r1,r2)       _remr_u(_jit,r0,r1,r2)
-static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define remi_u(r0,r1,i0)       _remi_u(_jit,r0,r1,i0)
-static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 static idiv_t __idivrem(int, int);
 #define qdivr(r0,r1,r2,r3)     _qdivr(_jit,r0,r1,r2,r3)
 static void _qdivr(jit_state_t*,
-                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+                  int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define qdivi(r0,r1,r2,i0)     _qdivi(_jit,r0,r1,r2,i0)
 static void _qdivi(jit_state_t*,
-                  jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+                  int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 static udiv_t __udivrem(unsigned int, unsigned int);
 #define qdivr_u(r0,r1,r2,r3)   _qdivr_u(_jit,r0,r1,r2,r3)
 static void _qdivr_u(jit_state_t*,
-                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+                    int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define qdivi_u(r0,r1,r2,i0)   _qdivi_u(_jit,r0,r1,r2,i0)
 static void _qdivi_u(jit_state_t*,
-                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
+                    int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 #define andr(r0,r1,r2)         AND(r1,r2,r0)
 #define andi(r0,r1,i0)         _andi(_jit,r0,r1,i0)
-static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _andi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define orr(r0,r1,r2)          OR(r1,r2,r0)
 #define ori(r0,r1,i0)          _ori(_jit,r0,r1,i0)
-static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define xorr(r0,r1,r2)         XOR(r1,r2,r0)
 #define xori(r0,r1,i0)         _xori(_jit,r0,r1,i0)
-static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _xori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define lshr(r0,r1,r2)         _lshr(_jit,r0,r1,r2)
-static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _lshr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lshi(r0,r1,i0)         SHLWI(r1,i0,r0)
 #define rshr(r0,r1,r2)         _rshr(_jit,r0,r1,r2)
-static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _rshr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define rshi(r0,r1,i0)         SHRWI(r1,i0,r0)
 #define rshr_u(r0,r1,r2)       _rshr_u(_jit,r0,r1,r2)
-static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _rshr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define rshi_u(r0,r1,i0)       SHRWI_U(r1,i0,r0)
 #define cmpr(c,r0,r1,r2)       _cmpr(_jit,c,r0,r1,r2)
-static void _cmpr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _cmpr(jit_state_t*,jit_word_t,int32_t,jit_int32_t,jit_int32_t);
 #define cmpi(c,ci,r0,r1,i0)    _cmpi(_jit,c,ci,r0,r1,i0)
 static void _cmpi(jit_state_t*,jit_word_t,jit_word_t,
-                 jit_int32_t,jit_int32_t,jit_word_t);
+                 int32_t,jit_int32_t,jit_word_t);
 #define ltr(r0,r1,r2)          cmpr(CS_CC_GE,r0,r1,r2)
 #define lti(r0,r1,i0)          cmpi(CS_CC_GE,CS_CC_LE,r0,r1,i0)
 #define ltr_u(r0,r1,r2)                cmpr(CS_CC_UGE,r0,r1,r2)
@@ -775,73 +775,73 @@ static void _cmpi(jit_state_t*,jit_word_t,jit_word_t,
 #define ner(r0,r1,r2)          cmpr(CS_CC_EQ,r0,r1,r2)
 #define nei(r0,r1,i0)          cmpi(CS_CC_EQ,CS_CC_EQ,r0,r1,i0)
 #define ldr_c(r0,r1)           _ldr_c(_jit,r0,r1)
-static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_c(jit_state_t*,int32_t,jit_int32_t);
 #define ldi_c(r0,i0)           _ldi_c(_jit,r0,i0)
-static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_c(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_c(r0,r1,r2)       _ldxr_c(_jit,r0,r1,r2)
-static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_c(r0,r1,i0)       _ldxi_c(_jit,r0,r1,i0)
-static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_c(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldr_uc(r0,r1)          LDBI(_R0_REGNO,r1,r0)
 #define ldi_uc(r0,i0)          _ldi_uc(_jit,r0,i0)
-static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_uc(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_uc(r0,r1,r2)      LDB(r2,r1,r0)
 #define ldxi_uc(r0,r1,i0)      _ldxi_uc(_jit,r0,r1,i0)
-static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_uc(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldr_s(r0,r1)           _ldr_s(_jit,r0,r1)
-static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_s(jit_state_t*,int32_t,jit_int32_t);
 #define ldi_s(r0,i0)           _ldi_s(_jit,r0,i0)
-static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_s(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_s(r0,r1,r2)       _ldxr_s(_jit,r0,r1,r2)
-static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_s(r0,r1,i0)       _ldxi_s(_jit,r0,r1,i0)
-static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_s(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldr_us(r0,r1)          LDHI(_R0_REGNO,r1,r0)
 #define ldi_us(r0,i0)          _ldi_us(_jit,r0,i0)
-static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_us(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_us(r0,r1,r2)      LDH(r2,r1,r0)
 #define ldxi_us(r0,r1,i0)      _ldxi_us(_jit,r0,r1,i0)
-static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_us(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldr(r0,r1)             ldr_ui(r0,r1)
 #define ldr_i(r0,r1)           ldr_ui(r0,r1)
 #define ldr_ui(r0,r1)          LDWI(_R0_REGNO,r1,r0)
 #define ldi_i(r0,i0)           ldi_ui(r0,i0)
 #define ldi_ui(r0,i0)          _ldi_ui(_jit,r0,i0)
-static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_ui(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_i(r0,r1,r2)       ldxr_ui(r0,r1,r2)
 #define ldxr_ui(r0,r1,r2)      LDW(r2,r1,r0)
 #define ldxi(r0,r1,i0)         ldxi_ui(r0,r1,i0)
 #define ldxi_i(r0,r1,i0)       ldxi_ui(r0,r1,i0)
 #define ldxi_ui(r0,r1,i0)      _ldxi_ui(_jit,r0,r1,i0)
-static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_ui(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define str_c(r0,r1)           STBI(r1,_R0_REGNO,r0)
 #define sti_c(i0,r0)           _sti_c(_jit,i0,r0)
-static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_c(jit_state_t*,jit_word_t,int32_t);
 #define stxr_c(r0,r1,r2)       _stxr_c(_jit,r0,r1,r2)
-static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi_c(i0,r0,r1)       _stxi_c(_jit,i0,r0,r1)
-static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_c(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define str_s(r0,r1)           STHI(r1,_R0_REGNO,r0)
 #define sti_s(i0,r0)           _sti_s(_jit,i0,r0)
-static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_s(jit_state_t*,jit_word_t,int32_t);
 #define stxr_s(r0,r1,r2)       _stxr_s(_jit,r0,r1,r2)
-static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi_s(i0,r0,r1)       _stxi_s(_jit,i0,r0,r1)
-static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_s(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define str_i(r0,r1)           STWI(r1,_R0_REGNO,r0)
 #define sti_i(i0,r0)           _sti_i(_jit,i0,r0)
-static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_i(jit_state_t*,jit_word_t,int32_t);
 #define stxr_i(r0,r1,r2)       _stxr_i(_jit,r0,r1,r2)
-static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi(i0,r0,r1)         stxi_i(i0,r0,r1)
 #define stxi_i(i0,r0,r1)       _stxi_i(_jit,i0,r0,r1)
-static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_i(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bcmpr(c,i0,r0,r1)      _bcmpr(_jit,c,i0,r0,r1)
 static jit_word_t _bcmpr(jit_state_t*,jit_word_t,
-                        jit_word_t,jit_int32_t,jit_int32_t);
+                        jit_word_t,int32_t,jit_int32_t);
 #define bcmpi(c,ci,i0,r0,i1)   _bcmpi(_jit,c,ci,i0,r0,i1)
 static jit_word_t _bcmpi(jit_state_t*,jit_word_t,jit_word_t,
-                        jit_word_t,jit_int32_t,jit_word_t);
+                        jit_word_t,int32_t,jit_word_t);
 #define bltr(i0,r0,r1)         bcmpr(CS_CC_LT,i0,r0,r1)
 #define blti(i0,r0,r1)         bcmpi(CS_CC_LT,CS_CC_GT,i0,r0,r1)
 #define bltr_u(i0,r0,r1)       bcmpr(CS_CC_ULT,i0,r0,r1)
@@ -864,54 +864,54 @@ static jit_word_t 
_bcmpi(jit_state_t*,jit_word_t,jit_word_t,
 #define bnei(i0,r0,r1)         bcmpi(CS_CC_NE,CS_CC_NE,i0,r0,r1)
 #define bmxr(c,i0,r0,r1)       _bmxr(_jit,c,i0,r0,r1)
 static jit_word_t _bmxr(jit_state_t*,jit_bool_t,
-                       jit_word_t,jit_int32_t,jit_int32_t);
+                       jit_word_t,int32_t,jit_int32_t);
 #define bmxi(c,i0,r0,i1)       _bmxi(_jit,c,i0,r0,i1)
 static jit_word_t _bmxi(jit_state_t*,jit_bool_t,
-                       jit_word_t,jit_int32_t,jit_word_t);
+                       jit_word_t,int32_t,jit_word_t);
 #define bmcr(r0,r1,r2)         bmxr(0,r0,r1,r2)
 #define bmci(r0,r1,r2)         bmxi(0,r0,r1,r2)
 #define bmsr(r0,r1,r2)         bmxr(1,r0,r1,r2)
 #define bmsi(r0,r1,r2)         bmxi(1,r0,r1,r2)
 #define boaddr(i0,r0,r1)       _boaddr(_jit,i0,r0,r1)
-static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _boaddr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define boaddi(i0,r0,i1)       _boaddi(_jit,i0,r0,i1)
-static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _boaddi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define boaddr_u(i0,r0,r1)     _boaddr_u(_jit,i0,r0,r1)
-static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define boaddi_u(i0,r0,i1)     _boaddi_u(_jit,i0,r0,i1)
-static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bxaddr(i0,r0,r1)       _bxaddr(_jit,i0,r0,r1)
-static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxaddr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bxaddi(i0,r0,i1)       _bxaddi(_jit,i0,r0,i1)
-static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxaddi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bxaddr_u(i0,r0,r1)     _bxaddr_u(_jit,i0,r0,r1)
-static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bxaddi_u(i0,r0,i1)     _bxaddi_u(_jit,i0,r0,i1)
-static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bosubr(i0,r0,r1)       _bosubr(_jit,i0,r0,r1)
-static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bosubr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bosubi(i0,r0,i1)       _bosubi(_jit,i0,r0,i1)
-static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bosubi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bosubr_u(i0,r0,r1)     _bosubr_u(_jit,i0,r0,r1)
-static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bosubi_u(i0,r0,i1)     _bosubi_u(_jit,i0,r0,i1)
-static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bxsubr(i0,r0,r1)       _bxsubr(_jit,i0,r0,r1)
-static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxsubr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bxsubi(i0,r0,i1)       _bxsubi(_jit,i0,r0,i1)
-static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxsubi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bxsubr_u(i0,r0,r1)     _bxsubr_u(_jit,i0,r0,r1)
-static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bxsubi_u(i0,r0,i1)     _bxsubi_u(_jit,i0,r0,i1)
-static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define jmpr(r0)               _jmpr(_jit,r0)
-static void _jmpr(jit_state_t*,jit_int32_t);
+static void _jmpr(jit_state_t*,int32_t);
 #define jmpi(i0)               _jmpi(_jit,i0)
 static void _jmpi(jit_state_t*,jit_word_t);
 #define jmpi_p(i0)             _jmpi_p(_jit,i0)
 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
 #define callr(r0)              _callr(_jit,r0)
-static void _callr(jit_state_t*,jit_int32_t);
+static void _callr(jit_state_t*,int32_t);
 #define calli(i0)              _calli(_jit,i0)
 static void _calli(jit_state_t*,jit_word_t);
 #define calli_p(i0)            _calli_p(_jit,i0)
@@ -921,9 +921,9 @@ static void _prolog(jit_state_t*, jit_node_t*);
 #define epilog(node)           _epilog(_jit, node)
 static void _epilog(jit_state_t*, jit_node_t*);
 #define vastart(r0)            _vastart(_jit, r0)
-static void _vastart(jit_state_t*, jit_int32_t);
+static void _vastart(jit_state_t*, int32_t);
 #define vaarg(r0, r1)          _vaarg(_jit, r0, r1)
-static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg(jit_state_t*, int32_t, jit_int32_t);
 #define patch_at(i,l)          _patch_at(_jit,i,l)
 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 #endif
@@ -1017,8 +1017,8 @@ re_assemble_22 (int as22)
 }
 
 static void
-_f1(jit_state_t *_jit, jit_int32_t o,
-    jit_int32_t b, jit_int32_t t, jit_int32_t i)
+_f1(jit_state_t *_jit, int32_t o,
+    int32_t b, jit_int32_t t, jit_int32_t i)
 {
     assert(!(o  & ~0x3f));
     assert(!(b  & ~0x1f));
@@ -1028,8 +1028,8 @@ _f1(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f2(jit_state_t *_jit, jit_int32_t o,
-    jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
+_f2(jit_state_t *_jit, int32_t o,
+    int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
 {
     assert(!(o  & ~0x3f));
     assert(!(b  & ~0x1f));
@@ -1040,8 +1040,8 @@ _f2(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f3(jit_state_t *_jit, jit_int32_t o,
-    jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
+_f3(jit_state_t *_jit, int32_t o,
+    int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
 {
     assert(!(o  & ~0x3f));
     assert(!(b  & ~0x1f));
@@ -1052,9 +1052,9 @@ _f3(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f4(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
-    jit_int32_t x, jit_int32_t s, jit_int32_t u, jit_int32_t y,
-    jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
+_f4(jit_state_t *_jit, int32_t o, jit_int32_t b,
+    int32_t x, jit_int32_t s, jit_int32_t u, jit_int32_t y,
+    int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
 {
     assert(!(o  & ~0x3f));
     assert(!(b  & ~0x1f));
@@ -1070,9 +1070,9 @@ _f4(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
 }
 
 static void
-_f5(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
-    jit_int32_t i, jit_int32_t s, jit_int32_t a, jit_int32_t y,
-    jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
+_f5(jit_state_t *_jit, int32_t o, jit_int32_t b,
+    int32_t i, jit_int32_t s, jit_int32_t a, jit_int32_t y,
+    int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
 {
     assert(!(o  & ~0x3f));
     assert(!(b  & ~0x1f));
@@ -1088,9 +1088,9 @@ _f5(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
 }
 
 static void
-_f6(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
-    jit_int32_t r, jit_int32_t s, jit_int32_t a, jit_int32_t x,
-    jit_int32_t c, jit_int32_t y, jit_int32_t m, jit_int32_t i)
+_f6(jit_state_t *_jit, int32_t o, jit_int32_t b,
+    int32_t r, jit_int32_t s, jit_int32_t a, jit_int32_t x,
+    int32_t c, jit_int32_t y, jit_int32_t m, jit_int32_t i)
 {
     assert(!(o  & ~0x3f));
     assert(!(b  & ~0x1f));
@@ -1106,7 +1106,7 @@ _f6(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
 }
 
 static void
-_f7(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t i)
+_f7(jit_state_t *_jit, int32_t o, jit_int32_t r, jit_int32_t i)
 {
     assert(!(o  & ~0x3f));
     assert(!(r  & ~0x1f));
@@ -1115,10 +1115,10 @@ _f7(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, 
jit_int32_t i)
 }
 
 static void
-_f8(jit_state_t *_jit, jit_int32_t o,
-    jit_int32_t r2, jit_int32_t r1, jit_int32_t cf,
-    jit_int32_t e1, jit_int32_t x, jit_int32_t e2,
-    jit_int32_t e3, jit_int32_t d, jit_int32_t t)
+_f8(jit_state_t *_jit, int32_t o,
+    int32_t r2, jit_int32_t r1, jit_int32_t cf,
+    int32_t e1, jit_int32_t x, jit_int32_t e2,
+    int32_t e3, jit_int32_t d, jit_int32_t t)
 {
     assert(!(o  & ~0x3f));
     assert(!(r2 & ~0x1f));
@@ -1136,8 +1136,8 @@ _f8(jit_state_t *_jit, jit_int32_t o,
 
 static void
 _f9(jit_state_t *_jit,
-    jit_int32_t o, jit_int32_t r, jit_int32_t t,
-    jit_int32_t cf, jit_int32_t e1, jit_int32_t i)
+    int32_t o, jit_int32_t r, jit_int32_t t,
+    int32_t cf, jit_int32_t e1, jit_int32_t i)
 {
     assert(!(o  & ~0x3f));
     assert(!(r  & ~0x1f));
@@ -1149,9 +1149,9 @@ _f9(jit_state_t *_jit,
 }
 
 static void
-_f10(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
-     jit_int32_t r1, jit_int32_t u, jit_int32_t v, jit_int32_t w,
-     jit_int32_t x, jit_int32_t sa, jit_int32_t y, jit_int32_t t)
+_f10(jit_state_t *_jit, int32_t o, jit_int32_t r2,
+     int32_t r1, jit_int32_t u, jit_int32_t v, jit_int32_t w,
+     int32_t x, jit_int32_t sa, jit_int32_t y, jit_int32_t t)
 {
     assert(!(o  & ~0x3f));
     assert(!(r2 & ~0x1f));
@@ -1168,9 +1168,9 @@ _f10(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
 }
 
 static void
-_f11(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
-     jit_int32_t y, jit_int32_t z, jit_int32_t u, jit_int32_t t)
+_f11(jit_state_t *_jit, int32_t o,
+     int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
+     int32_t y, jit_int32_t z, jit_int32_t u, jit_int32_t t)
 {
     assert(!(o  & ~0x3f));
     assert(!(r1 & ~0x1f));
@@ -1185,9 +1185,9 @@ _f11(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f12(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
-     jit_int32_t t, jit_int32_t c, jit_int32_t x, jit_int32_t se,
-     jit_int32_t y, jit_int32_t c1, jit_int32_t z, jit_int32_t clen)
+_f12(jit_state_t *_jit, int32_t o, jit_int32_t r,
+     int32_t t, jit_int32_t c, jit_int32_t x, jit_int32_t se,
+     int32_t y, jit_int32_t c1, jit_int32_t z, jit_int32_t clen)
 {
     assert(!(o    & ~0x3f));
     assert(!(r    & ~0x1f));
@@ -1204,9 +1204,9 @@ _f12(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
 }
 
 static void
-_f13(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
-     jit_int32_t r, jit_int32_t c, jit_int32_t x,
-     jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
+_f13(jit_state_t *_jit, int32_t o, jit_int32_t t,
+     int32_t r, jit_int32_t c, jit_int32_t x,
+     int32_t nz, jit_int32_t c1, jit_int32_t clen)
 {
     assert(!(o    & ~0x3f));
     assert(!(t    & ~0x1f));
@@ -1221,9 +1221,9 @@ _f13(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
 }
 
 static void
-_f13x(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
-      jit_int32_t i, jit_int32_t c, jit_int32_t x,
-      jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
+_f13x(jit_state_t *_jit, int32_t o, jit_int32_t t,
+      int32_t i, jit_int32_t c, jit_int32_t x,
+      int32_t nz, jit_int32_t c1, jit_int32_t clen)
 {
     assert(!(o    & ~0x3f));
     assert(!(t    & ~0x1f));
@@ -1237,9 +1237,9 @@ _f13x(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
 }
 
 static void
-_f14(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
-     jit_int32_t cp, jit_int32_t y, jit_int32_t cpos, jit_int32_t t)
+_f14(jit_state_t *_jit, int32_t o,
+     int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
+     int32_t cp, jit_int32_t y, jit_int32_t cpos, jit_int32_t t)
 {
     assert(!(o    & ~0x3f));
     assert(!(r1   & ~0x1f));
@@ -1254,9 +1254,9 @@ _f14(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f15(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t r, jit_int32_t t, jit_int32_t c, jit_int32_t c1,
-     jit_int32_t p, jit_int32_t se, jit_int32_t pos, jit_int32_t clen)
+_f15(jit_state_t *_jit, int32_t o,
+     int32_t r, jit_int32_t t, jit_int32_t c, jit_int32_t c1,
+     int32_t p, jit_int32_t se, jit_int32_t pos, jit_int32_t clen)
 {
     assert(!(o    & ~0x3f));
     assert(!(r    & ~0x1f));
@@ -1272,9 +1272,9 @@ _f15(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f16(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t t, jit_int32_t r, jit_int32_t c, jit_int32_t c1,
-     jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
+_f16(jit_state_t *_jit, int32_t o,
+     int32_t t, jit_int32_t r, jit_int32_t c, jit_int32_t c1,
+     int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
 {
     assert(!(o    & ~0x3f));
     assert(!(t    & ~0x1f));
@@ -1290,9 +1290,9 @@ _f16(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f16x(jit_state_t *_jit, jit_int32_t o,
-      jit_int32_t t, jit_int32_t i, jit_int32_t c, jit_int32_t c1,
-      jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
+_f16x(jit_state_t *_jit, int32_t o,
+      int32_t t, jit_int32_t i, jit_int32_t c, jit_int32_t c1,
+      int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
 {
     assert(!(o    & ~0x3f));
     assert(!(t    & ~0x1f));
@@ -1308,8 +1308,8 @@ _f16x(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f17(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
-     jit_int32_t r1, jit_int32_t c, jit_int32_t i, jit_int32_t n)
+_f17(jit_state_t *_jit, int32_t o, jit_int32_t r2,
+     int32_t r1, jit_int32_t c, jit_int32_t i, jit_int32_t n)
 {
     assert(!(o  & ~0x3f));
     assert(!(r2 & ~0x1f));
@@ -1321,8 +1321,8 @@ _f17(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
 }
 
 static void
-_f17x(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
-      jit_int32_t i, jit_int32_t c, jit_int32_t t, jit_int32_t n)
+_f17x(jit_state_t *_jit, int32_t o, jit_int32_t r,
+      int32_t i, jit_int32_t c, jit_int32_t t, jit_int32_t n)
 {
     assert(!(o & ~0x3f));
     assert(!(r & ~0x1f));
@@ -1335,8 +1335,8 @@ _f17x(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
 }
 
 static void
-_f18(jit_state_t *_jit, jit_int32_t o, jit_int32_t p,
-     jit_int32_t r, jit_int32_t c, jit_int32_t i, jit_int32_t n)
+_f18(jit_state_t *_jit, int32_t o, jit_int32_t p,
+     int32_t r, jit_int32_t c, jit_int32_t i, jit_int32_t n)
 {
     assert(!(o & ~0x3f));
     assert(!(p & ~0x1f));
@@ -1348,8 +1348,8 @@ _f18(jit_state_t *_jit, jit_int32_t o, jit_int32_t p,
 }
 
 static void
-_f19(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
-     jit_int32_t s, jit_int32_t i, jit_int32_t n)
+_f19(jit_state_t *_jit, int32_t o, jit_int32_t b,
+     int32_t s, jit_int32_t i, jit_int32_t n)
 {
     assert(!(o & ~0x3f));
     assert(!(b & ~0x1f));
@@ -1360,8 +1360,8 @@ _f19(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
 }
 
 static void
-_f20(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
-     jit_int32_t i, jit_int32_t g, jit_int32_t n)
+_f20(jit_state_t *_jit, int32_t o, jit_int32_t t,
+     int32_t i, jit_int32_t g, jit_int32_t n)
 {
     assert(!(o & ~0x3f));
     assert(!(t & ~0x1f));
@@ -1372,8 +1372,8 @@ _f20(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
 }
 
 static void
-_f21(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
-     jit_int32_t x, jit_int32_t y, jit_int32_t n)
+_f21(jit_state_t *_jit, int32_t o, jit_int32_t t,
+     int32_t x, jit_int32_t y, jit_int32_t n)
 {
     assert(!(o & ~0x3f));
     assert(!(t & ~0x1f));
@@ -1384,8 +1384,8 @@ _f21(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
 }
 
 static void
-_f22(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
-     jit_int32_t x, jit_int32_t r, jit_int32_t n, jit_int32_t p)
+_f22(jit_state_t *_jit, int32_t o, jit_int32_t b,
+     int32_t x, jit_int32_t r, jit_int32_t n, jit_int32_t p)
 {
     assert(!(o & ~0x3f));
     assert(!(b & ~0x1f));
@@ -1397,9 +1397,9 @@ _f22(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
 }
 
 static void
-_f23(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t d,
-     jit_int32_t e, jit_int32_t f, jit_int32_t g, jit_int32_t h)
+_f23(jit_state_t *_jit, int32_t o,
+     int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t d,
+     int32_t e, jit_int32_t f, jit_int32_t g, jit_int32_t h)
 {
     assert(!(o &  ~0x3f));
     assert(!(a &  ~0x1f));
@@ -1414,9 +1414,9 @@ _f23(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f24(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t b, jit_int32_t x, jit_int32_t s,
-     jit_int32_t y, jit_int32_t m,jit_int32_t r)
+_f24(jit_state_t *_jit, int32_t o,
+     int32_t b, jit_int32_t x, jit_int32_t s,
+     int32_t y, jit_int32_t m,jit_int32_t r)
 {
     assert(!(o &  ~0x3f));
     assert(!(b &  ~0x1f));
@@ -1429,9 +1429,9 @@ _f24(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f25(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t b, jit_int32_t i, jit_int32_t s,
-     jit_int32_t y, jit_int32_t m, jit_int32_t r)
+_f25(jit_state_t *_jit, int32_t o,
+     int32_t b, jit_int32_t i, jit_int32_t s,
+     int32_t y, jit_int32_t m, jit_int32_t r)
 {
     assert(!(o &  ~0x3f));
     assert(!(b &  ~0x1f));
@@ -1444,9 +1444,9 @@ _f25(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f26(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t b, jit_int32_t x, jit_int32_t s,
-     jit_int32_t y, jit_int32_t m,jit_int32_t r)
+_f26(jit_state_t *_jit, int32_t o,
+     int32_t b, jit_int32_t x, jit_int32_t s,
+     int32_t y, jit_int32_t m,jit_int32_t r)
 {
     assert(!(o &  ~0x3f));
     assert(!(b &  ~0x1f));
@@ -1459,7 +1459,7 @@ _f26(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f27(jit_state_t *_jit, jit_int32_t o, jit_int32_t i, jit_int32_t j)
+_f27(jit_state_t *_jit, int32_t o, jit_int32_t i, jit_int32_t j)
 {
     assert(!(o & ~0x3f));
     assert(i >= -4096 && i < 4095);
@@ -1468,7 +1468,7 @@ _f27(jit_state_t *_jit, jit_int32_t o, jit_int32_t i, 
jit_int32_t j)
 }
 
 static void
-_f28(jit_state_t *_jit, jit_int32_t o, jit_int32_t i)
+_f28(jit_state_t *_jit, int32_t o, jit_int32_t i)
 {
     assert(!(o &      ~0x3f));
     assert(!(i & ~0x1ffffff));
@@ -1476,8 +1476,8 @@ _f28(jit_state_t *_jit, jit_int32_t o, jit_int32_t i)
 }
 
 static void
-_f29(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
-     jit_int32_t x, jit_int32_t s, jit_int32_t y, jit_int32_t t)
+_f29(jit_state_t *_jit, int32_t o, jit_int32_t r,
+     int32_t x, jit_int32_t s, jit_int32_t y, jit_int32_t t)
 {
     assert(!(o & ~0x3f));
     assert(!(r & ~0x1f));
@@ -1489,8 +1489,8 @@ _f29(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
 }
 
 static void
-_f30(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, jit_int32_t r,
-     jit_int32_t s, jit_int32_t x, jit_int32_t y, jit_int32_t t)
+_f30(jit_state_t *_jit, int32_t o, jit_int32_t b, jit_int32_t r,
+     int32_t s, jit_int32_t x, jit_int32_t y, jit_int32_t t)
 {
     assert(!(o & ~0x3f));
     assert(!(b & ~0x1f));
@@ -1503,8 +1503,8 @@ _f30(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, 
jit_int32_t r,
 }
 
 static void
-_f31(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
-     jit_int32_t r, jit_int32_t v, jit_int32_t x, jit_int32_t y)
+_f31(jit_state_t *_jit, int32_t o, jit_int32_t t,
+     int32_t r, jit_int32_t v, jit_int32_t x, jit_int32_t y)
 {
     assert(!(o & ~0x3f));
     assert(!(t & ~0x1f));
@@ -1516,8 +1516,8 @@ _f31(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
 }
 
 static void
-_f33(jit_state_t *_jit, jit_int32_t o, jit_int32_t x,
-     jit_int32_t r, jit_int32_t y, jit_int32_t z, jit_int32_t u)
+_f33(jit_state_t *_jit, int32_t o, jit_int32_t x,
+     int32_t r, jit_int32_t y, jit_int32_t z, jit_int32_t u)
 {
     assert(!(o & ~0x3f));
     assert(!(x & ~0x1f));
@@ -1529,8 +1529,8 @@ _f33(jit_state_t *_jit, jit_int32_t o, jit_int32_t x,
 }
 
 static void
-_f34(jit_state_t *_jit, jit_int32_t o, jit_int32_t o1,
-     jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
+_f34(jit_state_t *_jit, int32_t o, jit_int32_t o1,
+     int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
 {
     assert(!(o  &   ~0x3f));
     assert(!(o1 & ~0x7fff));
@@ -1542,8 +1542,8 @@ _f34(jit_state_t *_jit, jit_int32_t o, jit_int32_t o1,
 }
 
 static void
-_f35(jit_state_t *_jit, jit_int32_t o, jit_int32_t op,
-     jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t t)
+_f35(jit_state_t *_jit, int32_t o, jit_int32_t op,
+     int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t t)
 {
     assert(!(o  &   ~0x3f));
     assert(!(op & ~0x7fff));
@@ -1555,8 +1555,8 @@ _f35(jit_state_t *_jit, jit_int32_t o, jit_int32_t op,
 }
 
 static void
-_f36(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t o1,
-     jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
+_f36(jit_state_t *_jit, int32_t o, jit_int32_t r, jit_int32_t o1,
+     int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
 {
     assert(!(o  &  ~0x3f));
     assert(!(r  &  ~0x1f));
@@ -1569,9 +1569,9 @@ _f36(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, 
jit_int32_t o1,
 }
 
 static void
-_f37(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
-     jit_int32_t r1, jit_int32_t o1, jit_int32_t x,
-     jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
+_f37(jit_state_t *_jit, int32_t o, jit_int32_t r2,
+     int32_t r1, jit_int32_t o1, jit_int32_t x,
+     int32_t sf, jit_int32_t n, jit_int32_t o2)
 {
     assert(!(o  & ~0x3f));
     assert(!(r2 & ~0x1f));
@@ -1585,8 +1585,8 @@ _f37(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
 }
 
 static void
-_f38(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t s, jit_int32_t u, jit_int32_t n)
+_f38(jit_state_t *_jit, int32_t o,
+     int32_t s, jit_int32_t u, jit_int32_t n)
 {
     assert(!(o &     ~0x3f));
     assert(!(s & ~0x3fffff));
@@ -1596,7 +1596,7 @@ _f38(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_nop(jit_state_t *_jit, jit_int32_t i0)
+_nop(jit_state_t *_jit, int32_t i0)
 {
     for (; i0 > 0; i0 -= 4)
        NOP();
@@ -1604,14 +1604,14 @@ _nop(jit_state_t *_jit, jit_int32_t i0)
 }
 
 static void
-_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        COPY(r1, r0);
 }
 
 static void
-_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     if (i0 >= -8192 && i0 <= 8191)
        LDI(i0, r0);
@@ -1624,7 +1624,7 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static jit_word_t
-_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi_p(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         w;
     w = _jit->pc.w;
@@ -1634,9 +1634,9 @@ _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -1024 && i0 <= 1023)
        ADDI(i0, r1, r0);
     else {
@@ -1648,9 +1648,9 @@ _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     addcr(r0, r1, rn(reg));
@@ -1658,9 +1658,9 @@ _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     addxr(r0, r1, rn(reg));
@@ -1668,9 +1668,9 @@ _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -1023 && i0 <= 1024)
        addi(r0, r1, -i0);
     else {
@@ -1682,9 +1682,9 @@ _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     subcr(r0, r1, rn(reg));
@@ -1692,9 +1692,9 @@ _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     subxr(r0, r1, rn(reg));
@@ -1702,9 +1702,9 @@ _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rsbi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -1024 && i0 <= 1023)
        SUBI(i0, r1, r0);
     else {
@@ -1716,9 +1716,9 @@ _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_mulr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                t0, t1;
+    int32_t            t0, t1;
     t0 = jit_get_reg(jit_class_fpr);
     t1 = jit_get_reg(jit_class_fpr);
     stxi(alloca_offset - 8, _FP_REGNO, r1);
@@ -1733,9 +1733,9 @@ _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_muli(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 != r1) {
        movi(r0, i0);
        mulr(r0, r1, r0);
@@ -1756,7 +1756,7 @@ __llmul(int u, int v)
 
 static void
 _qmulr(jit_state_t *_jit,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
     movr(_R26_REGNO, r2);
     movr(_R25_REGNO, r3);
@@ -1767,7 +1767,7 @@ _qmulr(jit_state_t *_jit,
 
 static void
 _qmuli(jit_state_t *_jit,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
     movr(_R26_REGNO, r2);
     movi(_R25_REGNO, i0);
@@ -1778,9 +1778,9 @@ _qmuli(jit_state_t *_jit,
 
 static void
 _qmulr_u(jit_state_t *_jit,
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
-    jit_int32_t                t0, t1;
+    int32_t            t0, t1;
     t0 = jit_get_reg(jit_class_fpr);
     t1 = jit_get_reg(jit_class_fpr);
     stxi(alloca_offset - 8, _FP_REGNO, r2);
@@ -1797,9 +1797,9 @@ _qmulr_u(jit_state_t *_jit,
 
 static void
 _qmuli_u(jit_state_t *_jit,
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     qmulr_u(r0, r1, r2, rn(reg));
@@ -1813,7 +1813,7 @@ __idiv(int u, int v)
 }
 
 static void
-_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     movr(_R26_REGNO, r1);
     movr(_R25_REGNO, r2);
@@ -1822,7 +1822,7 @@ _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     movr(_R26_REGNO, r1);
     movi(_R25_REGNO, i0);
@@ -1837,7 +1837,7 @@ __udiv(unsigned int u, unsigned int v)
 }
 
 static void
-_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     movr(_R26_REGNO, r1);
     movr(_R25_REGNO, r2);
@@ -1846,7 +1846,7 @@ _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     movr(_R26_REGNO, r1);
     movi(_R25_REGNO, i0);
@@ -1861,7 +1861,7 @@ __irem(int u, int v)
 }
 
 static void
-_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     movr(_R26_REGNO, r1);
     movr(_R25_REGNO, r2);
@@ -1870,7 +1870,7 @@ _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     movr(_R26_REGNO, r1);
     movi(_R25_REGNO, i0);
@@ -1885,7 +1885,7 @@ __urem(unsigned int u, unsigned int v)
 }
 
 static void
-_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     movr(_R26_REGNO, r1);
     movr(_R25_REGNO, r2);
@@ -1894,7 +1894,7 @@ _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     movr(_R26_REGNO, r1);
     movi(_R25_REGNO, i0);
@@ -1913,7 +1913,7 @@ __idivrem(int u, int v)
 
 static void
 _qdivr(jit_state_t *_jit,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
     movr(_R26_REGNO, r2);
     movr(_R25_REGNO, r3);
@@ -1924,7 +1924,7 @@ _qdivr(jit_state_t *_jit,
 
 static void
 _qdivi(jit_state_t *_jit,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
     movr(_R26_REGNO, r2);
     movi(_R25_REGNO, i0);
@@ -1944,7 +1944,7 @@ __udivrem(unsigned int u, unsigned int v)
 
 static void
 _qdivr_u(jit_state_t *_jit,
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 {
     movr(_R26_REGNO, r2);
     movr(_R25_REGNO, r3);
@@ -1955,7 +1955,7 @@ _qdivr_u(jit_state_t *_jit,
 
 static void
 _qdivi_u(jit_state_t *_jit,
-        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
+        int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
 {
     movr(_R26_REGNO, r2);
     movi(_R25_REGNO, i0);
@@ -1965,9 +1965,9 @@ _qdivi_u(jit_state_t *_jit,
 }
 
 static void
-_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_andi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     andr(r0, r1, rn(reg));
@@ -1975,9 +1975,9 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     orr(r0, r1, rn(reg));
@@ -1985,9 +1985,9 @@ _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_xori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     xorr(r0, r1, rn(reg));
@@ -1995,7 +1995,7 @@ _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_lshr(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
     SUBI(0x1f, r2, _R1_REGNO);
     MTSAR(_R1_REGNO);
@@ -2003,7 +2003,7 @@ _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_rshr(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
     SUBI(0x1f, r2, _R1_REGNO);
     MTSAR(_R1_REGNO);
@@ -2011,7 +2011,7 @@ _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_rshr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
     SUBI(0x1f, r2, _R1_REGNO);
     MTSAR(_R1_REGNO);
@@ -2020,7 +2020,7 @@ _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 
 static void
 _cmpr(jit_state_t *_jit, jit_word_t c,
-      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+      int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPCLR_(c, r1, r2, r0);
     LDI(1, r0);
@@ -2028,9 +2028,9 @@ _cmpr(jit_state_t *_jit, jit_word_t c,
 
 static void
 _cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
-      jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+      int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        CMPICLR_(ci, i0, r1, r0);
     else {
@@ -2043,37 +2043,37 @@ _cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
 }
 
 static void
-_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_uc(r0, r1);
     extr_c(r0, r0);
 }
 
 static void
-_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     ldi_uc(r0, i0);
     extr_c(r0, r0);
 }
 
 static void
-_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     ldxr_uc(r0, r1, r2);
     extr_c(r0, r0);
 }
 
 static void
-_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi_uc(r0, r1, i0);
     extr_c(r0, r0);
 }
 
 static void
-_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -8182 && i0 <= 8191)
        LDBL(i0, _R0_REGNO, r0);
     else {
@@ -2085,9 +2085,9 @@ _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        LDBI(i0, r1, r0);
     else if (i0 >= -8182 && i0 <= 8191)
@@ -2101,37 +2101,37 @@ _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_us(r0, r1);
     extr_s(r0, r0);
 }
 
 static void
-_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     ldi_us(r0, i0);
     extr_s(r0, r0);
 }
 
 static void
-_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     ldxr_us(r0, r1, r2);
     extr_s(r0, r0);
 }
 
 static void
-_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi_us(r0, r1, i0);
     extr_s(r0, r0);
 }
 
 static void
-_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -8182 && i0 <= 8191)
        LDHL(i0, _R0_REGNO, r0);
     else {
@@ -2143,9 +2143,9 @@ _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        LDHI(i0, r1, r0);
     else if (i0 >= -8182 && i0 <= 8191)
@@ -2159,9 +2159,9 @@ _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -8182 && i0 <= 8191)
        LDWL(i0, _R0_REGNO, r0);
     else {
@@ -2173,9 +2173,9 @@ _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        LDWI(i0, r1, r0);
     else if (i0 >= -8182 && i0 <= 8191)
@@ -2189,9 +2189,9 @@ _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -8182 && i0 <= 8191)
        STBL(r0, i0, _R0_REGNO);
     else {
@@ -2203,9 +2203,9 @@ _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_c(rn(reg), r2);
@@ -2213,9 +2213,9 @@ _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        STBI(r1, i0, r0);
     else if (i0 >= -8182 && i0 <= 8191)
@@ -2229,9 +2229,9 @@ _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -8182 && i0 <= 8191)
        STHL(r0, i0, _R0_REGNO);
     else {
@@ -2243,9 +2243,9 @@ _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_stxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_s(rn(reg), r2);
@@ -2253,9 +2253,9 @@ _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        STHI(r1, i0, r0);
     else if (i0 >= -8182 && i0 <= 8191)
@@ -2269,9 +2269,9 @@ _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -8182 && i0 <= 8191)
        STWL(r0, i0, _R0_REGNO);
     else {
@@ -2283,9 +2283,9 @@ _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_stxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_i(rn(reg), r2);
@@ -2293,9 +2293,9 @@ _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        STWI(r1, i0, r0);
     else if (i0 >= -8182 && i0 <= 8191)
@@ -2310,7 +2310,7 @@ _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 
 static jit_word_t
 _bcmpr(jit_state_t *_jit, jit_word_t c,
-       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+       jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     w = _jit->pc.w;
@@ -2321,10 +2321,10 @@ _bcmpr(jit_state_t *_jit, jit_word_t c,
 
 static jit_word_t
 _bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
-       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+       jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -16 && i1 <= 15) {
        w = _jit->pc.w;
        CMPIB_N_(ci, i1, r0, ((i0 - w) >> 2) - 2);
@@ -2342,10 +2342,10 @@ _bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
 
 static jit_word_t
 _bmxr(jit_state_t *_jit, jit_bool_t c,
-      jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+      jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     andr(rn(reg), r0, r1);
     w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
@@ -2355,10 +2355,10 @@ _bmxr(jit_state_t *_jit, jit_bool_t c,
 
 static jit_word_t
 _bmxi(jit_state_t *_jit, jit_bool_t c,
-      jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+      jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     andr(rn(reg), r0, rn(reg));
@@ -2368,7 +2368,7 @@ _bmxi(jit_state_t *_jit, jit_bool_t c,
 }
 
 static jit_word_t
-_boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_boaddr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     w = _jit->pc.w;
@@ -2378,10 +2378,10 @@ _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_boaddi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -16 && i1 <= 15) {
        w = _jit->pc.w;
        ADDIB_N_SV(i1, r0, ((i0 - w) >> 2) - 2);
@@ -2397,7 +2397,7 @@ _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_boaddr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     w = _jit->pc.w;
@@ -2407,10 +2407,10 @@ _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_boaddi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -16 && i1 <= 15) {
        w = _jit->pc.w;
        ADDIB_N_UV(i1, r0, ((i0 - w) >> 2) - 2);
@@ -2426,7 +2426,7 @@ _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxaddr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     w = _jit->pc.w;
@@ -2436,10 +2436,10 @@ _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxaddi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -16 && i1 <= 15) {
        w = _jit->pc.w;
        ADDIB_N_NSV(i1, r0, ((i0 - w) >> 2) - 2);
@@ -2455,7 +2455,7 @@ _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxaddr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     w = _jit->pc.w;
@@ -2465,10 +2465,10 @@ _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxaddi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -16 && i1 <= 15) {
        w = _jit->pc.w;
        ADDIB_N_NUV(i1, r0, ((i0 - w) >> 2) - 2);
@@ -2484,7 +2484,7 @@ _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bosubr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     SUB_NSV(r0, r1, r0);
@@ -2496,14 +2496,14 @@ _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bosubi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     movi(_R1_REGNO, i1);
     return (bosubr(i0, r0, _R1_REGNO));
 }
 
 static jit_word_t
-_bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bosubr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     SUB(r0, r1, r0);
     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
@@ -2511,7 +2511,7 @@ _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bosubi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     movi(_R1_REGNO, i1);
     SUB(r0, _R1_REGNO, r0);
@@ -2520,7 +2520,7 @@ _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxsubr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     SUB_SV(r0, r1, r0);
@@ -2532,14 +2532,14 @@ _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxsubi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     movi(_R1_REGNO, i1);
     return (bxsubr(i0, r0, _R1_REGNO));
 }
 
 static jit_word_t
-_bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxsubr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     SUB(r0, r1, r0);
     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
@@ -2547,7 +2547,7 @@ _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxsubi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     movi(_R1_REGNO, i1);
     SUB(r0, _R1_REGNO, r0);
@@ -2556,7 +2556,7 @@ _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static void
-_jmpr(jit_state_t *_jit, jit_int32_t r0)
+_jmpr(jit_state_t *_jit, int32_t r0)
 {
     BV_N(_R0_REGNO, r0);
 }
@@ -2584,7 +2584,7 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0)
 }
 
 static void
-_callr(jit_state_t *_jit, jit_int32_t r0)
+_callr(jit_state_t *_jit, int32_t r0)
 {
     jit_word_t         dyn;
     jit_word_t         imm;
@@ -2640,13 +2640,13 @@ _calli_p(jit_state_t *_jit, jit_word_t i0)
     return (w);
 }
 
-static jit_int32_t gr[] = {
+static int32_t gr[] = {
      _R4,  _R5,  _R6,  _R7,  _R8,
      _R9, _R10, _R11, _R12, _R13,
     _R14, _R15, _R16, _R17, _R18
 };
 
-static jit_int32_t fr[] = {
+static int32_t fr[] = {
     _F12, _F13, _F14, _F15, _F16,
     _F17, _F18, _F19, _F20, _F21
 };
@@ -2654,7 +2654,7 @@ static jit_int32_t fr[] = {
 static void
 _prolog(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     jit_word_t         offset;
 
     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
@@ -2707,7 +2707,7 @@ _prolog(jit_state_t *_jit, jit_node_t *node)
 static void
 _epilog(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     jit_word_t         offset;
 
     if (_jitc->function->assume_frame)
@@ -2735,14 +2735,14 @@ _epilog(jit_state_t *_jit, jit_node_t *node)
 }
 
 static void
-_vastart(jit_state_t *_jit, jit_int32_t r0)
+_vastart(jit_state_t *_jit, int32_t r0)
 {
     /* Initialize stack pointer to the first stack argument. */
     addi(r0, _FP_REGNO, params_offset - _jitc->function->vagp * 4);
 }
 
 static void
-_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
 
@@ -2758,7 +2758,7 @@ _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t 
label)
 {
     jit_word_t          w;
     union {
-       jit_uint32_t    *i;
+       uint32_t        *i;
        jit_word_t       w;
     } u;
     u.w = instr;
diff --git a/jit/hppa-fpu.c b/jit/hppa-fpu.c
index c0e85ba..861076e 100644
--- a/jit/hppa-fpu.c
+++ b/jit/hppa-fpu.c
@@ -28,44 +28,44 @@
 #endif
 
 #define f39(o,b,x,t)                   _f39(_jit,o,b,x,t)
-static void _f39(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f39(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f40(o,b,x,r)                   _f40(_jit,o,b,x,r)
-static void _f40(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
+static void _f40(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
     maybe_unused;
 #define f41(o,b,x,t)                   _f41(_jit,o,b,x,t)
-static void _f41(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f41(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f42(o,b,i,r)                   _f42(_jit,o,b,i,r)
-static void _f42(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f42(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f43(o,b,t,i)                   f1(o,b,t,i)
 #define f45(o,r,a,b,fmt,c,d,e,t)       _f45(_jit,o,r,a,b,fmt,c,d,e,t)
-static void _f45(jit_state_t*,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f45(jit_state_t*,int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f46(o,r,a,s,df,sf,b,c,d,t)     _f46(_jit,o,r,a,s,df,sf,b,c,d,t)
-static void _f46(jit_state_t*,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f46(jit_state_t*,int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f47(o,r1,r2,a,fmt,b,c,d,t)     f47_48(o,r1,r2,a,fmt,b,c,d,t)
 #define f48(o,r1,r2,a,fmt,b,c,d,t)     f47_48(o,r1,r2,a,fmt,b,c,d,t)
 #define f47_48(o,r1,r2,y,fmt,b,c,d,t)  _f47_48(_jit,o,r1,r2,y,fmt,b,c,d,t)
-static void _f47_48(jit_state_t*,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f47_48(jit_state_t*,int32_t,
+                   int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f49(o,r,a,b,c,f,d,e,g,h,i,t)   f49_52(o,r,a,b,c,f,d,e,g,h,i,t)
 #define f51(o,r1,r2,y,a,f,b,d,e,g,h,c) f49_52(o,r1,r2,y,a,f,b,d,e,g,h,c)
 #define f52(o,r1,r2,a,b,f,c,d,e,g,h,t) f49_52(o,r1,r2,a,b,f,c,d,e,g,h,t)
 #define f49_52(o,r1,r2,y,v,f,a,b,u,c,d,t) 
_f49_52(_jit,o,r1,r2,y,v,f,a,b,u,c,d,t)
-static void _f49_52(jit_state_t*,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _f49_52(jit_state_t*,int32_t,
+                   int32_t,jit_int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #define f53(o,r1,r2,ta,ra,f,tm)                _f53(_jit,o,r1,r2,ta,ra,f,tm)
-static void _f53(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f53(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define f54(o,r1,r2,a,b,f,c,d,e,g,t)   _f54(_jit,o,r1,r2,a,b,f,c,d,e,g,t)
-static void _f54(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-                jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
+static void _f54(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+                int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 #define FABS_(f,r,t)                   f49(0xe,r,0,3,0,f,0,0,0,0,0,t)
 #define FABS_S(r,t)                    FABS_(0,r,t)
 #define FABS_D(r,t)                    FABS_(1,r,t)
@@ -271,67 +271,67 @@ static void 
_f54(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
 #define sqrtr_f(r0,r1)                 FSQRT_S(r1,r0)
 #define sqrtr_d(r0,r1)                 FSQRT_D(r1,r0)
 #define extr_f(r0,r1)                  _extr_f(_jit,r0,r1)
-static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_f(jit_state_t*,int32_t,jit_int32_t);
 #define extr_d(r0,r1)                  _extr_d(_jit,r0,r1)
-static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_d(jit_state_t*,int32_t,jit_int32_t);
 #define extr_f_d(r0,r1)                        FCNVFF_S_D(r1,r0)
 #define extr_d_f(r0,r1)                        FCNVFF_D_S(r1,r0)
 #define truncr_f(r0,r1)                        truncr_f_i(r0,r1)
 #define truncr_f_i(r0,r1)              _truncr_f_i(_jit,r0,r1)
-static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_f_i(jit_state_t*,int32_t,jit_int32_t);
 #define truncr_d(r0,r1)                        truncr_d_i(r0,r1)
 #define truncr_d_i(r0,r1)              _truncr_d_i(_jit,r0,r1)
-static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_d_i(jit_state_t*,int32_t,jit_int32_t);
 #define movr_f(r0,r1)                  FCPY_S(r1,r0)
 #define movi_f(r0,i0)                  _movi_f(_jit,r0,i0)
-static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
+static void _movi_f(jit_state_t*,int32_t,jit_float32_t*);
 #define movr_d(r0,r1)                  FCPY_D(r1,r0)
 #define movi_d(r0,i0)                  _movi_d(_jit,r0,i0)
-static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
+static void _movi_d(jit_state_t*,int32_t,jit_float64_t*);
 #define absr_f(r0,r1)                  FABS_S(r1,r0)
 #define absr_d(r0,r1)                  FABS_D(r1,r0)
 #define addr_f(r0,r1,r2)               FADD_S(r1,r2,r0)
 #define addi_f(r0,r1,i0)               _addi_f(_jit,r0,r1,i0)
-static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _addi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define addr_d(r0,r1,r2)               FADD_D(r1,r2,r0)
 #define addi_d(r0,r1,i0)               _addi_d(_jit,r0,r1,i0)
-static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _addi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define subr_f(r0,r1,r2)               FSUB_S(r1,r2,r0)
 #define subi_f(r0,r1,i0)               _subi_f(_jit,r0,r1,i0)
-static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _subi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define subr_d(r0,r1,r2)               FSUB_D(r1,r2,r0)
 #define subi_d(r0,r1,i0)               _subi_d(_jit,r0,r1,i0)
-static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _subi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define rsbr_f(r0,r1,r2)               subr_f(r0,r2,r1)
 #define rsbi_f(r0,r1,i0)               _rsbi_f(_jit,r0,r1,i0)
-static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _rsbi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define rsbr_d(r0,r1,r2)               subr_d(r0,r2,r1)
 #define rsbi_d(r0,r1,i0)               _rsbi_d(_jit,r0,r1,i0)
-static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _rsbi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define mulr_f(r0,r1,r2)               FMPY_S(r1,r2,r0)
 #define muli_f(r0,r1,i0)               _muli_f(_jit,r0,r1,i0)
-static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _muli_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define mulr_d(r0,r1,r2)               FMPY_D(r1,r2,r0)
 #define muli_d(r0,r1,i0)               _muli_d(_jit,r0,r1,i0)
-static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _muli_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define divr_f(r0,r1,r2)               FDIV_S(r1,r2,r0)
 #define divi_f(r0,r1,i0)               _divi_f(_jit,r0,r1,i0)
-static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _divi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define divr_d(r0,r1,r2)               FDIV_D(r1,r2,r0)
 #define divi_d(r0,r1,i0)               _divi_d(_jit,r0,r1,i0)
-static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _divi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define cmpr_f(c,r0,r1,r2)             _cmpr_f(_jit,c,r0,r1,r2)
 static void _cmpr_f(jit_state_t*,jit_word_t,
-                   jit_int32_t,jit_int32_t,jit_int32_t);
+                   int32_t,jit_int32_t,jit_int32_t);
 #define cmpi_f(c,r0,r1,i0)             _cmpi_f(_jit,c,r0,r1,i0)
 static void _cmpi_f(jit_state_t*,jit_word_t,
-                   jit_int32_t,jit_int32_t,jit_float32_t*);
+                   int32_t,jit_int32_t,jit_float32_t*);
 #define cmpr_d(c,r0,r1,r2)             _cmpr_d(_jit,c,r0,r1,r2)
 static void _cmpr_d(jit_state_t*,jit_word_t,
-                   jit_int32_t,jit_int32_t,jit_int32_t);
+                   int32_t,jit_int32_t,jit_int32_t);
 #define cmpi_d(c,r0,r1,i0)             _cmpi_d(_jit,c,r0,r1,i0)
 static void _cmpi_d(jit_state_t*,jit_word_t,
-                   jit_int32_t,jit_int32_t,jit_float64_t*);
+                   int32_t,jit_int32_t,jit_float64_t*);
 #define ltr_f(r0,r1,r2)                        cmpr_f(FCMP_LT,r0,r1,r2)
 #define lti_f(r0,r1,i0)                        cmpi_f(FCMP_LT,r0,r1,i0)
 #define ltr_d(r0,r1,r2)                        cmpr_d(FCMP_LT,r0,r1,r2)
@@ -390,47 +390,47 @@ static void _cmpi_d(jit_state_t*,jit_word_t,
 #define unordi_d(r0,r1,i0)             cmpi_d(FCMP_UNORD,r0,r1,i0)
 #define ldr_f(r0,r1)                   FLDWI(0,r1,r0)
 #define ldi_f(r0,i0)                   _ldi_f(_jit,r0,i0)
-static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_f(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_f(r0,r1,r2)               FLDW(r2,r1,r0)
 #define ldxi_f(r0,r1,i0)               _ldxi_f(_jit,r0,r1,i0)
-static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_f(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldr_d(r0,r1)                   FLDDI(0,r1,r0)
 #define ldi_d(r0,i0)                   _ldi_d(_jit,r0,i0)
-static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_d(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_d(r0,r1,r2)               FLDD(r2,r1,r0)
 #define ldxi_d(r0,r1,i0)               _ldxi_d(_jit,r0,r1,i0)
-static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_d(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define str_f(r0,r1)                   FSTWI(r1,0,r0)
 #define sti_f(i0,r0)                   _sti_f(_jit,i0,r0)
-static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_f(jit_state_t*,jit_word_t,int32_t);
 #if FSTXR
 #  define stxr_f(r0,r1,r2)             FSTW(r2,r1,r0)
 #  define stxr_d(r0,r1,r2)             FSTD(r2,r1,r0)
 #else
 #  define stxr_f(r0,r1,r2)             _stxr_f(_jit,r0,r1,r2)
-static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxr_d(r0,r1,r2)             _stxr_d(_jit,r0,r1,r2)
-static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #endif
 #define stxi_f(i0,r0,r1)               _stxi_f(_jit,i0,r0,r1)
-static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define str_d(r0,r1)                   FSTDI(r1,0,r0)
 #define sti_d(i0,r0)                   _sti_d(_jit,i0,r0)
-static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_d(jit_state_t*,jit_word_t,int32_t);
 #define stxi_d(i0,r0,r1)               _stxi_d(_jit,i0,r0,r1)
-static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bcmpr_f(c,i0,r0,r1)            _bcmpr_f(_jit,c,i0,r0,r1)
 static jit_word_t _bcmpr_f(jit_state_t*,jit_word_t,
-                          jit_word_t,jit_int32_t,jit_int32_t);
+                          jit_word_t,int32_t,jit_int32_t);
 #define bcmpi_f(c,i0,r0,i1)            _bcmpi_f(_jit,c,i0,r0,i1)
 static jit_word_t _bcmpi_f(jit_state_t*,jit_word_t,
-                          jit_word_t,jit_int32_t,jit_float32_t*);
+                          jit_word_t,int32_t,jit_float32_t*);
 #define bcmpr_d(c,i0,r0,r1)            _bcmpr_d(_jit,c,i0,r0,r1)
 static jit_word_t _bcmpr_d(jit_state_t*,jit_word_t,
-                          jit_word_t,jit_int32_t,jit_int32_t);
+                          jit_word_t,int32_t,jit_int32_t);
 #define bcmpi_d(c,i0,r0,i1)            _bcmpi_d(_jit,c,i0,r0,i1)
 static jit_word_t _bcmpi_d(jit_state_t*,jit_word_t,
-                          jit_word_t,jit_int32_t,jit_float64_t*);
+                          jit_word_t,int32_t,jit_float64_t*);
 #define bltr_f(i0,r0,r1)               bcmpr_f(FCMP_LT,i0,r0,r1)
 #define blti_f(i0,r0,i1)               bcmpi_f(FCMP_LT,i0,r0,i1)
 #define bltr_d(i0,r0,r1)               bcmpr_d(FCMP_LT,i0,r0,r1)
@@ -488,13 +488,13 @@ static jit_word_t _bcmpi_d(jit_state_t*,jit_word_t,
 #define bunordr_d(i0,r0,r1)            bcmpr_d(FCMP_UNORD,i0,r0,r1)
 #define bunordi_d(i0,r0,i1)            bcmpi_d(FCMP_UNORD,i0,r0,i1)
 #define vaarg_d(r0, r1)                        _vaarg_d(_jit, r0, r1)
-static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg_d(jit_state_t*, int32_t, jit_int32_t);
 #endif
 
 #if CODE
 static void
-_f39(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t b, jit_int32_t x, jit_int32_t t)
+_f39(jit_state_t *_jit, int32_t o,
+     int32_t b, jit_int32_t x, jit_int32_t t)
 {
     assert(!(o & ~0x3f));
     assert(!(b & ~0x1f));
@@ -504,8 +504,8 @@ _f39(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f40(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t b, jit_int32_t x, jit_int32_t r)
+_f40(jit_state_t *_jit, int32_t o,
+     int32_t b, jit_int32_t x, jit_int32_t r)
 {
     assert(!(o & ~0x3f));
     assert(!(b & ~0x1f));
@@ -515,8 +515,8 @@ _f40(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f41(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t b, jit_int32_t x, jit_int32_t t)
+_f41(jit_state_t *_jit, int32_t o,
+     int32_t b, jit_int32_t x, jit_int32_t t)
 {
     assert(!(o & ~0x3f));
     assert(!(b & ~0x1f));
@@ -526,8 +526,8 @@ _f41(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f42(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t b, jit_int32_t i, jit_int32_t r)
+_f42(jit_state_t *_jit, int32_t o,
+     int32_t b, jit_int32_t i, jit_int32_t r)
 {
     assert(!(o & ~0x3f));
     assert(!(b & ~0x1f));
@@ -537,9 +537,9 @@ _f42(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f45(jit_state_t *_jit, jit_int32_t o,
-     jit_int32_t r, jit_int32_t a, jit_int32_t b, jit_int32_t fmt,
-     jit_int32_t c, jit_int32_t d, jit_int32_t e, jit_int32_t t)
+_f45(jit_state_t *_jit, int32_t o,
+     int32_t r, jit_int32_t a, jit_int32_t b, jit_int32_t fmt,
+     int32_t c, jit_int32_t d, jit_int32_t e, jit_int32_t t)
 {
     assert(!(o   & ~0x3f));
     assert(!(r   & ~0x1f));
@@ -554,9 +554,9 @@ _f45(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f46(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
-     jit_int32_t a, jit_int32_t s, jit_int32_t df, jit_int32_t sf,
-     jit_int32_t b, jit_int32_t c, jit_int32_t d, jit_int32_t t)
+_f46(jit_state_t *_jit, int32_t o, jit_int32_t r,
+     int32_t a, jit_int32_t s, jit_int32_t df, jit_int32_t sf,
+     int32_t b, jit_int32_t c, jit_int32_t d, jit_int32_t t)
 {
     assert(!(o  & ~0x3f));
     assert(!(r  & ~0x1f));
@@ -573,9 +573,9 @@ _f46(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
 }
 
 static void
-_f47_48(jit_state_t *_jit, jit_int32_t o,
-       jit_int32_t r2, jit_int32_t r1, jit_int32_t y, jit_int32_t fmt,
-       jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t t)
+_f47_48(jit_state_t *_jit, int32_t o,
+       int32_t r2, jit_int32_t r1, jit_int32_t y, jit_int32_t fmt,
+       int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t t)
 {
     assert(!(o   & ~0x3f));
     assert(!(r2  & ~0x1f));
@@ -590,10 +590,10 @@ _f47_48(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f49_52(jit_state_t *_jit, jit_int32_t o,
-       jit_int32_t r1, jit_int32_t r2, jit_int32_t y,
-       jit_int32_t v, jit_int32_t f, jit_int32_t a, jit_int32_t b,
-       jit_int32_t u, jit_int32_t c, jit_int32_t d, jit_int32_t t)
+_f49_52(jit_state_t *_jit, int32_t o,
+       int32_t r1, jit_int32_t r2, jit_int32_t y,
+       int32_t v, jit_int32_t f, jit_int32_t a, jit_int32_t b,
+       int32_t u, jit_int32_t c, jit_int32_t d, jit_int32_t t)
 {
     assert(!(o  & ~0x3f));
     assert(!(r1 & ~0x1f));
@@ -612,8 +612,8 @@ _f49_52(jit_state_t *_jit, jit_int32_t o,
 }
 
 static void
-_f53(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2,
-     jit_int32_t ta, jit_int32_t ra, jit_int32_t f, jit_int32_t tm)
+_f53(jit_state_t *_jit, int32_t o, jit_int32_t r1, jit_int32_t r2,
+     int32_t ta, jit_int32_t ra, jit_int32_t f, jit_int32_t tm)
 {
     assert(!(o  & ~0x3f));
     assert(!(r1 & ~0x1f));
@@ -629,9 +629,9 @@ _f53(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, 
jit_int32_t r2,
 }
 
 static void
-_f54(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, jit_int32_t r2,
-     jit_int32_t a, jit_int32_t b, jit_int32_t f, jit_int32_t c,
-     jit_int32_t d, jit_int32_t e, jit_int32_t g, jit_int32_t t)
+_f54(jit_state_t *_jit, int32_t o, jit_int32_t r1, jit_int32_t r2,
+     int32_t a, jit_int32_t b, jit_int32_t f, jit_int32_t c,
+     int32_t d, jit_int32_t e, jit_int32_t g, jit_int32_t t)
 {
     assert(!(o  & ~0x3f));
     assert(!(r1 & ~0x1f));
@@ -649,7 +649,7 @@ _f54(jit_state_t *_jit, jit_int32_t o, jit_int32_t r1, 
jit_int32_t r2,
 }
 
 static void
-_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     stxi(alloca_offset - 8, _FP_REGNO, r1);
     ldxi_f(r0, _FP_REGNO, alloca_offset - 8);
@@ -657,7 +657,7 @@ _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     stxi(alloca_offset - 8, _FP_REGNO, r1);
     ldxi_f(r0, _FP_REGNO, alloca_offset - 8);
@@ -665,9 +665,9 @@ _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_f_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     FCNVXT_S_S(r1, rn(reg));
     stxi_f(alloca_offset - 8, _FP_REGNO, rn(reg));
@@ -676,9 +676,9 @@ _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_d_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     FCNVXT_D_S(r1, rn(reg));
     stxi_d(alloca_offset - 8, _FP_REGNO, rn(reg));
@@ -687,13 +687,13 @@ _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
+_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t *i0)
 {
     union {
-       jit_int32_t      i;
+       int32_t  i;
        jit_float32_t    f;
     } data;
-    jit_int32_t                 reg;
+    int32_t             reg;
 
     if (_jitc->no_data) {
        data.f = *i0;
@@ -708,14 +708,14 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t 
*i0)
 }
 
 static void
-_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
+_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t *i0)
 {
     union {
-       jit_int32_t      ii[2];
+       int32_t  ii[2];
        jit_word_t       w;
        jit_float64_t    d;
     } data;
-    jit_int32_t                 reg;
+    int32_t             reg;
 
     data.d = *i0;
     if (_jitc->no_data) {
@@ -735,10 +735,10 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t 
*i0)
 #define fpr_opi(name, type, size)                                      \
 static void                                                            \
 _##name##i_##type(jit_state_t *_jit,                                   \
-                 jit_int32_t r0, jit_int32_t r1,                       \
+                 int32_t r0, jit_int32_t r1,                   \
                  jit_float##size##_t *i0)                              \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     movi_##type(rn(reg), i0);                                          \
     name##r_##type(r0, r1, rn(reg));                                   \
     jit_unget_reg(reg);                                                        
\
@@ -759,7 +759,7 @@ dopi(div)
 
 static void
 _cmpr_f(jit_state_t *_jit, jit_word_t c,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     LDI(0, r0);
     FCMP_S_(r1, r2, c);
@@ -769,9 +769,9 @@ _cmpr_f(jit_state_t *_jit, jit_word_t c,
 
 static void
 _cmpi_f(jit_state_t *_jit, jit_word_t c,
-       jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
+       int32_t r0, jit_int32_t r1, jit_float32_t *i0)
 {
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);
+    int32_t            reg = jit_get_reg(jit_class_fpr);
     movi_f(rn(reg), i0);
     cmpr_f(c, r0, r1, rn(reg));
     jit_unget_reg(reg);
@@ -779,7 +779,7 @@ _cmpi_f(jit_state_t *_jit, jit_word_t c,
 
 static void
 _cmpr_d(jit_state_t *_jit, jit_word_t c,
-       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+       int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     LDI(0, r0);
     FCMP_D_(r1, r2, c);
@@ -789,18 +789,18 @@ _cmpr_d(jit_state_t *_jit, jit_word_t c,
 
 static void
 _cmpi_d(jit_state_t *_jit, jit_word_t c,
-       jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
+       int32_t r0, jit_int32_t r1, jit_float64_t *i0)
 {
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);
+    int32_t            reg = jit_get_reg(jit_class_fpr);
     movi_d(rn(reg), i0);
     cmpr_d(c, r0, r1, rn(reg));
     jit_unget_reg(reg);
 }
 
 static void
-_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 3));
     if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
        FLDWL(i0, _R0_REGNO, r0);
@@ -813,9 +813,9 @@ _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        FLDWI(i0, r1, r0);
     /* |im11a|0|t|i| */
@@ -830,9 +830,9 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 7));
     if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
        FLDDL(i0, _R0_REGNO, r0);
@@ -845,9 +845,9 @@ _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        FLDDI(i0, r1, r0);
     /* |im10a|m|a|1|i| */
@@ -862,9 +862,9 @@ _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 3));
     if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 6))
        FSTWL(r0, i0, _R0_REGNO);
@@ -878,9 +878,9 @@ _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 
 #if !FSTXR
 static void
-_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_f(rn(reg), r2);
@@ -888,9 +888,9 @@ _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_d(rn(reg), r2);
@@ -899,9 +899,9 @@ _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 #endif
 
 static void
-_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        FSTWI(r1, i0, r0);
     /* |im11a|0|t|i| */
@@ -921,9 +921,9 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(!(i0 & 7));
     if (i0 >= -8192 && i0 <= 8191 && !(re_assemble_16(i0) & 14))
        FSTDL(r0, i0, _R0_REGNO);
@@ -936,9 +936,9 @@ _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -16 && i0 <= 15)
        FSTDI(r1, i0, r0);
     /* |im10a|m|a|1|i| */
@@ -959,7 +959,7 @@ _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 
 static jit_word_t
 _bcmpr_f(jit_state_t *_jit, jit_word_t c,
-        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+        jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_S_(r0, r1, c);
@@ -972,10 +972,10 @@ _bcmpr_f(jit_state_t *_jit, jit_word_t c,
 
 static jit_word_t
 _bcmpi_f(jit_state_t *_jit, jit_word_t c,
-        jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
+        jit_word_t i0, int32_t r0, jit_float32_t *i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi_f(rn(reg), i1);
     FCMP_S_(r0, rn(reg), c);
@@ -989,7 +989,7 @@ _bcmpi_f(jit_state_t *_jit, jit_word_t c,
 
 static jit_word_t
 _bcmpr_d(jit_state_t *_jit, jit_word_t c,
-        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+        jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_D_(r0, r1, c);
@@ -1002,10 +1002,10 @@ _bcmpr_d(jit_state_t *_jit, jit_word_t c,
 
 static jit_word_t
 _bcmpi_d(jit_state_t *_jit, jit_word_t c,
-        jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
+        jit_word_t i0, int32_t r0, jit_float64_t *i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
     movi_d(rn(reg), i1);
     FCMP_D_(r0, rn(reg), c);
@@ -1018,9 +1018,9 @@ _bcmpi_d(jit_state_t *_jit, jit_word_t c,
 }
 
 static void
-_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     assert(_jitc->function->self.call & jit_call_varargs);
 
diff --git a/jit/hppa.c b/jit/hppa.c
index 6b9ef3f..c1908e9 100644
--- a/jit/hppa.c
+++ b/jit/hppa.c
@@ -141,7 +141,7 @@ _jit_init(jit_state_t *_jit)
 void
 _jit_prolog(jit_state_t *_jit)
 {
-    jit_int32_t                offset;
+    int32_t            offset;
 
     if (_jitc->function)
        jit_epilog();
@@ -161,7 +161,7 @@ _jit_prolog(jit_state_t *_jit)
     _jitc->function->self.aoff = alloca_offset;
     _jitc->function->self.call = jit_call_default;
     jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
-             _jitc->reglen * sizeof(jit_int32_t));
+             _jitc->reglen * sizeof(int32_t));
 
     /* _no_link here does not mean the jit_link() call can be removed
      * by rewriting as:
@@ -180,10 +180,10 @@ _jit_prolog(jit_state_t *_jit)
     jit_regset_new(&_jitc->function->regset);
 }
 
-jit_int32_t
-_jit_allocai(jit_state_t *_jit, jit_int32_t length)
+int32_t
+_jit_allocai(jit_state_t *_jit, int32_t length)
 {
-    jit_int32_t                offset;
+    int32_t            offset;
     assert(_jitc->function);
     switch (length) {
        case 0: case 1:
@@ -208,13 +208,13 @@ _jit_allocai(jit_state_t *_jit, jit_int32_t length)
 }
 
 void
-_jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_allocar(jit_state_t *_jit, int32_t u, jit_int32_t v)
 {
-    jit_int32_t                 reg;
+    int32_t             reg;
     assert(_jitc->function);
     jit_inc_synth_ww(allocar, u, v);
     if (!_jitc->function->allocar) {
-       _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
+       _jitc->function->aoffoff = jit_allocai(sizeof(int32_t));
        _jitc->function->allocar = 1;
     }
     reg = jit_get_reg(jit_class_gpr);
@@ -240,7 +240,7 @@ _jit_ret(jit_state_t *_jit)
 }
 
 void
-_jit_retr(jit_state_t *_jit, jit_int32_t u)
+_jit_retr(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr, u);
     jit_movr(JIT_RET, u);
@@ -258,7 +258,7 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_f(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_f, u);
     jit_movr_f(JIT_FRET, u);
@@ -276,7 +276,7 @@ _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_d(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_d, u);
     jit_movr_d(JIT_FRET, u);
@@ -330,7 +330,7 @@ _jit_ellipsis(jit_state_t *_jit)
 }
 
 void
-_jit_va_push(jit_state_t *_jit, jit_int32_t u)
+_jit_va_push(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(va_push, u);
     jit_pushargr(u);
@@ -341,7 +341,7 @@ jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     _jitc->function->self.size -= sizeof(jit_word_t);
     if (jit_arg_reg_p(_jitc->function->self.argi))
@@ -358,7 +358,7 @@ jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     _jitc->function->self.size -= sizeof(jit_word_t);
     if (jit_arg_reg_p(_jitc->function->self.argi))
@@ -375,7 +375,7 @@ jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     if (_jitc->function->self.argi & 1) {
        ++_jitc->function->self.argi;
@@ -399,7 +399,7 @@ _jit_arg_d(jit_state_t *_jit)
 }
 
 void
-_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_c(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_c, u, v);
@@ -411,7 +411,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_uc(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_uc, u, v);
@@ -423,7 +423,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_s(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_s, u, v);
@@ -435,7 +435,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_us(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_us, u, v);
@@ -447,7 +447,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_i(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_i, u, v);
@@ -459,7 +459,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargr, u, v);
@@ -473,7 +473,7 @@ _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargi, u, v);
     if (v->u.w >= 0)
@@ -488,7 +488,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 }
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(getarg_f, u, v);
@@ -500,7 +500,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(putargr_f, u, v);
@@ -514,7 +514,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_fp(putargi_f, u, v);
     if (v->u.w >= 0)
@@ -529,7 +529,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, 
jit_node_t *v)
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(getarg_d, u, v);
@@ -541,7 +541,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(putargr_d, u, v);
@@ -555,7 +555,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_dp(putargi_d, u, v);
     if (v->u.w >= 0)
@@ -570,7 +570,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, 
jit_node_t *v)
 }
 
 void
-_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr, u);
@@ -588,7 +588,7 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_w(pushargi, u);
     jit_link_prepare();
@@ -607,7 +607,7 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_f(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_f, u);
@@ -634,7 +634,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_f(pushargi_f, u);
     jit_link_prepare();
@@ -663,7 +663,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_d(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_d, u);
@@ -700,7 +700,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_d(pushargi_d, u);
     jit_link_prepare();
@@ -737,9 +737,9 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 }
 
 jit_bool_t
-_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, int32_t regno)
 {
-    jit_int32_t                spec;
+    int32_t            spec;
     spec = jit_class(_rvs[regno].spec);
     if (spec & jit_class_arg) {
        if (spec & jit_class_gpr) {
@@ -757,7 +757,7 @@ _jit_regarg_p(jit_state_t *_jit, jit_node_t *node, 
jit_int32_t regno)
 }
 
 void
-_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
+_jit_finishr(jit_state_t *_jit, int32_t r0)
 {
     jit_node_t         *call;
     assert(_jitc->function);
@@ -788,7 +788,7 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
 }
 
 void
-_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_c(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_c, r0);
     jit_extr_c(r0, JIT_RET);
@@ -796,7 +796,7 @@ _jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_uc(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_uc, r0);
     jit_extr_uc(r0, JIT_RET);
@@ -804,7 +804,7 @@ _jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_s(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_s, r0);
     jit_extr_s(r0, JIT_RET);
@@ -812,7 +812,7 @@ _jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_us(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_us, r0);
     jit_extr_us(r0, JIT_RET);
@@ -820,7 +820,7 @@ _jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_i(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_i, r0);
     jit_movr(r0, JIT_RET);
@@ -828,7 +828,7 @@ _jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_f(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_f, r0);
     jit_movr_f(r0, JIT_FRET);
@@ -836,7 +836,7 @@ _jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_d(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_d, r0);
     jit_movr_d(r0, JIT_FRET);
@@ -849,15 +849,15 @@ _emit_code(jit_state_t *_jit)
     jit_node_t         *node;
     jit_node_t         *temp;
     jit_word_t          word;
-    jit_int32_t                 value;
-    jit_int32_t                 offset;
+    int32_t             value;
+    int32_t             offset;
     struct {
        jit_node_t      *node;
        jit_word_t       word;
 #if DEVEL_DISASSEMBLER
        jit_word_t       prevw;
 #endif
-       jit_int32_t      patch_offset;
+       int32_t  patch_offset;
     } undo;
 #if DEVEL_DISASSEMBLER
     jit_word_t          prevw;
@@ -1565,7 +1565,7 @@ _emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_gpr_t 
r0, jit_fpr_t r1)
 static void
 _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
 {
-    jit_int32_t                flag;
+    int32_t            flag;
 
     assert(node->flag & jit_flag_node);
     if (node->code == jit_code_movi)
diff --git a/jit/ia64-cpu.c b/jit/ia64-cpu.c
index 8372b24..9dcd975 100644
--- a/jit/ia64-cpu.c
+++ b/jit/ia64-cpu.c
@@ -238,7 +238,7 @@ static void _sync(jit_state_t*);
 #define flush()                                _flush(_jit)
 static void _flush(jit_state_t*);
 #define inst(w, t)                     _inst(_jit, w, t)
-static void _inst(jit_state_t*, jit_word_t, jit_uint8_t);
+static void _inst(jit_state_t*, jit_word_t, uint8_t);
 #define A1(x4,x2,r3,r2,r1)             _A1(_jit,0,x4,x2,r3,r2,r1)
 static void _A1(jit_state_t*, jit_word_t,
                jit_word_t,jit_word_t,jit_word_t,jit_word_t,jit_word_t);
@@ -1177,141 +1177,141 @@ static void _X5(jit_state_t*,jit_word_t,
 
 #define addr(r0,r1,r2)                 ADD(r0,r1,r2)
 #define addi(r0,r1,i0)                 _addi(_jit,r0,r1,i0)
-static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define addcr(r0, r1, r2)              _addcr(_jit, r0, r1, r2)
-static void _addcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
+static void _addcr(jit_state_t*, int32_t, jit_int32_t, jit_int32_t);
 #define addci(r0, r1, i0)              _addci(_jit, r0, r1, i0)
-static void _addci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
+static void _addci(jit_state_t*, int32_t, jit_int32_t, jit_word_t);
 #  define addxr(r0, r1, r2)            _addxr(_jit, r0, r1, r2)
-static void _addxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
+static void _addxr(jit_state_t*, int32_t, jit_int32_t, jit_int32_t);
 #  define addxi(r0, r1, i0)            _addxi(_jit, r0, r1, i0)
-static void _addxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
+static void _addxi(jit_state_t*, int32_t, jit_int32_t, jit_word_t);
 #define subr(r0,r1,r2)                 SUB(r0,r1,r2)
 #define subi(r0,r1,i0)                 _subi(_jit,r0,r1,i0)
-static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subcr(r0, r1, r2)            _subcr(_jit, r0, r1, r2)
-static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subcr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subci(r0, r1, i0)            _subci(_jit, r0, r1, i0)
-static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subxr(r0, r1, r2)            _subxr(_jit, r0, r1, r2)
-static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subxr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subxi(r0, r1, i0)            _subxi(_jit, r0, r1, i0)
-static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rsbi(r0, r1, i0)             _rsbi(_jit, r0, r1, i0)
-static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rsbi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define mulr(r0,r1,r2)                 _mulr(_jit,r0,r1,r2)
-static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _mulr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define muli(r0,r1,i0)                 _muli(_jit,r0,r1,i0)
-static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _muli(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define divr(r0,r1,r2)                 _divr(_jit,r0,r1,r2)
-static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define divi(r0,r1,i0)                 _divi(_jit,r0,r1,i0)
-static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define divr_u(r0,r1,r2)               _divr_u(_jit,r0,r1,r2)
-static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define divi_u(r0,r1,i0)               _divi_u(_jit,r0,r1,i0)
-static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define remr(r0,r1,r2)                 _remr(_jit,r0,r1,r2)
-static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define remi(r0,r1,i0)                 _remi(_jit,r0,r1,i0)
-static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define remr_u(r0,r1,r2)               _remr_u(_jit,r0,r1,r2)
-static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define remi_u(r0,r1,i0)               _remi_u(_jit,r0,r1,i0)
-static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define mulh(r0,r1,r2,sign)            _mulh(_jit,r0,r1,r2,sign)
-static void _mulh(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _mulh(jit_state_t*,jit_bool_t,int32_t,jit_int32_t,jit_int32_t);
 #define qmulr(r0,r1,r2,r3)             iqmulr(r0,r1,r2,r3,1)
 #define qmulr_u(r0,r1,r2,r3)           iqmulr(r0,r1,r2,r3,0)
 #define iqmulr(r0,r1,r2,r3,sign)       _iqmulr(_jit,r0,r1,r2,r3,sign)
-static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_bool_t);
+static void _iqmulr(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_bool_t);
 #define qmuli(r0,r1,r2,i0)             iqmuli(r0,r1,r2,i0,1)
 #define qmuli_u(r0,r1,r2,i0)           iqmuli(r0,r1,r2,i0,0)
 #define iqmuli(r0,r1,r2,i0,sign)       _iqmuli(_jit,r0,r1,r2,i0,sign)
-static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_word_t,jit_bool_t);
+static void _iqmuli(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_word_t,jit_bool_t);
 #define qdivr(r0,r1,r2,r3)             iqdivr(r0,r1,r2,r3,1)
 #define qdivr_u(r0,r1,r2,r3)           iqdivr(r0,r1,r2,r3,0)
 #define iqdivr(r0,r1,r2,r3,sign)       _iqdivr(_jit,r0,r1,r2,r3,sign)
-static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_bool_t);
+static void _iqdivr(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_bool_t);
 #define qdivi(r0,r1,r2,i0)             iqdivi(r0,r1,r2,i0,1)
 #define qdivi_u(r0,r1,r2,i0)           iqdivi(r0,r1,r2,i0,0)
 #define iqdivi(r0,r1,r2,i0,sign)       _iqdivi(_jit,r0,r1,r2,i0,sign)
-static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_word_t,jit_bool_t);
+static void _iqdivi(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_word_t,jit_bool_t);
 #define andr(r0,r1,r2)                 AND(r0,r1,r2)
 #define andi(r0,r1,i0)                 _andi(_jit,r0,r1,i0)
-static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _andi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define orr(r0,r1,r2)                  OR(r0,r1,r2)
 #define ori(r0,r1,i0)                  _ori(_jit,r0,r1,i0)
-static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define xorr(r0,r1,r2)                 XOR(r0,r1,r2)
 #define xori(r0,r1,i0)                 _xori(_jit,r0,r1,i0)
-static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _xori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define lshr(r0,r1,r2)                 SHL(r0,r1,r2)
 #define lshi(r0,r1,i0)                 _lshi(_jit,r0,r1,i0)
-static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define rshr(r0,r1,r2)                 SHR(r0,r1,r2)
 #define rshi(r0,r1,i0)                 _rshi(_jit,r0,r1,i0)
-static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define rshr_u(r0,r1,r2)               SHR_U(r0,r1,r2)
 #define rshi_u(r0,r1,i0)               _rshi_u(_jit,r0,r1,i0)
-static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ltr(r0,r1,r2)                  _ltr(_jit,r0,r1,r2)
-static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lti(r0,r1,i0)                  _lti(_jit,r0,r1,i0)
-static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lti(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ltr_u(r0,r1,r2)                        _ltr_u(_jit,r0,r1,r2)
-static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lti_u(r0,r1,i0)                        _lti_u(_jit,r0,r1,i0)
-static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lti_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ler(r0,r1,r2)                  _ler(_jit,r0,r1,r2)
-static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lei(r0,r1,i0)                  _lei(_jit,r0,r1,i0)
-static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ler_u(r0,r1,r2)                        _ler_u(_jit,r0,r1,r2)
-static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lei_u(r0,r1,i0)                        _lei_u(_jit,r0,r1,i0)
-static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lei_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define eqr(r0,r1,r2)                  _eqr(_jit,r0,r1,r2)
-static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _eqr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define eqi(r0,r1,i0)                  _eqi(_jit,r0,r1,i0)
-static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _eqi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ger(r0,r1,r2)                  _ger(_jit,r0,r1,r2)
-static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define gei(r0,r1,i0)                  _gei(_jit,r0,r1,i0)
-static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ger_u(r0,r1,r2)                        _ger_u(_jit,r0,r1,r2)
-static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define gei_u(r0,r1,i0)                        _gei_u(_jit,r0,r1,i0)
-static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gei_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define gtr(r0,r1,r2)                  _gtr(_jit,r0,r1,r2)
-static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define gti(r0,r1,i0)                  _gti(_jit,r0,r1,i0)
-static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gti(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define gtr_u(r0,r1,r2)                        _gtr_u(_jit,r0,r1,r2)
-static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define gti_u(r0,r1,i0)                        _gti_u(_jit,r0,r1,i0)
-static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gti_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ner(r0,r1,r2)                  _ner(_jit,r0,r1,r2)
-static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define nei(r0,r1,i0)                  _nei(_jit,r0,r1,i0)
-static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _nei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define negr(r0,r1)                    subr(r0,0,r1)
 #define comr(r0,r1)                    ANDCMI(r0,-1,r1)
 #define movr(r0,r1)                    _movr(_jit,r0,r1)
-static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr(jit_state_t*,int32_t,jit_int32_t);
 #define movi(r0,i0)                    _movi(_jit,r0,i0)
-static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
+static void _movi(jit_state_t*,int32_t,jit_word_t);
 #define movi_p(r0,i0)                  _movi_p(_jit,r0,i0)
-static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
+static jit_word_t _movi_p(jit_state_t*,int32_t,jit_word_t);
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 #  define htonr_us(r0,r1)              _htonr_us(_jit,r0,r1)
-static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_us(jit_state_t*,int32_t,jit_int32_t);
 #  define htonr_ui(r0,r1)              _htonr_ui(_jit,r0,r1)
-static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ui(jit_state_t*,int32_t,jit_int32_t);
 #  define htonr_ul(r0,r1)              MUX1(r0,r1,MUX_REV)
 #else
 #  define htonr_us(r0,r1)              extr_us(r0,r1)
@@ -1325,77 +1325,77 @@ static void 
_htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 #define extr_i(r0,r1)                  SXT4(r0,r1)
 #define extr_ui(r0,r1)                 ZXT4(r0,r1)
 #define bltr(i0,r0,r1)                 _bltr(_jit,i0,r0,r1)
-static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blti(i0,r0,i1)                 _blti(_jit,i0,r0,i1)
-static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blti(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bltr_u(i0,r0,r1)               _bltr_u(_jit,i0,r0,r1)
-static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blti_u(i0,r0,i1)               _blti_u(_jit,i0,r0,i1)
-static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blti_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bler(i0,r0,r1)                 _bler(_jit,i0,r0,r1)
-static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blei(i0,r0,i1)                 _blei(_jit,i0,r0,i1)
-static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bler_u(i0,r0,r1)               _bler_u(_jit,i0,r0,r1)
-static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blei_u(i0,r0,i1)               _blei_u(_jit,i0,r0,i1)
-static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blei_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define beqr(i0,r0,r1)                 _beqr(_jit,i0,r0,r1)
-static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define beqi(i0,r0,i1)                 _beqi(_jit,i0,r0,i1)
-static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _beqi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bger(i0,r0,r1)                 _bger(_jit,i0,r0,r1)
-static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgei(i0,r0,i1)                 _bgei(_jit,i0,r0,i1)
-static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bger_u(i0,r0,r1)               _bger_u(_jit,i0,r0,r1)
-static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgei_u(i0,r0,i1)               _bgei_u(_jit,i0,r0,i1)
-static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgei_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bgtr(i0,r0,r1)                 _bgtr(_jit,i0,r0,r1)
-static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgti(i0,r0,i1)                 _bgti(_jit,i0,r0,i1)
-static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgti(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bgtr_u(i0,r0,r1)               _bgtr_u(_jit,i0,r0,r1)
-static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgti_u(i0,r0,i1)               _bgti_u(_jit,i0,r0,i1)
-static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgti_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bner(i0,r0,r1)                 _bner(_jit,i0,r0,r1)
-static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bnei(i0,r0,i1)                 _bnei(_jit,i0,r0,i1)
-static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bnei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bmsr(i0,r0,r1)                 _bmsr(_jit,i0,r0,r1)
-static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bmsr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bmsi(i0,r0,i1)                 _bmsi(_jit,i0,r0,i1)
-static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bmsi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bmcr(i0,r0,r1)                 _bmcr(_jit,i0,r0,r1)
-static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bmcr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bmci(i0,r0,i1)                 _bmci(_jit,i0,r0,i1)
-static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bmci(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define baddr(i0,r0,r1,cc)             _baddr(_jit,i0,r0,r1,cc)
 static jit_word_t _baddr(jit_state_t*,jit_word_t,
-                        jit_int32_t,jit_int32_t,jit_bool_t);
+                        int32_t,jit_int32_t,jit_bool_t);
 #define baddi(i0,r0,i1,cc)             _baddi(_jit,i0,r0,i1,cc)
 static jit_word_t _baddi(jit_state_t*,jit_word_t,
-                        jit_int32_t,jit_word_t,jit_bool_t);
+                        int32_t,jit_word_t,jit_bool_t);
 #define baddr_u(i0,r0,r1,cc)           _baddr_u(_jit,i0,r0,r1,cc)
 static jit_word_t _baddr_u(jit_state_t*,jit_word_t,
-                          jit_int32_t,jit_int32_t,jit_bool_t);
+                          int32_t,jit_int32_t,jit_bool_t);
 #define baddi_u(i0,r0,i1,cc)           _baddi_u(_jit,i0,r0,i1,cc)
 static jit_word_t _baddi_u(jit_state_t*,jit_word_t,
-                          jit_int32_t,jit_word_t,jit_bool_t);
+                          int32_t,jit_word_t,jit_bool_t);
 #define bsubr(i0,r0,r1,cc)             _bsubr(_jit,i0,r0,r1,cc)
 static jit_word_t _bsubr(jit_state_t*,jit_word_t,
-                        jit_int32_t,jit_int32_t,jit_bool_t);
+                        int32_t,jit_int32_t,jit_bool_t);
 #define bsubi(i0,r0,i1,cc)             _bsubi(_jit,i0,r0,i1,cc)
 static jit_word_t _bsubi(jit_state_t*,jit_word_t,
-                        jit_int32_t,jit_word_t,jit_bool_t);
+                        int32_t,jit_word_t,jit_bool_t);
 #define bsubr_u(i0,r0,r1,cc)           _bsubr_u(_jit,i0,r0,r1,cc)
 static jit_word_t _bsubr_u(jit_state_t*,jit_word_t,
-                          jit_int32_t,jit_int32_t,jit_bool_t);
+                          int32_t,jit_int32_t,jit_bool_t);
 #define bsubi_u(i0,r0,i1,cc)           _bsubi_u(_jit,i0,r0,i1,cc)
 static jit_word_t _bsubi_u(jit_state_t*,jit_word_t,
-                          jit_int32_t,jit_word_t,jit_bool_t);
+                          int32_t,jit_word_t,jit_bool_t);
 #define boaddr(i0,r0,r1)               baddr(i0,r0,r1,1)
 #define boaddi(i0,r0,i1)               baddi(i0,r0,i1,1)
 #define boaddr_u(i0,r0,r1)             baddr_u(i0,r0,r1,1)
@@ -1413,93 +1413,93 @@ static jit_word_t _bsubi_u(jit_state_t*,jit_word_t,
 #define bxsubr_u(i0,r0,r1)             bsubr_u(i0,r0,r1,0)
 #define bxsubi_u(i0,r0,i1)             bsubi_u(i0,r0,i1,0)
 #define ldr_c(r0,r1)                   _ldr_c(_jit,r0,r1)
-static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_c(jit_state_t*,int32_t,jit_int32_t);
 #define ldi_c(r0,i0)                   _ldi_c(_jit,r0,i0)
-static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_c(jit_state_t*,int32_t,jit_word_t);
 #define ldr_uc(r0,r1)                  LD1(r0,r1)
 #define ldi_uc(r0,i0)                  _ldi_uc(_jit,r0,i0)
-static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_uc(jit_state_t*,int32_t,jit_word_t);
 #define ldr_s(r0,r1)                   _ldr_s(_jit,r0,r1)
-static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_s(jit_state_t*,int32_t,jit_int32_t);
 #define ldi_s(r0,i0)                   _ldi_s(_jit,r0,i0)
-static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_s(jit_state_t*,int32_t,jit_word_t);
 #define ldr_us(r0,r1)                  LD2(r0,r1)
 #define ldi_us(r0,i0)                  _ldi_us(_jit,r0,i0)
-static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_us(jit_state_t*,int32_t,jit_word_t);
 #define ldr_i(r0,r1)                   _ldr_i(_jit,r0,r1)
-static void _ldr_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_i(jit_state_t*,int32_t,jit_int32_t);
 #define ldi_i(r0,i0)                   _ldi_i(_jit,r0,i0)
-static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_i(jit_state_t*,int32_t,jit_word_t);
 #define ldr_ui(r0,r1)                  LD4(r0,r1)
 #define ldi_ui(r0,i0)                  _ldi_ui(_jit,r0,i0)
-static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_ui(jit_state_t*,int32_t,jit_word_t);
 #define ldr_l(r0,r1)                   LD8(r0,r1)
 #define ldi_l(r0,i0)                   _ldi_l(_jit,r0,i0)
-static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_l(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_c(r0,r1,r2)               _ldxr_c(_jit,r0,r1,r2)
-static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_c(r0,r1,i0)               _ldxi_c(_jit,r0,r1,i0)
-static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_c(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldxr_uc(r0,r1,r2)              _ldxr_uc(_jit,r0,r1,r2)
-static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_uc(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_uc(r0,r1,i0)              _ldxi_uc(_jit,r0,r1,i0)
-static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_uc(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldxr_s(r0,r1,r2)               _ldxr_s(_jit,r0,r1,r2)
-static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_s(r0,r1,i0)               _ldxi_s(_jit,r0,r1,i0)
-static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_s(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldxr_us(r0,r1,r2)              _ldxr_us(_jit,r0,r1,r2)
-static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_us(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_us(r0,r1,i0)              _ldxi_us(_jit,r0,r1,i0)
-static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_us(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldxr_i(r0,r1,r2)               _ldxr_i(_jit,r0,r1,r2)
-static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_i(r0,r1,i0)               _ldxi_i(_jit,r0,r1,i0)
-static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_i(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldxr_ui(r0,r1,r2)              _ldxr_ui(_jit,r0,r1,r2)
-static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_ui(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_ui(r0,r1,i0)              _ldxi_ui(_jit,r0,r1,i0)
-static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_ui(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldxr_l(r0,r1,r2)               _ldxr_l(_jit,r0,r1,r2)
-static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_l(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_l(r0,r1,i0)               _ldxi_l(_jit,r0,r1,i0)
-static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_l(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define str_c(r0,r1)                   ST1(r0,r1)
 #define sti_c(i0,r0)                   _sti_c(_jit,i0,r0)
-static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_c(jit_state_t*,jit_word_t,int32_t);
 #define str_s(r0,r1)                   ST2(r0,r1)
 #define sti_s(i0,r0)                   _sti_s(_jit,i0,r0)
-static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_s(jit_state_t*,jit_word_t,int32_t);
 #define str_i(r0,r1)                   ST4(r0,r1)
 #define sti_i(i0,r0)                   _sti_i(_jit,i0,r0)
-static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_i(jit_state_t*,jit_word_t,int32_t);
 #define str_l(r0,r1)                   ST8(r0,r1)
 #define sti_l(i0,r0)                   _sti_l(_jit,i0,r0)
-static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_l(jit_state_t*,jit_word_t,int32_t);
 #define stxr_c(r0,r1,r2)               _stxr_c(_jit,r0,r1,r2)
-static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi_c(i0,r0,r1)               _stxi_c(_jit,i0,r0,r1)
-static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_c(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define stxr_s(r0,r1,r2)               _stxr_s(_jit,r0,r1,r2)
-static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi_s(i0,r0,r1)               _stxi_s(_jit,i0,r0,r1)
-static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_s(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define stxr_i(r0,r1,r2)               _stxr_i(_jit,r0,r1,r2)
-static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi_i(i0,r0,r1)               _stxi_i(_jit,i0,r0,r1)
-static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_i(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define stxr_l(r0,r1,r2)               _stxr_l(_jit,r0,r1,r2)
-static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_l(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi_l(i0,r0,r1)               _stxi_l(_jit,i0,r0,r1)
-static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_l(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define jmpr(r0)                       _jmpr(_jit,r0)
-static void _jmpr(jit_state_t*,jit_int32_t);
+static void _jmpr(jit_state_t*,int32_t);
 #define jmpi(i0)                       _jmpi(_jit,i0)
 static void _jmpi(jit_state_t*,jit_word_t);
 #define jmpi_p(i0)                     _jmpi_p(_jit,i0)
 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
 #define callr(r0)                      _callr(_jit,r0)
-static void _callr(jit_state_t*,jit_int32_t);
+static void _callr(jit_state_t*,int32_t);
 #define calli(i0)                      _calli(_jit,i0)
 static void _calli(jit_state_t*,jit_word_t);
 #define calli_p(i0)                    _calli_p(_jit,i0)
@@ -1509,9 +1509,9 @@ static void _prolog(jit_state_t*,jit_node_t*);
 #define epilog(node)                   _epilog(_jit,node)
 static void _epilog(jit_state_t*,jit_node_t*);
 #  define vastart(r0)                  _vastart(_jit, r0)
-static void _vastart(jit_state_t*, jit_int32_t);
+static void _vastart(jit_state_t*, int32_t);
 #  define vaarg(r0, r1)                        _vaarg(_jit, r0, r1)
-static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg(jit_state_t*, int32_t, jit_int32_t);
 #define patch_at(node,instr,label)     _patch_at(_jit,node,instr,label)
 static void _patch_at(jit_state_t*,jit_code_t,jit_word_t,jit_word_t);
 #endif
@@ -2116,7 +2116,7 @@ _flush(jit_state_t *_jit)
 }
 
 static void
-_inst(jit_state_t *_jit, jit_word_t i, jit_uint8_t t)
+_inst(jit_state_t *_jit, jit_word_t i, uint8_t t)
 {
     if (_jitc->ioff > 2)
        flush();
@@ -2685,7 +2685,7 @@ static void
 _I24(jit_state_t *_jit, jit_word_t _p,
      jit_word_t im)
 {
-    jit_uint8_t                cc = INST_I;
+    uint8_t            cc = INST_I;
     assert(!(_p &      ~0x3fL));
     assert(!(im & ~0xfffffffL));
     TSTPRED(_p);
@@ -2817,7 +2817,7 @@ static void
 _M3(jit_state_t *_jit, jit_word_t _p,
     jit_word_t x6, jit_word_t ht, jit_word_t r3, jit_word_t im, jit_word_t r1)
 {
-    jit_uint8_t                cc = INST_M;
+    uint8_t            cc = INST_M;
     assert(!(_p &  ~0x3fL));
     assert(!(x6 &  ~0x3fL));
     assert(!(ht &   ~0x3L));
@@ -3451,7 +3451,7 @@ _X5(jit_state_t *_jit, jit_word_t _p,
 }
 
 static void
-_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     /* patch pushargr */
     if (r0 >= 120)
@@ -3461,7 +3461,7 @@ _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     /* patch pushargi */
     if (r0 >= 120)
@@ -3474,7 +3474,7 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static jit_word_t
-_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi_p(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         w;
     sync();
@@ -3484,9 +3484,9 @@ _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -8192 && i0 <= 8191)
        ADDS(r0, i0, r1);
     else if (!(r1 & ~3) && i0 >= -2097152 && i0 <= 2097151)
@@ -3500,9 +3500,9 @@ _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addcr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
     if (r0 == r1) {
@@ -3519,9 +3519,9 @@ _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
     if (r0 == r1) {
@@ -3538,9 +3538,9 @@ _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addxr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(jit_carry != _NOREG);
     reg = jit_get_reg(jit_class_gpr);
     movr(rn(reg), rn(jit_carry));
@@ -3550,9 +3550,9 @@ _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(jit_carry != _NOREG);
     reg = jit_get_reg(jit_class_gpr);
     movr(rn(reg), rn(jit_carry));
@@ -3562,9 +3562,9 @@ _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     subr(r0, r1, rn(reg));
@@ -3572,9 +3572,9 @@ _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subcr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
     if (r0 == r1) {
@@ -3591,9 +3591,9 @@ _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
     if (r0 == r1) {
@@ -3610,9 +3610,9 @@ _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subxr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(jit_carry != _NOREG);
     reg = jit_get_reg(jit_class_gpr);
     movr(rn(reg), rn(jit_carry));
@@ -3622,9 +3622,9 @@ _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     assert(jit_carry != _NOREG);
     reg = jit_get_reg(jit_class_gpr);
     movr(rn(reg), rn(jit_carry));
@@ -3634,9 +3634,9 @@ _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rsbi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -128 && i0 <= 127)
        SUBI(r0, i0, r1);
     else if (!(r1 & ~3) && i0 >= -2097151 && i0 <= 2097152)
@@ -3650,9 +3650,9 @@ _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_mulr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                f0, f1;
+    int32_t            f0, f1;
     f0 = jit_get_reg(jit_class_fpr);
     f1 = jit_get_reg(jit_class_fpr);
     SETF_SIG(rn(f0), r1);
@@ -3664,9 +3664,9 @@ _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_muli(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     mulr(r0, r1, rn(reg));
@@ -3700,7 +3700,7 @@ __umoddi3(unsigned long u, unsigned long v)
 #endif
 
 static void
-_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     MOV(_jitc->rout, r1);
     MOV(_jitc->rout + 1, r2);
@@ -3709,9 +3709,9 @@ _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     switch (i0) {
        case 1:
            movr(r0, r1);
@@ -3734,7 +3734,7 @@ _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     MOV(_jitc->rout, r1);
     MOV(_jitc->rout + 1, r2);
@@ -3743,9 +3743,9 @@ _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 1) {
        movr(r0, r1);
        return;
@@ -3762,7 +3762,7 @@ _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     MOV(_jitc->rout, r1);
     MOV(_jitc->rout + 1, r2);
@@ -3771,9 +3771,9 @@ _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 1 || i0 == -1) {
        MOV(r0, GR_0);
        return;
@@ -3785,7 +3785,7 @@ _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     MOV(_jitc->rout, r1);
     MOV(_jitc->rout + 1, r2);
@@ -3794,9 +3794,9 @@ _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 1) {
        MOV(r0, GR_0);
        return;
@@ -3813,9 +3813,9 @@ _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 
 static void
 _mulh(jit_state_t *_jit,
-      jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_bool_t sign)
+      int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_bool_t sign)
 {
-    jit_int32_t                f0, f1;
+    int32_t            f0, f1;
     f0 = jit_get_reg(jit_class_fpr);
     f1 = jit_get_reg(jit_class_fpr);
     SETF_SIG(rn(f0), r1);
@@ -3830,10 +3830,10 @@ _mulh(jit_state_t *_jit,
 }
 
 static void
-_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
+_iqmulr(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_int32_t r3, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r2 || r0 == r3) {
        reg = jit_get_reg(jit_class_gpr);
        mulr(rn(reg), r2, r3);
@@ -3848,10 +3848,10 @@ _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
+_iqmuli(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     iqmulr(r0, r1, r2, rn(reg), sign);
@@ -3859,11 +3859,11 @@ _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
+_iqdivr(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_int32_t r3, jit_bool_t sign)
 {
-    jit_int32_t                sv0, rg0;
-    jit_int32_t                sv1, rg1;
+    int32_t            sv0, rg0;
+    int32_t            sv1, rg1;
 
     if (r0 == r2 || r0 == r3) {
        sv0 = jit_get_reg(jit_class_gpr);
@@ -3895,10 +3895,10 @@ _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
+_iqdivi(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     iqdivr(r0, r1, r2, rn(reg), sign);
@@ -3906,9 +3906,9 @@ _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
 }
 
 static void
-_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_andi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -128 && i0 <= 127)
        ANDI(r0, i0, r1);
     else if (~i0 >= -128 && ~i0 <= 127)
@@ -3922,9 +3922,9 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -128 && i0 <= 127)
        ORI(r0, i0, r1);
     else {
@@ -3936,9 +3936,9 @@ _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_xori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -128 && i0 <= 127)
        XORI(r0, i0, r1);
     else {
@@ -3951,9 +3951,9 @@ _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 static void
-_htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr);
     rshi(rn(t0), r1, 8);
     andi(r0, r1, 0xff);
@@ -3964,11 +3964,11 @@ _htonr_us(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr);
     t2 = jit_get_reg(jit_class_gpr);
@@ -3992,9 +3992,9 @@ _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 #endif
 
 static void
-_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     lshr(r0, r1, rn(reg));
@@ -4002,9 +4002,9 @@ _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     rshr(r0, r1, rn(reg));
@@ -4012,9 +4012,9 @@ _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     rshr_u(r0, r1, rn(reg));
@@ -4022,7 +4022,7 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_LT(PR_6, PR_7, r1, r2);
     MOVI_p(r0, 1, PR_6);
@@ -4030,9 +4030,9 @@ _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lti(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -127 && i0 <= 128)
        CMPI_LT(PR_7, PR_6, i0 - 1, r1);
     else {
@@ -4046,7 +4046,7 @@ _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_LTU(PR_6, PR_7, r1, r2);
     MOVI_p(r0, 1, PR_6);
@@ -4054,9 +4054,9 @@ _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lti_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -127 && i0 <= 128)
        CMPI_LTU(PR_7, PR_6, i0 - 1, r1);
     else {
@@ -4070,7 +4070,7 @@ _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_LT(PR_6, PR_7, r2, r1);
     MOV_p(r0, GR_0, PR_6);
@@ -4078,9 +4078,9 @@ _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ler(r0, r1, rn(reg));
@@ -4088,7 +4088,7 @@ _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_LTU(PR_6, PR_7, r2, r1);
     MOV_p(r0, GR_0, PR_6);
@@ -4096,9 +4096,9 @@ _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lei_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ler_u(r0, r1, rn(reg));
@@ -4106,7 +4106,7 @@ _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_eqr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_EQ(PR_6, PR_7, r1, r2);
     MOVI_p(r0, 1, PR_6);
@@ -4114,9 +4114,9 @@ _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_eqi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -128 && i0 <= 127)
        CMPI_EQ(PR_6, PR_7, i0, r1);
     else {
@@ -4130,7 +4130,7 @@ _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_LT(PR_6, PR_7, r1, r2);
     MOV_p(r0, GR_0, PR_6);
@@ -4138,9 +4138,9 @@ _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -127 && i0 <= 128)
        CMPI_LT(PR_7, PR_6, i0 - 1, r1);
     else {
@@ -4154,7 +4154,7 @@ _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_LTU(PR_6, PR_7, r1, r2);
     MOV_p(r0, GR_0, PR_6);
@@ -4162,9 +4162,9 @@ _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gei_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -127 && i0 <= 128)
        CMPI_LTU(PR_7, PR_6, i0 - 1, r1);
     else {
@@ -4178,7 +4178,7 @@ _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_LT(PR_6, PR_7, r2, r1);
     MOVI_p(r0, 1, PR_6);
@@ -4186,9 +4186,9 @@ _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gti(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     gtr(r0, r1, rn(reg));
@@ -4196,7 +4196,7 @@ _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_LTU(PR_6, PR_7, r2, r1);
     MOVI_p(r0, 1, PR_6);
@@ -4204,9 +4204,9 @@ _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gti_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     gtr_u(r0, r1, rn(reg));
@@ -4214,7 +4214,7 @@ _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMP_EQ(PR_6, PR_7, r1, r2);
     MOV_p(r0, GR_0, PR_6);
@@ -4222,9 +4222,9 @@ _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_nei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 >= -128 && i0 <= 127)
        CMPI_EQ(PR_6, PR_7, i0, r1);
     else {
@@ -4238,16 +4238,16 @@ _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_uc(r0, r1);
     extr_c(r0, r0);
 }
 
 static void
-_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_c(r0, rn(reg));
@@ -4255,9 +4255,9 @@ _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_uc(r0, rn(reg));
@@ -4265,16 +4265,16 @@ _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t 
i0)
 }
 
 static void
-_ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_us(r0, r1);
     extr_s(r0, r0);
 }
 
 static void
-_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_s(r0, rn(reg));
@@ -4282,9 +4282,9 @@ _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_us(r0, rn(reg));
@@ -4292,16 +4292,16 @@ _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t 
i0)
 }
 
 static void
-_ldr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_ui(r0, r1);
     extr_i(r0, r0);
 }
 
 static void
-_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_i(r0, rn(reg));
@@ -4309,9 +4309,9 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_ui(r0, rn(reg));
@@ -4319,9 +4319,9 @@ _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_l(r0, rn(reg));
@@ -4329,9 +4329,9 @@ _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_c(r0, rn(reg));
@@ -4339,9 +4339,9 @@ _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        movi(rn(reg), i0);
@@ -4353,9 +4353,9 @@ _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_uc(r0, rn(reg));
@@ -4363,9 +4363,9 @@ _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        movi(rn(reg), i0);
@@ -4377,9 +4377,9 @@ _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_s(r0, rn(reg));
@@ -4387,9 +4387,9 @@ _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        movi(rn(reg), i0);
@@ -4401,9 +4401,9 @@ _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_us(r0, rn(reg));
@@ -4411,9 +4411,9 @@ _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        movi(rn(reg), i0);
@@ -4425,9 +4425,9 @@ _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_i(r0, rn(reg));
@@ -4435,9 +4435,9 @@ _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        movi(rn(reg), i0);
@@ -4449,9 +4449,9 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_ui(r0, rn(reg));
@@ -4459,9 +4459,9 @@ _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        movi(rn(reg), i0);
@@ -4473,9 +4473,9 @@ _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_l(r0, rn(reg));
@@ -4483,9 +4483,9 @@ _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        movi(rn(reg), i0);
@@ -4497,9 +4497,9 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_c(rn(reg), r0);
@@ -4507,9 +4507,9 @@ _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_s(rn(reg), r0);
@@ -4517,9 +4517,9 @@ _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_i(rn(reg), r0);
@@ -4527,9 +4527,9 @@ _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_l(rn(reg), r0);
@@ -4537,9 +4537,9 @@ _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_c(rn(reg), r2);
@@ -4547,9 +4547,9 @@ _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        addi(rn(reg), r0, i0);
@@ -4561,9 +4561,9 @@ _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_s(rn(reg), r2);
@@ -4571,9 +4571,9 @@ _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        addi(rn(reg), r0, i0);
@@ -4585,9 +4585,9 @@ _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_i(rn(reg), r2);
@@ -4595,9 +4595,9 @@ _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        addi(rn(reg), r0, i0);
@@ -4609,9 +4609,9 @@ _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_l(rn(reg), r2);
@@ -4619,9 +4619,9 @@ _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        addi(rn(reg), r0, i0);
@@ -4633,7 +4633,7 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_LT(PR_6, PR_7, r0, r1);
@@ -4644,10 +4644,10 @@ _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blti(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -127 && i1 <= 128)
        CMPI_LT(PR_7, PR_6, i1 - 1, r0);
     else {
@@ -4663,7 +4663,7 @@ _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_LTU(PR_6, PR_7, r0, r1);
@@ -4674,10 +4674,10 @@ _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blti_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -127 && i1 <= 128)
        CMPI_LTU(PR_7, PR_6, i1 - 1, r0);
     else {
@@ -4693,7 +4693,7 @@ _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_LT(PR_6, PR_7, r1, r0);
@@ -4704,10 +4704,10 @@ _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bler(i0, r0, rn(reg));
@@ -4716,7 +4716,7 @@ _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_LTU(PR_6, PR_7, r1, r0);
@@ -4727,10 +4727,10 @@ _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blei_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bler_u(i0, r0, rn(reg));
@@ -4739,7 +4739,7 @@ _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_beqr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_EQ(PR_6, PR_7, r0, r1);
@@ -4750,10 +4750,10 @@ _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_beqi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -128 && i1 <= 127)
        CMPI_EQ(PR_6, PR_7, i1, r0);
     else {
@@ -4769,7 +4769,7 @@ _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_LT(PR_6, PR_7, r0, r1);
@@ -4780,10 +4780,10 @@ _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -127 && i1 <= 128)
        CMPI_LT(PR_7, PR_6, i1 - 1, r0);
     else {
@@ -4799,7 +4799,7 @@ _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_LTU(PR_6, PR_7, r0, r1);
@@ -4810,10 +4810,10 @@ _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgei_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -127 && i1 <= 128)
        CMPI_LTU(PR_7, PR_6, i1 - 1, r0);
     else {
@@ -4829,7 +4829,7 @@ _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_LT(PR_6, PR_7, r1, r0);
@@ -4840,10 +4840,10 @@ _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgti(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bgtr(i0, r0, rn(reg));
@@ -4852,7 +4852,7 @@ _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_LTU(PR_6, PR_7, r1, r0);
@@ -4863,10 +4863,10 @@ _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgti_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bgtr_u(i0, r0, rn(reg));
@@ -4875,7 +4875,7 @@ _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bner(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     CMP_EQ(PR_6, PR_7, r0, r1);
@@ -4886,10 +4886,10 @@ _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bnei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i1 >= -128 && i1 <= 127)
        CMPI_EQ(PR_6, PR_7, i1, r0);
     else {
@@ -4905,10 +4905,10 @@ _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bmsr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     andr(rn(reg), r0, r1);
     CMPI_EQ(PR_6, PR_7, 0, rn(reg));
@@ -4920,10 +4920,10 @@ _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bmsi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i1);
     andr(rn(reg), r0, rn(reg));
@@ -4936,10 +4936,10 @@ _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bmcr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     andr(rn(reg), r0, r1);
     CMPI_EQ(PR_6, PR_7, 0, rn(reg));
@@ -4951,10 +4951,10 @@ _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bmci(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i1);
     andr(rn(reg), r0, rn(reg));
@@ -4967,13 +4967,13 @@ _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_baddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_baddr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
        jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
     /* t1 = r0 + r1;   overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -4996,11 +4996,11 @@ _baddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1,
 }
 
 static jit_word_t
-_baddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_baddi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
        jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = baddr(i0, r0, rn(reg), carry);
@@ -5009,12 +5009,12 @@ _baddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1,
 }
 
 static jit_word_t
-_baddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_baddr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
         jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     addr(rn(t0), r0, r1);
@@ -5030,11 +5030,11 @@ _baddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1,
 }
 
 static jit_word_t
-_baddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_baddi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
         jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = baddr_u(i0, r0, rn(reg), carry);
@@ -5043,13 +5043,13 @@ _baddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1,
 }
 
 static jit_word_t
-_bsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_bsubr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
        jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
     /* t1 = r0 - r1;   overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -5072,11 +5072,11 @@ _bsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1,
 }
 
 static jit_word_t
-_bsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_bsubi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
        jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bsubr(i0, r0, rn(reg), carry);
@@ -5085,12 +5085,12 @@ _bsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1,
 }
 
 static jit_word_t
-_bsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
+_bsubr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1,
         jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     subr(rn(t0), r0, r1);
@@ -5106,11 +5106,11 @@ _bsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1,
 }
 
 static jit_word_t
-_bsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
+_bsubi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1,
         jit_bool_t carry)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bsubr_u(i0, r0, rn(reg), carry);
@@ -5119,7 +5119,7 @@ _bsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1,
 }
 
 static void
-_jmpr(jit_state_t *_jit, jit_int32_t r0)
+_jmpr(jit_state_t *_jit, int32_t r0)
 {
     MOV_br_rn(BR_6, r0);
     BR(BR_6);
@@ -5149,9 +5149,9 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0)
 }
 
 static void
-_callr(jit_state_t *_jit, jit_int32_t r0)
+_callr(jit_state_t *_jit, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     LD8_inc(rn(reg), r0, 8);
     MOV_br_rn(BR_6, rn(reg));
@@ -5163,7 +5163,7 @@ _callr(jit_state_t *_jit, jit_int32_t r0)
 static void
 _calli(jit_state_t *_jit, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     callr(rn(reg));
@@ -5174,7 +5174,7 @@ static jit_word_t
 _calli_p(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     w = movi_p(rn(reg), i0);
     callr(rn(reg));
@@ -5185,10 +5185,10 @@ _calli_p(jit_state_t *_jit, jit_word_t i0)
 static void
 _prolog(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                reg, ruse, rout;
+    int32_t            reg, ruse, rout;
 
     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
-       jit_int32_t     frame = -_jitc->function->frame;
+       int32_t frame = -_jitc->function->frame;
        assert(_jitc->function->self.aoff >= frame);
        if (_jitc->function->assume_frame)
            return;
@@ -5312,7 +5312,7 @@ _epilog(jit_state_t *_jit, jit_node_t *node)
 }
 
 static void
-_vastart(jit_state_t *_jit, jit_int32_t r0)
+_vastart(jit_state_t *_jit, int32_t r0)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
     /* Initialize va_list to the first stack argument. */
@@ -5323,7 +5323,7 @@ _vastart(jit_state_t *_jit, jit_int32_t r0)
 }
 
 static void
-_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
     /* Load argument. */
diff --git a/jit/ia64-fpu.c b/jit/ia64-fpu.c
index e152671..913c0fd 100644
--- a/jit/ia64-fpu.c
+++ b/jit/ia64-fpu.c
@@ -432,298 +432,298 @@ static void F16_(jit_state_t*,jit_word_t,
 #define movr_f(r0,r1)                  movr_d(r0,r1)
 #define movr_d(r0,r1)                  MOVF(r0,r1)
 #define movi_f(r0,i0)                  _movi_f(_jit,r0,i0)
-static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
+static void _movi_f(jit_state_t*,int32_t,jit_float32_t*);
 #define movi_d(r0,i0)                  _movi_d(_jit,r0,i0)
-static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
+static void _movi_d(jit_state_t*,int32_t,jit_float64_t*);
 #define movr_w_f(r0,r1)                        _movr_w_f(_jit,r0,r1)
-static void _movr_w_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_w_f(jit_state_t*,int32_t,jit_int32_t);
 #define movr_f_w(r0,r1)                        _movr_f_w(_jit,r0,r1)
-static void _movr_f_w(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_f_w(jit_state_t*,int32_t,jit_int32_t);
 #define movr_w_d(r0,r1)                        _movr_w_d(_jit,r0,r1)
-static void _movr_w_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_w_d(jit_state_t*,int32_t,jit_int32_t);
 #define movr_d_w(r0,r1)                        _movr_d_w(_jit,r0,r1)
-static void _movr_d_w(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_d_w(jit_state_t*,int32_t,jit_int32_t);
 #define movi_f_w(r0,i0)                        _movi_f_w(_jit,r0,i0)
-static void _movi_f_w(jit_state_t*,jit_int32_t,jit_float32_t*);
+static void _movi_f_w(jit_state_t*,int32_t,jit_float32_t*);
 #define movi_d_w(r0,i0)                        _movi_d_w(_jit,r0,i0)
-static void _movi_d_w(jit_state_t*,jit_int32_t,jit_float64_t*);
+static void _movi_d_w(jit_state_t*,int32_t,jit_float64_t*);
 #define absr_f(r0,r1)                  absr_d(r0,r1)
 #define absr_d(r0,r1)                  FABS(r0,r1)
 #define negr_f(r0,r1)                  negr_d(r0,r1)
 #define negr_d(r0,r1)                  FNEG(r0,r1)
 #define sqrtr_f(r0,r1)                 _sqrtr_f(_jit,r0,r1)
-static void _sqrtr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _sqrtr_f(jit_state_t*,int32_t,jit_int32_t);
 #define sqrtr_d(r0,r1)                 _sqrtr_d(_jit,r0,r1)
-static void _sqrtr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _sqrtr_d(jit_state_t*,int32_t,jit_int32_t);
 #define extr_f_d(r0,r1)                        FNORM_D(r0,r1)
 #define extr_d_f(r0,r1)                        FNORM_S(r0,r1)
 #define extr_f(r0,r1)                  _extr_f(_jit,r0,r1)
-static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_f(jit_state_t*,int32_t,jit_int32_t);
 #define extr_d(r0,r1)                  _extr_d(_jit,r0,r1)
-static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_d(jit_state_t*,int32_t,jit_int32_t);
 #define truncr_f_i(r0,r1)              truncr_d_l(r0,r1)
 #define truncr_d_i(r0,r1)              truncr_d_l(r0,r1)
 #define truncr_f_l(r0,r1)              truncr_d_l(r0,r1)
 #define truncr_d_l(r0,r1)              _truncr_d_l(_jit,r0,r1)
-static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_d_l(jit_state_t*,int32_t,jit_int32_t);
 #define addr_f(r0,r1,r2)               FADD_S(r0,r1,r2)
 #define addi_f(r0,r1,i0)               _addi_f(_jit,r0,r1,i0)
-static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _addi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define addr_d(r0,r1,r2)               FADD_D(r0,r1,r2)
 #define addi_d(r0,r1,i0)               _addi_d(_jit,r0,r1,i0)
-static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _addi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define subr_f(r0,r1,r2)               FSUB_S(r0,r1,r2)
 #define subi_f(r0,r1,i0)               _subi_f(_jit,r0,r1,i0)
-static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _subi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define subr_d(r0,r1,r2)               FSUB_D(r0,r1,r2)
 #define subi_d(r0,r1,i0)               _subi_d(_jit,r0,r1,i0)
-static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _subi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define rsbr_f(r0,r1,r2)               subr_f(r0,r2,r1)
 #define rsbi_f(r0,r1,i0)               _rsbi_f(_jit,r0,r1,i0)
-static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _rsbi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define rsbr_d(r0,r1,r2)               subr_d(r0,r2,r1)
 #define rsbi_d(r0,r1,i0)               _rsbi_d(_jit,r0,r1,i0)
-static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _rsbi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define mulr_f(r0,r1,r2)               FMPY_S(r0,r1,r2)
 #define muli_f(r0,r1,i0)               _muli_f(_jit,r0,r1,i0)
-static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _muli_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define mulr_d(r0,r1,r2)               FMPY_D(r0,r1,r2)
 #define muli_d(r0,r1,i0)               _muli_d(_jit,r0,r1,i0)
-static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _muli_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define divr_f(r0,r1,r2)               _divr_f(_jit,r0,r1,r2)
-static void _divr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define divi_f(r0,r1,i0)               _divi_f(_jit,r0,r1,i0)
-static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _divi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define divr_d(r0,r1,r2)               _divr_d(_jit,r0,r1,r2)
-static void _divr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define divi_d(r0,r1,i0)               _divi_d(_jit,r0,r1,i0)
-static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _divi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define ltr_f(r0,r1,r2)                        ltr_d(r0,r1,r2)
 #define ltr_d(r0,r1,r2)                        _ltr_d(_jit,r0,r1,r2)
-static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lti_f(r0,r1,i0)                        _lti_f(_jit,r0,r1,i0)
-static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _lti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define lti_d(r0,r1,i0)                        _lti_d(_jit,r0,r1,i0)
-static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _lti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define ler_f(r0,r1,r2)                        ler_d(r0,r1,r2)
 #define ler_d(r0,r1,r2)                        _ler_d(_jit,r0,r1,r2)
-static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lei_f(r0,r1,i0)                        _lei_f(_jit,r0,r1,i0)
-static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _lei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define lei_d(r0,r1,i0)                        _lei_d(_jit,r0,r1,i0)
-static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _lei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define eqr_f(r0,r1,r2)                        eqr_d(r0,r1,r2)
 #define eqr_d(r0,r1,r2)                        _eqr_d(_jit,r0,r1,r2)
-static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _eqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define eqi_f(r0,r1,i0)                        _eqi_f(_jit,r0,r1,i0)
-static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _eqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define eqi_d(r0,r1,i0)                        _eqi_d(_jit,r0,r1,i0)
-static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _eqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define ger_f(r0,r1,r2)                        ger_d(r0,r1,r2)
 #define ger_d(r0,r1,r2)                        _ger_d(_jit,r0,r1,r2)
-static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define gei_f(r0,r1,i0)                        _gei_f(_jit,r0,r1,i0)
-static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _gei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define gei_d(r0,r1,i0)                        _gei_d(_jit,r0,r1,i0)
-static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _gei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define gtr_f(r0,r1,r2)                        gtr_d(r0,r1,r2)
 #define gtr_d(r0,r1,r2)                        _gtr_d(_jit,r0,r1,r2)
-static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define gti_f(r0,r1,i0)                        _gti_f(_jit,r0,r1,i0)
-static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _gti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define gti_d(r0,r1,i0)                        _gti_d(_jit,r0,r1,i0)
-static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _gti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define ner_f(r0,r1,r2)                        ner_d(r0,r1,r2)
 #define ner_d(r0,r1,r2)                        _ner_d(_jit,r0,r1,r2)
-static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define nei_f(r0,r1,i0)                        _nei_f(_jit,r0,r1,i0)
-static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _nei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define nei_d(r0,r1,i0)                        _nei_d(_jit,r0,r1,i0)
-static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _nei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define unltr_f(r0,r1,r2)              unltr_d(r0,r1,r2)
 #define unltr_d(r0,r1,r2)              _unltr_d(_jit,r0,r1,r2)
-static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unltr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define unlti_f(r0,r1,i0)              _unlti_f(_jit,r0,r1,i0)
-static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unlti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define unlti_d(r0,r1,i0)              _unlti_d(_jit,r0,r1,i0)
-static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unlti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define unler_f(r0,r1,r2)              unler_d(r0,r1,r2)
 #define unler_d(r0,r1,r2)              _unler_d(_jit,r0,r1,r2)
-static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unler_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define unlei_f(r0,r1,i0)              _unlei_f(_jit,r0,r1,i0)
-static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unlei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define unlei_d(r0,r1,i0)              _unlei_d(_jit,r0,r1,i0)
-static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unlei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define uneqr_f(r0,r1,r2)              uneqr_d(r0,r1,r2)
 #define uneqr_d(r0,r1,r2)              _uneqr_d(_jit,r0,r1,r2)
-static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _uneqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define uneqi_f(r0,r1,i0)              _uneqi_f(_jit,r0,r1,i0)
-static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _uneqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define uneqi_d(r0,r1,i0)              _uneqi_d(_jit,r0,r1,i0)
-static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _uneqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define unger_f(r0,r1,r2)              unger_d(r0,r1,r2)
 #define unger_d(r0,r1,r2)              _unger_d(_jit,r0,r1,r2)
-static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unger_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ungei_f(r0,r1,i0)              _ungei_f(_jit,r0,r1,i0)
-static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ungei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define ungei_d(r0,r1,i0)              _ungei_d(_jit,r0,r1,i0)
-static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ungei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define ungtr_f(r0,r1,r2)              ungtr_d(r0,r1,r2)
 #define ungtr_d(r0,r1,r2)              _ungtr_d(_jit,r0,r1,r2)
-static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ungtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ungti_f(r0,r1,i0)              _ungti_f(_jit,r0,r1,i0)
-static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ungti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define ungti_d(r0,r1,i0)              _ungti_d(_jit,r0,r1,i0)
-static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ungti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define ltgtr_f(r0,r1,r2)              ltgtr_d(r0,r1,r2)
 #define ltgtr_d(r0,r1,r2)              _ltgtr_d(_jit,r0,r1,r2)
-static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltgtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ltgti_f(r0,r1,i0)              _ltgti_f(_jit,r0,r1,i0)
-static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ltgti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define ltgti_d(r0,r1,i0)              _ltgti_d(_jit,r0,r1,i0)
-static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ltgti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define ordr_f(r0,r1,r2)               ordr_d(r0,r1,r2)
 #define ordr_d(r0,r1,r2)               _ordr_d(_jit,r0,r1,r2)
-static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ordi_f(r0,r1,i0)               _ordi_f(_jit,r0,r1,i0)
-static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define ordi_d(r0,r1,i0)               _ordi_d(_jit,r0,r1,i0)
-static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define unordr_f(r0,r1,r2)             unordr_d(r0,r1,r2)
 #define unordr_d(r0,r1,r2)             _unordr_d(_jit,r0,r1,r2)
-static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define unordi_f(r0,r1,i0)             _unordi_f(_jit,r0,r1,i0)
-static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #define unordi_d(r0,r1,i0)             _unordi_d(_jit,r0,r1,i0)
-static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #define ldr_f(r0,r1)                   LDFS(r0,r1)
 #define ldi_f(r0,i0)                   _ldi_f(_jit,r0,i0)
-static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_f(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_f(r0,r1,r2)               _ldxr_f(_jit,r0,r1,r2)
-static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_f(r0,r1,i0)               _ldxi_f(_jit,r0,r1,i0)
-static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_f(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ldr_d(r0,r1)                   LDFD(r0,r1)
 #define ldi_d(r0,i0)                   _ldi_d(_jit,r0,i0)
-static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_d(jit_state_t*,int32_t,jit_word_t);
 #define ldxr_d(r0,r1,r2)               _ldxr_d(_jit,r0,r1,r2)
-static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define ldxi_d(r0,r1,i0)               _ldxi_d(_jit,r0,r1,i0)
-static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_d(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define str_f(r0,r1)                   STFS(r0,r1)
 #define sti_f(i0,r0)                   _sti_f(_jit,i0,r0)
-static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_f(jit_state_t*,jit_word_t,int32_t);
 #define stxr_f(r0,r1,r2)               _stxr_f(_jit,r0,r1,r2)
-static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi_f(i0,r0,r1)               _stxi_f(_jit,i0,r0,r1)
-static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define str_d(r0,r1)                   STFD(r0,r1)
 #define sti_d(i0,r0)                   _sti_d(_jit,i0,r0)
-static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_d(jit_state_t*,jit_word_t,int32_t);
 #define stxr_d(r0,r1,r2)               _stxr_d(_jit,r0,r1,r2)
-static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define stxi_d(i0,r0,r1)               _stxi_d(_jit,i0,r0,r1)
-static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bltr_f(i0,r0,r1)               bltr_d(i0,r0,r1)
 #define bltr_d(i0,r0,r1)               _bltr_d(_jit,i0,r0,r1)
-static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blti_f(i0,r0,i1)               _blti_f(_jit,i0,r0,i1)
-static jit_word_t _blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _blti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define blti_d(i0,r0,i1)               _blti_d(_jit,i0,r0,i1)
-static jit_word_t _blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _blti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bler_f(i0,r0,r1)               bler_d(i0,r0,r1)
 #define bler_d(i0,r0,r1)               _bler_d(_jit,i0,r0,r1)
-static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blei_f(i0,r0,i1)               _blei_f(_jit,i0,r0,i1)
-static jit_word_t _blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _blei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define blei_d(i0,r0,i1)               _blei_d(_jit,i0,r0,i1)
-static jit_word_t _blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _blei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define beqr_f(i0,r0,r1)               beqr_d(i0,r0,r1)
 #define beqr_d(i0,r0,r1)               _beqr_d(_jit,i0,r0,r1)
-static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define beqi_f(i0,r0,i1)               _beqi_f(_jit,i0,r0,i1)
-static jit_word_t _beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _beqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define beqi_d(i0,r0,i1)               _beqi_d(_jit,i0,r0,i1)
-static jit_word_t _beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _beqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bger_f(i0,r0,r1)               bger_d(i0,r0,r1)
 #define bger_d(i0,r0,r1)               _bger_d(_jit,i0,r0,r1)
-static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgei_f(i0,r0,i1)               _bgei_f(_jit,i0,r0,i1)
-static jit_word_t _bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bgei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bgei_d(i0,r0,i1)               _bgei_d(_jit,i0,r0,i1)
-static jit_word_t _bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bgei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bgtr_f(i0,r0,r1)               bgtr_d(i0,r0,r1)
 #define bgtr_d(i0,r0,r1)               _bgtr_d(_jit,i0,r0,r1)
-static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgti_f(i0,r0,i1)               _bgti_f(_jit,i0,r0,i1)
-static jit_word_t _bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bgti_d(i0,r0,i1)               _bgti_d(_jit,i0,r0,i1)
-static jit_word_t _bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bner_f(i0,r0,r1)               bner_d(i0,r0,r1)
 #define bner_d(i0,r0,r1)               _bner_d(_jit,i0,r0,r1)
-static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bnei_f(i0,r0,i1)               _bnei_f(_jit,i0,r0,i1)
-static jit_word_t _bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bnei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bnei_d(i0,r0,i1)               _bnei_d(_jit,i0,r0,i1)
-static jit_word_t _bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bnei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bunltr_f(i0,r0,r1)             bunltr_d(i0,r0,r1)
 #define bunltr_d(i0,r0,r1)             _bunltr_d(_jit,i0,r0,r1)
-static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bunlti_f(i0,r0,i1)             _bunlti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunlti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bunlti_d(i0,r0,i1)             _bunlti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunlti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bunler_f(i0,r0,r1)             bunler_d(i0,r0,r1)
 #define bunler_d(i0,r0,r1)             _bunler_d(_jit,i0,r0,r1)
-static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunler_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bunlei_f(i0,r0,i1)             _bunlei_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunlei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bunlei_d(i0,r0,i1)             _bunlei_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunlei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define buneqr_f(i0,r0,r1)             buneqr_d(i0,r0,r1)
 #define buneqr_d(i0,r0,r1)             _buneqr_d(_jit,i0,r0,r1)
-static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define buneqi_f(i0,r0,i1)             _buneqi_f(_jit,i0,r0,i1)
-static jit_word_t 
_buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define buneqi_d(i0,r0,i1)             _buneqi_d(_jit,i0,r0,i1)
-static jit_word_t 
_buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bunger_f(i0,r0,r1)             bunger_d(i0,r0,r1)
 #define bunger_d(i0,r0,r1)             _bunger_d(_jit,i0,r0,r1)
-static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bungei_f(i0,r0,i1)             _bungei_f(_jit,i0,r0,i1)
-static jit_word_t 
_bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bungei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bungei_d(i0,r0,i1)             _bungei_d(_jit,i0,r0,i1)
-static jit_word_t 
_bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bungei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bungtr_f(i0,r0,r1)             bungtr_d(i0,r0,r1)
 #define bungtr_d(i0,r0,r1)             _bungtr_d(_jit,i0,r0,r1)
-static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bungti_f(i0,r0,i1)             _bungti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bungti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bungti_d(i0,r0,i1)             _bungti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bungti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bltgtr_f(i0,r0,r1)             bltgtr_d(i0,r0,r1)
 #define bltgtr_d(i0,r0,r1)             _bltgtr_d(_jit,i0,r0,r1)
-static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bltgti_f(i0,r0,i1)             _bltgti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bltgti_d(i0,r0,i1)             _bltgti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bordr_f(i0,r0,r1)              bordr_d(i0,r0,r1)
 #define bordr_d(i0,r0,r1)              _bordr_d(_jit,i0,r0,r1)
-static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bordr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bordi_f(i0,r0,i1)              _bordi_f(_jit,i0,r0,i1)
-static jit_word_t _bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bordi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bordi_d(i0,r0,i1)              _bordi_d(_jit,i0,r0,i1)
-static jit_word_t _bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bordi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #define bunordr_f(i0,r0,r1)            bunordr_d(i0,r0,r1)
 #define bunordr_d(i0,r0,r1)            _bunordr_d(_jit,i0,r0,r1)
-static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bunordi_f(i0,r0,i1)            _bunordi_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunordi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #define bunordi_d(i0,r0,i1)            _bunordi_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunordi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define vaarg_d(r0, r1)              _vaarg_d(_jit, r0, r1)
-static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg_d(jit_state_t*, int32_t, jit_int32_t);
 #endif
 
 #if CODE
@@ -1014,13 +1014,13 @@ F16_(jit_state_t* _jit, jit_word_t _p,
 }
 
 static void
-_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
+_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t *i0)
 {
     union {
-       jit_int32_t      i;
+       int32_t  i;
        jit_float32_t    f;
     } data;
-    jit_int32_t                 reg;
+    int32_t             reg;
 
     if (_jitc->no_data) {
        data.f = *i0;
@@ -1034,13 +1034,13 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, 
jit_float32_t *i0)
 }
 
 static void
-_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
+_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t *i0)
 {
     union {
        jit_word_t       w;
        jit_float64_t    d;
     } data;
-    jit_int32_t                 reg;
+    int32_t             reg;
 
     if (_jitc->no_data) {
        data.d = *i0;
@@ -1054,7 +1054,7 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t 
*i0)
 }
 
 static void
-_movr_w_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_w_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     /* Should be used only in this case (with out0 == 120) */
     if (r1 >= 120)
@@ -1063,7 +1063,7 @@ _movr_w_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_movr_f_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_f_w(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     /* Should actually be used only in this case (with out0 == 120) */
     if (r0 >= 120)
@@ -1072,7 +1072,7 @@ _movr_f_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
+_movi_f_w(jit_state_t *_jit, int32_t r0, jit_float32_t *i0)
 {
     jit_data_t         data;
 
@@ -1088,7 +1088,7 @@ _movi_f_w(jit_state_t *_jit, jit_int32_t r0, 
jit_float32_t *i0)
 }
 
 static void
-_movr_w_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_w_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     /* Should be used only in this case (with out0 == 120) */
     if (r1 >= 120)
@@ -1097,7 +1097,7 @@ _movr_w_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_movr_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_d_w(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     /* Should be used only in this case (with out0 == 120) */
     if (r0 >= 120)
@@ -1106,7 +1106,7 @@ _movr_d_w(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
+_movi_d_w(jit_state_t *_jit, int32_t r0, jit_float64_t *i0)
 {
     union {
        jit_word_t       w;
@@ -1127,10 +1127,10 @@ _movi_d_w(jit_state_t *_jit, jit_int32_t r0, 
jit_float64_t *i0)
 #define fpr_opi(name, type, size)                                      \
 static void                                                            \
 _##name##i_##type(jit_state_t *_jit,                                   \
-                 jit_int32_t r0, jit_int32_t r1,                       \
+                 int32_t r0, jit_int32_t r1,                   \
                  jit_float##size##_t *i0)                              \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     movi_##type(rn(reg), i0);                                          \
     name##r_##type(r0, r1, rn(reg));                                   \
     jit_unget_reg(reg);                                                        
\
@@ -1138,11 +1138,11 @@ _##name##i_##type(jit_state_t *_jit,                    
                \
 #define fpr_bopi(name, type, size)                                     \
 static jit_word_t                                                      \
 _b##name##i_##type(jit_state_t *_jit,                                  \
-                 jit_word_t i0, jit_int32_t r0,                        \
+                 jit_word_t i0, int32_t r0,                    \
                  jit_float##size##_t *i1)                              \
 {                                                                      \
     jit_word_t         word;                                           \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr|                
\
+    int32_t            reg = jit_get_reg(jit_class_fpr|                \
                                          jit_class_nospill);           \
     movi_##type(rn(reg), i1);                                          \
     word = b##name##r_##type(i0, r0, rn(reg));                         \
@@ -1167,9 +1167,9 @@ dopi(div)
 
 /* translation from gcc -O0 */
 static void
-_divr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                t0, t1, t2;
+    int32_t            t0, t1, t2;
     t0 = jit_get_reg(jit_class_fpr);
     t1 = jit_get_reg(jit_class_fpr);
     t2 = jit_get_reg(jit_class_fpr);
@@ -1189,9 +1189,9 @@ _divr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_divr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                t0, t1, t2;
+    int32_t            t0, t1, t2;
     t0 = jit_get_reg(jit_class_fpr);
     t1 = jit_get_reg(jit_class_fpr);
     t2 = jit_get_reg(jit_class_fpr);
@@ -1211,9 +1211,9 @@ _divr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     SETF_SIG(rn(reg), r1);
     FCVT_XF(r0, rn(reg));
@@ -1222,9 +1222,9 @@ _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     SETF_SIG(rn(reg), r1);
     FCVT_XF(r0, rn(reg));
@@ -1233,9 +1233,9 @@ _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_d_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     FCVT_FX_TRUNC(rn(reg), r1);
     GETF_SIG(r0, rn(reg));
@@ -1244,7 +1244,7 @@ _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_LT(PR_6, PR_7, r1, r2);
     MOVI_p(r0, 1, PR_6);
@@ -1254,7 +1254,7 @@ fopi(lt)
 dopi(lt)
 
 static void
-_ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_LE(PR_6, PR_7, r1, r2);
     MOVI_p(r0, 1, PR_6);
@@ -1264,7 +1264,7 @@ fopi(le)
 dopi(le)
 
 static void
-_eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_eqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_EQ(PR_6, PR_7, r1, r2);
     MOVI_p(r0, 1, PR_6);
@@ -1274,7 +1274,7 @@ fopi(eq)
 dopi(eq)
 
 static void
-_ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_LE(PR_6, PR_7, r2, r1);
     MOVI_p(r0, 1, PR_6);
@@ -1284,7 +1284,7 @@ fopi(ge)
 dopi(ge)
 
 static void
-_gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_LT(PR_6, PR_7, r2, r1);
     MOVI_p(r0, 1, PR_6);
@@ -1294,7 +1294,7 @@ fopi(gt)
 dopi(gt)
 
 static void
-_ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_EQ(PR_6, PR_7, r1, r2);
     MOV_p(r0, GR_0, PR_6);
@@ -1304,7 +1304,7 @@ fopi(ne)
 dopi(ne)
 
 static void
-_unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unltr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_LE(PR_6, PR_7, r2, r1);
     MOV_p(r0, GR_0, PR_6);
@@ -1314,7 +1314,7 @@ fopi(unlt)
 dopi(unlt)
 
 static void
-_unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unler_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_LT(PR_6, PR_7, r2, r1);
     MOV_p(r0, GR_0, PR_6);
@@ -1324,7 +1324,7 @@ fopi(unle)
 dopi(unle)
 
 static void
-_uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_uneqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     MOVI(r0, 1);
     FCMP_LT(PR_8, PR_9, r1, r2);
@@ -1336,7 +1336,7 @@ fopi(uneq)
 dopi(uneq)
 
 static void
-_unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unger_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_LT(PR_6, PR_7, r1, r2);
     MOV_p(r0, GR_0, PR_6);
@@ -1346,7 +1346,7 @@ fopi(unge)
 dopi(unge)
 
 static void
-_ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ungtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_LE(PR_6, PR_7, r1, r2);
     MOV_p(r0, GR_0, PR_6);
@@ -1356,7 +1356,7 @@ fopi(ungt)
 dopi(ungt)
 
 static void
-_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltgtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     MOVI(r0, 1);
     FCMP_EQ(PR_8, PR_9, r1, r2);
@@ -1368,7 +1368,7 @@ fopi(ltgt)
 dopi(ltgt)
 
 static void
-_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_UNORD(PR_6, PR_7, r1, r2);
     MOV_p(r0, GR_0, PR_6);
@@ -1378,7 +1378,7 @@ fopi(ord)
 dopi(ord)
 
 static void
-_unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMP_UNORD(PR_6, PR_7, r1, r2);
     MOVI_p(r0, 1, PR_6);
@@ -1388,9 +1388,9 @@ fopi(unord)
 dopi(unord)
 
 static void
-_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_f(r0, rn(reg));
@@ -1398,9 +1398,9 @@ _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_f(r0, rn(reg));
@@ -1408,9 +1408,9 @@ _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0) {
        reg = jit_get_reg(jit_class_gpr);
        addi(rn(reg), r1, i0);
@@ -1422,9 +1422,9 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ldr_d(r0, rn(reg));
@@ -1432,9 +1432,9 @@ _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_d(r0, rn(reg));
@@ -1442,9 +1442,9 @@ _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0) {
        reg = jit_get_reg(jit_class_gpr);
        addi(rn(reg), r1, i0);
@@ -1456,9 +1456,9 @@ _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_f(rn(reg), r0);
@@ -1466,9 +1466,9 @@ _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_f(rn(reg), r2);
@@ -1476,9 +1476,9 @@ _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        addi(rn(reg), r0, i0);
@@ -1490,9 +1490,9 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     str_d(rn(reg), r0);
@@ -1500,9 +1500,9 @@ _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_d(rn(reg), r2);
@@ -1510,9 +1510,9 @@ _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0) {
        reg = jit_get_reg(jit_class_gpr);
        addi(rn(reg), r0, i0);
@@ -1524,7 +1524,7 @@ _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_sqrtr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     movr_f(GR_8, r1);
     calli((jit_word_t)sqrtf);
@@ -1532,7 +1532,7 @@ _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_sqrtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     movr_d(GR_8, r1);
     calli((jit_word_t)sqrt);
@@ -1540,7 +1540,7 @@ _sqrtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static jit_word_t
-_bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_LT(PR_6, PR_7, r0, r1);
@@ -1553,7 +1553,7 @@ fbopi(lt)
 dbopi(lt)
 
 static jit_word_t
-_bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_LE(PR_6, PR_7, r0, r1);
@@ -1566,7 +1566,7 @@ fbopi(le)
 dbopi(le)
 
 static jit_word_t
-_beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_beqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_EQ(PR_6, PR_7, r0, r1);
@@ -1579,7 +1579,7 @@ fbopi(eq)
 dbopi(eq)
 
 static jit_word_t
-_bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_LE(PR_6, PR_7, r1, r0);
@@ -1592,7 +1592,7 @@ fbopi(ge)
 dbopi(ge)
 
 static jit_word_t
-_bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_LT(PR_6, PR_7, r1, r0);
@@ -1605,7 +1605,7 @@ fbopi(gt)
 dbopi(gt)
 
 static jit_word_t
-_bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bner_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_EQ(PR_6, PR_7, r0, r1);
@@ -1618,7 +1618,7 @@ fbopi(ne)
 dbopi(ne)
 
 static jit_word_t
-_bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunltr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_LE(PR_6, PR_7, r1, r0);
@@ -1631,7 +1631,7 @@ fbopi(unlt)
 dbopi(unlt)
 
 static jit_word_t
-_bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunler_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_LT(PR_6, PR_7, r1, r0);
@@ -1644,7 +1644,7 @@ fbopi(unle)
 dbopi(unle)
 
 static jit_word_t
-_buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_buneqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     jit_word_t         junord, jne;
@@ -1672,7 +1672,7 @@ fbopi(uneq)
 dbopi(uneq)
 
 static jit_word_t
-_bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunger_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_LT(PR_6, PR_7, r0, r1);
@@ -1685,7 +1685,7 @@ fbopi(unge)
 dbopi(unge)
 
 static jit_word_t
-_bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bungtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_LE(PR_6, PR_7, r0, r1);
@@ -1698,7 +1698,7 @@ fbopi(ungt)
 dbopi(ungt)
 
 static jit_word_t
-_bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     jit_word_t         jeq, junord;
@@ -1725,7 +1725,7 @@ fbopi(ltgt)
 dbopi(ltgt)
 
 static jit_word_t
-_bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bordr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_UNORD(PR_6, PR_7, r0, r1);
@@ -1738,7 +1738,7 @@ fbopi(ord)
 dbopi(ord)
 
 static jit_word_t
-_bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunordr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
     FCMP_UNORD(PR_6, PR_7, r0, r1);
@@ -1751,7 +1751,7 @@ fbopi(unord)
 dbopi(unord)
 
 static void
-_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
     /* Load argument. */
diff --git a/jit/ia64.c b/jit/ia64.c
index 96f1b59..6da15f3 100644
--- a/jit/ia64.c
+++ b/jit/ia64.c
@@ -27,9 +27,9 @@
 #  define I_DISP                       0
 #  define F_DISP                       0
 #else
-#  define C_DISP                       8 - sizeof(jit_int8_t)
-#  define S_DISP                       8 - sizeof(jit_int16_t)
-#  define I_DISP                       8 - sizeof(jit_int32_t)
+#  define C_DISP                       8 - sizeof(int8_t)
+#  define S_DISP                       8 - sizeof(int16_t)
+#  define I_DISP                       8 - sizeof(int32_t)
 #  define F_DISP                       8 - sizeof(jit_float32_t)
 #endif
 
@@ -251,7 +251,7 @@ _jit_init(jit_state_t *_jit)
 void
 _jit_prolog(jit_state_t *_jit)
 {
-    jit_int32_t                offset;
+    int32_t            offset;
 
     if (_jitc->function)
        jit_epilog();
@@ -273,7 +273,7 @@ _jit_prolog(jit_state_t *_jit)
        _jitc->function->self.aoff = _jitc->function->self.alen = 0;
     _jitc->function->self.call = jit_call_default;
     jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
-             _jitc->reglen * sizeof(jit_int32_t));
+             _jitc->reglen * sizeof(int32_t));
 
     /* _no_link here does not mean the jit_link() call can be removed
      * by rewriting as:
@@ -292,8 +292,8 @@ _jit_prolog(jit_state_t *_jit)
     jit_regset_new(&_jitc->function->regset);
 }
 
-jit_int32_t
-_jit_allocai(jit_state_t *_jit, jit_int32_t length)
+int32_t
+_jit_allocai(jit_state_t *_jit, int32_t length)
 {
     assert(_jitc->function);
     switch (length) {
@@ -311,13 +311,13 @@ _jit_allocai(jit_state_t *_jit, jit_int32_t length)
 }
 
 void
-_jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_allocar(jit_state_t *_jit, int32_t u, jit_int32_t v)
 {
-    jit_int32_t                 reg;
+    int32_t             reg;
     assert(_jitc->function);
     jit_inc_synth_ww(allocar, u, v);
     if (!_jitc->function->allocar) {
-       _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
+       _jitc->function->aoffoff = jit_allocai(sizeof(int32_t));
        _jitc->function->allocar = 1;
     }
     reg = jit_get_reg(jit_class_gpr);
@@ -344,7 +344,7 @@ _jit_ret(jit_state_t *_jit)
 }
 
 void
-_jit_retr(jit_state_t *_jit, jit_int32_t u)
+_jit_retr(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr, u);
     jit_movr(JIT_RET, u);
@@ -362,7 +362,7 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_f(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_f, u);
     jit_movr_f(JIT_FRET, u);
@@ -380,7 +380,7 @@ _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_d(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_d, u);
     jit_movr_d(JIT_FRET, u);
@@ -433,7 +433,7 @@ _jit_ellipsis(jit_state_t *_jit)
 }
 
 void
-_jit_va_push(jit_state_t *_jit, jit_int32_t u)
+_jit_va_push(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(va_push, u);
     jit_pushargr(u);
@@ -444,7 +444,7 @@ jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     if (jit_arg_reg_p(_jitc->function->self.argi))
        offset = _jitc->function->self.argi++;
@@ -462,7 +462,7 @@ jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     if (jit_arg_reg_p(_jitc->function->self.argi)) {
        if (!(_jitc->function->self.call & jit_call_varargs))
@@ -485,7 +485,7 @@ jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     if (jit_arg_reg_p(_jitc->function->self.argi)) {
        if (!(_jitc->function->self.call & jit_call_varargs))
@@ -505,7 +505,7 @@ _jit_arg_d(jit_state_t *_jit)
 }
 
 void
-_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_c(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_c, u, v);
@@ -517,7 +517,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_uc(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_uc, u, v);
@@ -529,7 +529,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_s(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_s, u, v);
@@ -541,7 +541,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_us(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_us, u, v);
@@ -553,7 +553,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_i(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_i, u, v);
@@ -565,7 +565,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_ui(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_ui, u, v);
@@ -577,7 +577,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_l(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_l, u, v);
@@ -589,7 +589,7 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargr, u, v);
@@ -603,7 +603,7 @@ _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargi, u, v);
     if (jit_arg_reg_p(v->u.w))
@@ -618,7 +618,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 }
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(getarg_f, u, v);
@@ -632,7 +632,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(putargr_f, u, v);
@@ -648,7 +648,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_fp(putargi_f, u, v);
     if (jit_arg_reg_p(v->u.w))
@@ -665,7 +665,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, 
jit_node_t *v)
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(getarg_d, u, v);
@@ -679,7 +679,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(putargr_d, u, v);
@@ -695,7 +695,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_dp(putargi_d, u, v);
     if (jit_arg_reg_p(v->u.w))
@@ -712,7 +712,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, 
jit_node_t *v)
 }
 
 void
-_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr, u);
@@ -731,7 +731,7 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_w(pushargi, u);
     jit_link_prepare();
@@ -750,7 +750,7 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_f(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_f, u);
@@ -775,7 +775,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_f(pushargi_f, u);
     jit_link_prepare();
@@ -800,7 +800,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_d(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_d, u);
@@ -824,7 +824,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_d(pushargi_d, u);
     jit_link_prepare();
@@ -848,14 +848,14 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 }
 
 jit_bool_t
-_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, int32_t regno)
 {
     /* Argument registers are allocated from the pool of unused registers */
     return (0);
 }
 
 void
-_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
+_jit_finishr(jit_state_t *_jit, int32_t r0)
 {
     jit_node_t         *call;
     assert(_jitc->function);
@@ -890,7 +890,7 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
 }
 
 void
-_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_c(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_c, r0);
     jit_extr_c(r0, JIT_RET);
@@ -898,7 +898,7 @@ _jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_uc(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_uc, r0);
     jit_extr_uc(r0, JIT_RET);
@@ -906,7 +906,7 @@ _jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_s(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_s, r0);
     jit_extr_s(r0, JIT_RET);
@@ -914,7 +914,7 @@ _jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_us(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_us, r0);
     jit_extr_us(r0, JIT_RET);
@@ -922,7 +922,7 @@ _jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_i(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_i, r0);
     jit_extr_i(r0, JIT_RET);
@@ -930,7 +930,7 @@ _jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_ui(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_ui, r0);
     jit_extr_ui(r0, JIT_RET);
@@ -938,7 +938,7 @@ _jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_l(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_l, r0);
     jit_movr(r0, JIT_RET);
@@ -946,7 +946,7 @@ _jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_f(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_l, r0);
     jit_movr_f(r0, JIT_FRET);
@@ -954,7 +954,7 @@ _jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
 }
 
 void
-_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_d(jit_state_t *_jit, int32_t r0)
 {
     jit_inc_synth_w(retval_d, r0);
     jit_movr_d(r0, JIT_FRET);
@@ -967,15 +967,15 @@ _emit_code(jit_state_t *_jit)
     jit_node_t         *node;
     jit_node_t         *temp;
     jit_word_t          word;
-    jit_int32_t                 value;
-    jit_int32_t                 offset;
+    int32_t             value;
+    int32_t             offset;
     struct {
        jit_node_t      *node;
        jit_word_t       word;
 #if DEVEL_DISASSEMBLER
        jit_word_t       prevw;
 #endif
-       jit_int32_t      patch_offset;
+       int32_t  patch_offset;
        jit_word_t       prolog_offset;
     } undo;
 #if DEVEL_DISASSEMBLER
@@ -1751,7 +1751,7 @@ _emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_gpr_t 
r0, jit_fpr_t r1)
 static void
 _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
 {
-    jit_int32_t                flag;
+    int32_t            flag;
 
     assert(node->flag & jit_flag_node);
     if (node->code == jit_code_movi)
diff --git a/jit/jit.c b/jit/jit.c
index f906899..da630b0 100644
--- a/jit/jit.c
+++ b/jit/jit.c
@@ -127,12 +127,12 @@ _redundant_store(jit_state_t *_jit, jit_node_t *node, 
jit_bool_t jump);
 #define simplify_movr(p, n, k, s)      _simplify_movr(_jit, p, n, k, s)
 static jit_bool_t
 _simplify_movr(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node,
-              jit_int32_t kind, jit_int32_t size);
+              int32_t kind, jit_int32_t size);
 
 #define simplify_movi(p, n, k, s)      _simplify_movi(_jit, p, n, k, s)
 static jit_bool_t
 _simplify_movi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node,
-              jit_int32_t kind, jit_int32_t size);
+              int32_t kind, jit_int32_t size);
 
 #define simplify_ldxi(prev, node)      _simplify_ldxi(_jit, prev, node)
 static jit_bool_t
@@ -144,7 +144,7 @@ _simplify_stxi(jit_state_t *_jit, jit_node_t *prev, 
jit_node_t *node);
 
 #define simplify_spill(node, regno)    _simplify_spill(_jit, node, regno)
 static void
-_simplify_spill(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno);
+_simplify_spill(jit_state_t *_jit, jit_node_t *node, int32_t regno);
 
 #define simplify()                     _simplify(_jit)
 static void
@@ -154,13 +154,13 @@ _simplify(jit_state_t *_jit);
 #define jit_reg_static                  0
 #define jit_reg_change                  1
 #define register_change_p(n, l, r)     _register_change_p(_jit, n, l, r)
-static jit_int32_t
+static int32_t
 _register_change_p(jit_state_t *_jit, jit_node_t *node, jit_node_t *link,
-                  jit_int32_t regno);
+                  int32_t regno);
 
 #define spill_reglive_p(node, regno)   _spill_reglive_p(_jit, node, regno)
 static jit_bool_t
-_spill_reglive_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno);
+_spill_reglive_p(jit_state_t *_jit, jit_node_t *node, int32_t regno);
 
 #define patch_registers()              _patch_registers(_jit)
 static void
@@ -169,7 +169,7 @@ _patch_registers(jit_state_t *_jit);
 #define patch_register(n,l,r,p)                _patch_register(_jit,n,l,r,p)
 static void
 _patch_register(jit_state_t *jit, jit_node_t *node, jit_node_t *link,
-               jit_int32_t regno, jit_int32_t patch);
+               int32_t regno, jit_int32_t patch);
 
 /*
  * Initialization
@@ -196,11 +196,11 @@ finish_jit(void)
     jit_finish_size();
 }
 
-jit_int32_t
-_jit_get_reg(jit_state_t *_jit, jit_int32_t regspec)
+int32_t
+_jit_get_reg(jit_state_t *_jit, int32_t regspec)
 {
-    jit_int32_t                spec;
-    jit_int32_t                regno;
+    int32_t            spec;
+    int32_t            regno;
 
     spec = regspec & ~(jit_class_chk|jit_class_nospill);
     if (spec & jit_class_named) {
@@ -311,7 +311,7 @@ fail:
 }
 
 void
-_jit_unget_reg(jit_state_t *_jit, jit_int32_t regno)
+_jit_unget_reg(jit_state_t *_jit, int32_t regno)
 {
     regno = jit_regno(regno);
     if (jit_regset_tstbit(&_jitc->regsav, regno)) {
@@ -339,7 +339,7 @@ _jit_unget_reg(jit_state_t *_jit, jit_int32_t regno)
 }
 
 jit_bool_t
-_jit_callee_save_p(jit_state_t *_jit, jit_int32_t regno)
+_jit_callee_save_p(jit_state_t *_jit, int32_t regno)
 {
     assert(regno >= 0 && regno < JIT_NOREG);
     return (!!(_rvs[regno].spec & jit_class_sav));
@@ -348,7 +348,7 @@ _jit_callee_save_p(jit_state_t *_jit, jit_int32_t regno)
 extern jit_bool_t
 _jit_pointer_p(jit_state_t *_jit, jit_pointer_t address)
 {
-    return ((jit_uint8_t *)address >= _jit->code.ptr &&
+    return ((uint8_t *)address >= _jit->code.ptr &&
            (jit_word_t)address < _jit->pc.w);
 }
 
@@ -389,7 +389,7 @@ jit_regset_set(jit_regset_t *u, jit_regset_t *v)
 }
 
 void
-jit_regset_set_mask(jit_regset_t *u, jit_int32_t v)
+jit_regset_set_mask(jit_regset_t *u, int32_t v)
 {
     jit_bool_t         w = !!(v & (v - 1));
 
@@ -436,7 +436,7 @@ jit_regset_set_p(jit_regset_t *u)
 }
 
 void
-jit_regset_clrbit(jit_regset_t *set, jit_int32_t bit)
+jit_regset_clrbit(jit_regset_t *set, int32_t bit)
 {
     assert(bit >= 0 && bit <= 255);
     if (bit < 64)
@@ -450,7 +450,7 @@ jit_regset_clrbit(jit_regset_t *set, jit_int32_t bit)
 }
 
 void
-jit_regset_setbit(jit_regset_t *set, jit_int32_t bit)
+jit_regset_setbit(jit_regset_t *set, int32_t bit)
 {
     assert(bit >= 0 && bit <= 255);
     if (bit < 64)
@@ -464,7 +464,7 @@ jit_regset_setbit(jit_regset_t *set, jit_int32_t bit)
 }
 
 jit_bool_t
-jit_regset_tstbit(jit_regset_t *set, jit_int32_t bit)
+jit_regset_tstbit(jit_regset_t *set, int32_t bit)
 {
     assert(bit >= 0 && bit <= 255);
     if (bit < 64)
@@ -477,7 +477,7 @@ jit_regset_tstbit(jit_regset_t *set, jit_int32_t bit)
 }
 
 unsigned long
-jit_regset_scan1(jit_regset_t *set, jit_int32_t offset)
+jit_regset_scan1(jit_regset_t *set, int32_t offset)
 {
     assert(offset >= 0 && offset <= 255);
     for (; offset < 64; offset++) {
@@ -531,7 +531,7 @@ jit_regset_set(jit_regset_t *u, jit_regset_t *v)
 }
 
 void
-jit_regset_set_mask(jit_regset_t *u, jit_int32_t v)
+jit_regset_set_mask(jit_regset_t *u, int32_t v)
 {
     jit_bool_t         w = !!(v & (v - 1));
 
@@ -568,7 +568,7 @@ jit_regset_set_p(jit_regset_t *u)
 }
 
 void
-jit_regset_clrbit(jit_regset_t *set, jit_int32_t bit)
+jit_regset_clrbit(jit_regset_t *set, int32_t bit)
 {
     assert(bit >= 0 && bit <= 128);
     if (bit < 64)
@@ -578,7 +578,7 @@ jit_regset_clrbit(jit_regset_t *set, jit_int32_t bit)
 }
 
 void
-jit_regset_setbit(jit_regset_t *set, jit_int32_t bit)
+jit_regset_setbit(jit_regset_t *set, int32_t bit)
 {
     assert(bit >= 0 && bit <= 127);
     if (bit < 64)
@@ -588,7 +588,7 @@ jit_regset_setbit(jit_regset_t *set, jit_int32_t bit)
 }
 
 jit_bool_t
-jit_regset_tstbit(jit_regset_t *set, jit_int32_t bit)
+jit_regset_tstbit(jit_regset_t *set, int32_t bit)
 {
     assert(bit >= 0 && bit <= 127);
     if (bit < 64)
@@ -598,7 +598,7 @@ jit_regset_tstbit(jit_regset_t *set, jit_int32_t bit)
 }
 
 unsigned long
-jit_regset_scan1(jit_regset_t *set, jit_int32_t offset)
+jit_regset_scan1(jit_regset_t *set, int32_t offset)
 {
     assert(offset >= 0 && offset <= 127);
     for (; offset < 64; offset++) {
@@ -614,7 +614,7 @@ jit_regset_scan1(jit_regset_t *set, jit_int32_t offset)
 
 #else
 unsigned long
-jit_regset_scan1(jit_regset_t *set, jit_int32_t offset)
+jit_regset_scan1(jit_regset_t *set, int32_t offset)
 {
     jit_regset_t       mask;
     assert(offset >= 0 && offset <= 63);
@@ -631,7 +631,7 @@ jit_regset_scan1(jit_regset_t *set, jit_int32_t offset)
 #endif
 
 void
-_jit_save(jit_state_t *_jit, jit_int32_t reg)
+_jit_save(jit_state_t *_jit, int32_t reg)
 {
     reg = jit_regno(reg);
     assert(!_jitc->realize);
@@ -639,7 +639,7 @@ _jit_save(jit_state_t *_jit, jit_int32_t reg)
 }
 
 void
-_jit_load(jit_state_t *_jit, jit_int32_t reg)
+_jit_load(jit_state_t *_jit, int32_t reg)
 {
     jit_node_t         *node;
 
@@ -656,7 +656,7 @@ _jit_load(jit_state_t *_jit, jit_int32_t reg)
 static jit_word_t
 hash_data(const void *data, jit_word_t length)
 {
-    const jit_uint8_t          *ptr;
+    const uint8_t              *ptr;
     jit_word_t          i, key;
     for (i = key = 0, ptr = data; i < length; i++)
        key = (key << (key & 1)) ^ ptr[i];
@@ -677,7 +677,7 @@ _jit_address(jit_state_t *_jit, jit_node_t *node)
 
 jit_node_t *
 _jit_data(jit_state_t *_jit, const void *data,
-         jit_word_t length, jit_int32_t align)
+         jit_word_t length, int32_t align)
 {
     jit_word_t          key;
     jit_node_t         *node;
@@ -769,10 +769,10 @@ static void
 _new_pool(jit_state_t *_jit)
 {
     jit_node_t         *list;
-    jit_int32_t                 offset;
+    int32_t             offset;
 
     if (_jitc->pool.offset >= _jitc->pool.length) {
-       jit_int32_t      length;
+       int32_t  length;
 
        length = _jitc->pool.length + 16;
        jit_realloc((jit_pointer_t *)&_jitc->pool.ptr,
@@ -932,7 +932,7 @@ jit_new_state(void)
     jit_alloc((jit_pointer_t *)&_jitc->spill,
              _jitc->reglen * sizeof(jit_node_t*));
     jit_alloc((jit_pointer_t *)&_jitc->gen,
-             _jitc->reglen * sizeof(jit_int32_t));
+             _jitc->reglen * sizeof(int32_t));
     jit_alloc((jit_pointer_t *)&_jitc->values,
              _jitc->reglen * sizeof(jit_value_t));
 
@@ -1192,7 +1192,7 @@ _jit_new_node_www(jit_state_t *_jit, jit_code_t code,
 
 jit_node_t *
 _jit_new_node_qww(jit_state_t *_jit, jit_code_t code,
-                 jit_int32_t l, jit_int32_t h,
+                 int32_t l, jit_int32_t h,
                  jit_word_t v, jit_word_t w)
 {
     jit_node_t         *node = new_node(code);
@@ -1360,10 +1360,10 @@ _jit_patch(jit_state_t* _jit, jit_node_t *instr)
     jit_patch_at(instr, label);
 }
 
-jit_int32_t
+int32_t
 _jit_classify(jit_state_t *_jit, jit_code_t code)
 {
-    jit_int32_t                mask;
+    int32_t            mask;
 
     switch (code) {
        case jit_code_data:     case jit_code_save:     case jit_code_load:
@@ -1612,7 +1612,7 @@ _jit_classify(jit_state_t *_jit, jit_code_t code)
 void
 _jit_patch_abs(jit_state_t *_jit, jit_node_t *instr, jit_pointer_t address)
 {
-    jit_int32_t                mask;
+    int32_t            mask;
 
     if (instr->code == jit_code_movi)
        instr->v.p = address;
@@ -1626,7 +1626,7 @@ _jit_patch_abs(jit_state_t *_jit, jit_node_t *instr, 
jit_pointer_t address)
 void
 _jit_patch_at(jit_state_t *_jit, jit_node_t *instr, jit_node_t *label)
 {
-    jit_int32_t                mask;
+    int32_t            mask;
 
     assert(!(instr->flag & jit_flag_node));
     instr->flag |= jit_flag_node;
@@ -1659,7 +1659,7 @@ void
 _jit_optimize(jit_state_t *_jit)
 {
     jit_bool_t          jump;
-    jit_int32_t                 mask;
+    int32_t             mask;
     jit_node_t         *node;
     jit_block_t                *block;
     jit_word_t          offset;
@@ -1809,8 +1809,8 @@ _jit_optimize(jit_state_t *_jit)
 void
 _jit_reglive(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                 spec;
-    jit_int32_t                 value;
+    int32_t             spec;
+    int32_t             value;
     jit_block_t                *block;
 
     switch (node->code) {
@@ -1895,7 +1895,7 @@ _jit_reglive(jit_state_t *_jit, jit_node_t *node)
 }
 
 void
-_jit_regarg_set(jit_state_t *_jit, jit_node_t *node, jit_int32_t value)
+_jit_regarg_set(jit_state_t *_jit, jit_node_t *node, int32_t value)
 {
 #if GET_JIT_SIZE
     jit_size_prepare();
@@ -1915,7 +1915,7 @@ _jit_regarg_set(jit_state_t *_jit, jit_node_t *node, 
jit_int32_t value)
 }
 
 void
-_jit_regarg_clr(jit_state_t *_jit, jit_node_t *node, jit_int32_t value)
+_jit_regarg_clr(jit_state_t *_jit, jit_node_t *node, int32_t value)
 {
 #if GET_JIT_SIZE
     jit_size_collect(node);
@@ -1958,7 +1958,7 @@ _jit_realize(jit_state_t *_jit)
 void
 _jit_dataset(jit_state_t *_jit)
 {
-    jit_uint8_t                *ptr;
+    uint8_t            *ptr;
     jit_node_t         *node;
     jit_word_t          offset;
 #if defined(__sgi)
@@ -2184,21 +2184,21 @@ fail:
 }
 
 void
-_jit_frame(jit_state_t *_jit, jit_int32_t frame)
+_jit_frame(jit_state_t *_jit, int32_t frame)
 {
     jit_trampoline(frame, 1);
 }
 
 void
-_jit_tramp(jit_state_t *_jit, jit_int32_t frame)
+_jit_tramp(jit_state_t *_jit, int32_t frame)
 {
     jit_trampoline(frame, 0);
 }
 
 void
-_jit_trampoline(jit_state_t *_jit, jit_int32_t frame, jit_bool_t prolog)
+_jit_trampoline(jit_state_t *_jit, int32_t frame, jit_bool_t prolog)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
 
     /* Must be called after prolog, actually, just to simplify
      * tests and know there is a current function and that
@@ -2310,8 +2310,8 @@ static void
 _jit_update(jit_state_t *_jit, jit_node_t *node,
            jit_regset_t *live, jit_regset_t *mask, jit_bool_t recurse)
 {
-    jit_int32_t                 spec;
-    jit_int32_t                 regno;
+    int32_t             spec;
+    int32_t             regno;
     jit_regset_t        ztmp;
     jit_regset_t        zmask;
     unsigned long       value;
@@ -2477,7 +2477,7 @@ _thread_jumps(jit_state_t *_jit)
     jit_node_t         *prev;
     jit_node_t         *node;
     jit_node_t         *next;
-    jit_int32_t                 mask;
+    int32_t             mask;
 
     for (prev = node = _jitc->head; node;) {
        next = node->next;
@@ -2826,8 +2826,8 @@ _redundant_store(jit_state_t *_jit, jit_node_t *node, 
jit_bool_t jump)
     jit_node_t         *iter;
     jit_node_t         *prev;
     jit_word_t          word;
-    jit_int32_t                 spec;
-    jit_int32_t                 regno;
+    int32_t             spec;
+    int32_t             regno;
 
     if (jump) {
        prev = node->u.n;
@@ -2889,10 +2889,10 @@ _redundant_store(jit_state_t *_jit, jit_node_t *node, 
jit_bool_t jump)
 
 static jit_bool_t
 _simplify_movr(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node,
-              jit_int32_t kind, jit_int32_t size)
+              int32_t kind, jit_int32_t size)
 {
-    jit_int32_t                 regno;
-    jit_int32_t                 right;
+    int32_t             regno;
+    int32_t             right;
     jit_value_t                *value;
 
     regno = jit_regno(node->u.w);
@@ -2920,12 +2920,12 @@ _simplify_movr(jit_state_t *_jit, jit_node_t *prev, 
jit_node_t *node,
 
 static jit_bool_t
 _simplify_movi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node,
-              jit_int32_t kind, jit_int32_t size)
+              int32_t kind, jit_int32_t size)
 {
     jit_value_t                *value;
-    jit_int32_t                 spec;
-    jit_int32_t                 regno;
-    jit_int32_t                 offset;
+    int32_t             spec;
+    int32_t             regno;
+    int32_t             offset;
 
     regno = jit_regno(node->u.w);
     value = _jitc->values + regno;
@@ -2976,8 +2976,8 @@ static jit_bool_t
 _simplify_ldxi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node)
 {
     jit_value_t                *value;
-    jit_int32_t                 regno;
-    jit_int32_t                 right;
+    int32_t             regno;
+    int32_t             right;
 
     regno = jit_regno(node->u.w);
     right = jit_regno(node->v.w);
@@ -3003,9 +3003,9 @@ static jit_bool_t
 _simplify_stxi(jit_state_t *_jit, jit_node_t *prev, jit_node_t *node)
 {
     jit_value_t                *value;
-    jit_int32_t                 regno;
-    jit_int32_t                 right;
-    jit_int32_t                 offset;
+    int32_t             regno;
+    int32_t             right;
+    int32_t             offset;
 
     regno = jit_regno(node->w.w);
     right = jit_regno(node->v.w);
@@ -3055,7 +3055,7 @@ _simplify_stxi(jit_state_t *_jit, jit_node_t *prev, 
jit_node_t *node)
  * jit_get_reg/jit_unget_reg, but properly handle
  * multiple ones by moving the save node */
 static void
-_simplify_spill(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+_simplify_spill(jit_state_t *_jit, jit_node_t *node, int32_t regno)
 {
     jit_node_t         *save;
     jit_node_t         *temp;
@@ -3078,8 +3078,8 @@ _simplify(jit_state_t *_jit)
     jit_node_t         *prev;
     jit_node_t         *node;
     jit_node_t         *next;
-    jit_int32_t                 info;
-    jit_int32_t                 regno;
+    int32_t             info;
+    int32_t             regno;
 
     for (prev = NULL, node = _jitc->head; node; prev = node, node = next) {
        next = node->next;
@@ -3087,7 +3087,7 @@ _simplify(jit_state_t *_jit)
            case jit_code_label:        case jit_code_prolog:
            case jit_code_callr:        case jit_code_calli:
            reset:
-               memset(_jitc->gen, 0, sizeof(jit_int32_t) * _jitc->reglen);
+               memset(_jitc->gen, 0, sizeof(int32_t) * _jitc->reglen);
                memset(_jitc->values, 0, sizeof(jit_value_t) * _jitc->reglen);
                break;
            case jit_code_save:
@@ -3197,11 +3197,11 @@ _simplify(jit_state_t *_jit)
     }
 }
 
-static jit_int32_t
+static int32_t
 _register_change_p(jit_state_t *_jit, jit_node_t *node, jit_node_t *link,
-                  jit_int32_t regno)
+                  int32_t regno)
 {
-    jit_int32_t                value;
+    int32_t            value;
 
     for (; node != link; node = node->next) {
        switch (node->code) {
@@ -3240,7 +3240,7 @@ _register_change_p(jit_state_t *_jit, jit_node_t *node, 
jit_node_t *link,
  * avoid complications on different cpu backends and patch spill/loads
  * here, by simulating jit generation */
 static jit_bool_t
-_spill_reglive_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+_spill_reglive_p(jit_state_t *_jit, jit_node_t *node, int32_t regno)
 {
     if (!jit_regset_tstbit(&_jitc->reglive, regno)) {
        bmp_zero();
@@ -3260,10 +3260,10 @@ _patch_registers(jit_state_t *_jit)
     jit_node_t         *prev;
     jit_node_t         *node;
     jit_node_t         *next;
-    jit_int32_t                 info;
-    jit_int32_t                 spec;
-    jit_int32_t                 regno;
-    jit_int32_t                 value;
+    int32_t             info;
+    int32_t             spec;
+    int32_t             regno;
+    int32_t             value;
 
     _jitc->function = NULL;
 
@@ -3376,9 +3376,9 @@ _patch_registers(jit_state_t *_jit)
 
 static void
 _patch_register(jit_state_t *_jit, jit_node_t *node, jit_node_t *link,
-               jit_int32_t regno, jit_int32_t patch)
+               int32_t regno, jit_int32_t patch)
 {
-    jit_int32_t                value;
+    int32_t            value;
 
     for (; node != link; node = node->next) {
        value = jit_classify(node->code);
diff --git a/jit/mips-cpu.c b/jit/mips-cpu.c
index f68040f..8756069 100644
--- a/jit/mips-cpu.c
+++ b/jit/mips-cpu.c
@@ -20,37 +20,37 @@
 #if PROTO
 typedef union {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-    struct {   jit_uint32_t _:26;      jit_uint32_t b :  6; } hc;
-    struct {   jit_uint32_t _:21;      jit_uint32_t b :  5; } rs;
-    struct {   jit_uint32_t _:21;      jit_uint32_t b :  5; } fm;
-    struct {   jit_uint32_t _:16;      jit_uint32_t b :  5; } rt;
-    struct {   jit_uint32_t _:16;      jit_uint32_t b :  5; } ft;
-    struct {   jit_uint32_t _:11;      jit_uint32_t b :  5; } rd;
-    struct {   jit_uint32_t _:11;      jit_uint32_t b :  5; } fs;
-    struct {   jit_uint32_t _: 6;      jit_uint32_t b :  5; } ic;
-    struct {   jit_uint32_t _: 6;      jit_uint32_t b :  5; } fd;
-    struct {   jit_uint32_t _: 6;      jit_uint32_t b : 10; } tr;
-    struct {   jit_uint32_t _: 6;      jit_uint32_t b : 20; } br;
-    struct {                           jit_uint32_t b :  6; } tc;
-    struct {                           jit_uint32_t b : 11; } cc;
-    struct {                           jit_uint32_t b : 16; } is;
-    struct {                           jit_uint32_t b : 26; } ii;
+    struct {   uint32_t _:26;  jit_uint32_t b :  6; } hc;
+    struct {   uint32_t _:21;  jit_uint32_t b :  5; } rs;
+    struct {   uint32_t _:21;  jit_uint32_t b :  5; } fm;
+    struct {   uint32_t _:16;  jit_uint32_t b :  5; } rt;
+    struct {   uint32_t _:16;  jit_uint32_t b :  5; } ft;
+    struct {   uint32_t _:11;  jit_uint32_t b :  5; } rd;
+    struct {   uint32_t _:11;  jit_uint32_t b :  5; } fs;
+    struct {   uint32_t _: 6;  jit_uint32_t b :  5; } ic;
+    struct {   uint32_t _: 6;  jit_uint32_t b :  5; } fd;
+    struct {   uint32_t _: 6;  jit_uint32_t b : 10; } tr;
+    struct {   uint32_t _: 6;  jit_uint32_t b : 20; } br;
+    struct {                           uint32_t b :  6; } tc;
+    struct {                           uint32_t b : 11; } cc;
+    struct {                           uint32_t b : 16; } is;
+    struct {                           uint32_t b : 26; } ii;
 #else
-    struct {                           jit_uint32_t b :  6; } hc;
-    struct {   jit_uint32_t _: 6;      jit_uint32_t b :  5; } rs;
-    struct {   jit_uint32_t _: 6;      jit_uint32_t b :  5; } fm;
-    struct {   jit_uint32_t _:11;      jit_uint32_t b :  5; } rt;
-    struct {   jit_uint32_t _:11;      jit_uint32_t b :  5; } ft;
-    struct {   jit_uint32_t _:16;      jit_uint32_t b :  5; } rd;
-    struct {   jit_uint32_t _:16;      jit_uint32_t b :  5; } fs;
-    struct {   jit_uint32_t _:21;      jit_uint32_t b :  5; } ic;
-    struct {   jit_uint32_t _:21;      jit_uint32_t b :  5; } fd;
-    struct {   jit_uint32_t _:21;      jit_uint32_t b : 10; } tr;
-    struct {   jit_uint32_t _:21;      jit_uint32_t b : 20; } br;
-    struct {   jit_uint32_t _:26;      jit_uint32_t b :  6; } tc;
-    struct {   jit_uint32_t _:21;      jit_uint32_t b : 11; } cc;
-    struct {   jit_uint32_t _:16;      jit_uint32_t b : 16; } is;
-    struct {   jit_uint32_t _: 6;      jit_uint32_t b : 26; } ii;
+    struct {                           uint32_t b :  6; } hc;
+    struct {   uint32_t _: 6;  jit_uint32_t b :  5; } rs;
+    struct {   uint32_t _: 6;  jit_uint32_t b :  5; } fm;
+    struct {   uint32_t _:11;  jit_uint32_t b :  5; } rt;
+    struct {   uint32_t _:11;  jit_uint32_t b :  5; } ft;
+    struct {   uint32_t _:16;  jit_uint32_t b :  5; } rd;
+    struct {   uint32_t _:16;  jit_uint32_t b :  5; } fs;
+    struct {   uint32_t _:21;  jit_uint32_t b :  5; } ic;
+    struct {   uint32_t _:21;  jit_uint32_t b :  5; } fd;
+    struct {   uint32_t _:21;  jit_uint32_t b : 10; } tr;
+    struct {   uint32_t _:21;  jit_uint32_t b : 20; } br;
+    struct {   uint32_t _:26;  jit_uint32_t b :  6; } tc;
+    struct {   uint32_t _:21;  jit_uint32_t b : 11; } cc;
+    struct {   uint32_t _:16;  jit_uint32_t b : 16; } is;
+    struct {   uint32_t _: 6;  jit_uint32_t b : 26; } ii;
 #endif
     int                                        op;
 } jit_instr_t;
@@ -296,18 +296,18 @@ typedef union {
 #  define MIPS_SDBPP                   0x3f
 #  define ii(i)                                *_jit->pc.ui++ = i
 static void
-_hrrrit(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
-       jit_int32_t,jit_int32_t);
+_hrrrit(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
+       int32_t,jit_int32_t);
 #  define hrrrit(hc,rs,rt,rd,im,tc)    _hrrrit(_jit,hc,rs,rt,rd,im,tc)
 #  define hrrr_t(hc,rs,rt,rd,tc)       hrrrit(hc,rs,rt,rd,0,tc)
 #  define rrr_t(rs,rt,rd,tc)           hrrr_t(0,rs,rt,rd,tc)
 #  define hrri(hc,rs,rt,im)            _hrri(_jit,hc,rs,rt,im)
-static void 
_hrri(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _hrri(jit_state_t*,int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 #  define hi(hc,im)                    _hi(_jit,hc,im)
-static void _hi(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _hi(jit_state_t*,int32_t,jit_int32_t);
 #  define NOP(i0)                      ii(0)
 #  define nop(i0)                      _nop(_jit,i0)
-static void _nop(jit_state_t*,jit_int32_t);
+static void _nop(jit_state_t*,int32_t);
 #  define h_ri(hc,rt,im)               _hrri(_jit,hc,0,rt,im)
 #  define rrit(rt,rd,im,tc)            _hrrrit(_jit,0,0,rt,rd,im,tc)
 #  define LUI(rt,im)                   h_ri(MIPS_LUI,rt,im)
@@ -402,67 +402,67 @@ static void _nop(jit_state_t*,jit_int32_t);
 #    define divu(rs,rt)                        DDIVU(rs,rt)
 #  endif
 #  define addi(r0,r1,i0)               _addi(_jit,r0,r1,i0)
-static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define addcr(r0,r1,r2)                        _addcr(_jit,r0,r1,r2)
-static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addcr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define addci(r0,r1,i0)                        _addci(_jit,r0,r1,i0)
-static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addxr(r0,r1,r2)              _addxr(_jit,r0,r1,r2)
-static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _addxr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define addxi(r0,r1,i0)              _addxi(_jit,r0,r1,i0)
-static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subi(r0,r1,i0)               _subi(_jit,r0,r1,i0)
-static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subcr(r0,r1,r2)              _subcr(_jit,r0,r1,r2)
-static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subcr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subci(r0,r1,i0)              _subci(_jit,r0,r1,i0)
-static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subxr(r0,r1,r2)              _subxr(_jit,r0,r1,r2)
-static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _subxr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define subxi(r0,r1,i0)              _subxi(_jit,r0,r1,i0)
-static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rsbi(r0, r1, i0)             _rsbi(_jit, r0, r1, i0)
-static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rsbi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define mulr(r0,r1,r2)               _mulr(_jit,r0,r1,r2)
-static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _mulr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define muli(r0,r1,i0)               _muli(_jit,r0,r1,i0)
-static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _muli(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qmulr(r0,r1,r2,r3)           iqmulr(r0,r1,r2,r3,1)
 #  define qmulr_u(r0,r1,r2,r3)         iqmulr(r0,r1,r2,r3,0)
 #  define iqmulr(r0,r1,r2,r3,cc)       _iqmulr(_jit,r0,r1,r2,r3,cc)
-static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_bool_t);
+static void _iqmulr(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_bool_t);
 #  define qmuli(r0,r1,r2,i0)           iqmuli(r0,r1,r2,i0,1)
 #  define qmuli_u(r0,r1,r2,i0)         iqmuli(r0,r1,r2,i0,0)
 #  define iqmuli(r0,r1,r2,i0,cc)       _iqmuli(_jit,r0,r1,r2,i0,cc)
-static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_word_t,jit_bool_t);
+static void _iqmuli(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_word_t,jit_bool_t);
 #  define divr(r0,r1,r2)               _divr(_jit,r0,r1,r2)
-static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define divi(r0,r1,i0)               _divi(_jit,r0,r1,i0)
-static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define divr_u(r0,r1,r2)             _divr_u(_jit,r0,r1,r2)
-static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _divr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define divi_u(r0,r1,i0)             _divi_u(_jit,r0,r1,i0)
-static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qdivr(r0,r1,r2,r3)           iqdivr(r0,r1,r2,r3,1)
 #  define qdivr_u(r0,r1,r2,r3)         iqdivr(r0,r1,r2,r3,0)
 #  define iqdivr(r0,r1,r2,r3,cc)       _iqdivr(_jit,r0,r1,r2,r3,cc)
-static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_bool_t);
+static void _iqdivr(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_bool_t);
 #  define qdivi(r0,r1,r2,i0)           iqdivi(r0,r1,r2,i0,1)
 #  define qdivi_u(r0,r1,r2,i0)         iqdivi(r0,r1,r2,i0,0)
 #  define iqdivi(r0,r1,r2,i0,cc)       _iqdivi(_jit,r0,r1,r2,i0,cc)
-static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_word_t,jit_bool_t);
+static void _iqdivi(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_word_t,jit_bool_t);
 #  define remr(r0,r1,r2)               _remr(_jit,r0,r1,r2)
-static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi(r0,r1,i0)               _remi(_jit,r0,r1,i0)
-static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define remr_u(r0,r1,r2)             _remr_u(_jit,r0,r1,r2)
-static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi_u(r0,r1,i0)             _remi_u(_jit,r0,r1,i0)
-static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 32
 #    define lshr(r0,r1,r2)             SLLV(r0,r1,r2)
 #    define lshi(r0,r1,i0)             SLL(r0,r1,i0)
@@ -473,121 +473,121 @@ static void 
_remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 #  else
 #    define lshr(r0,r1,r2)             DSLLV(r0,r1,r2)
 #    define lshi(r0,r1,i0)             _lshi(_jit,r0,r1,i0)
-static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #    define rshr(r0,r1,r2)             DSRAV(r0,r1,r2)
 #    define rshi(r0,r1,i0)             _rshi(_jit,r0,r1,i0)
-static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #    define rshr_u(r0,r1,r2)           DSRLV(r0,r1,r2)
 #    define rshi_u(r0,r1,i0)           _rshi_u(_jit,r0,r1,i0)
-static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  endif
 #  define andr(r0,r1,r2)               AND(r0,r1,r2)
 #  define andi(r0,r1,i0)               _andi(_jit,r0,r1,i0)
-static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _andi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define orr(r0,r1,r2)                        OR(r0,r1,r2)
 #  define ori(r0,r1,i0)                        _ori(_jit,r0,r1,i0)
-static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define xorr(r0,r1,r2)               XOR(r0,r1,r2)
 #  define xori(r0,r1,i0)               _xori(_jit,r0,r1,i0)
-static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _xori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define movr(r0,r1)                  orr(r0,r1,_ZERO_REGNO)
 #  define movi(r0,i0)                  _movi(_jit,r0,i0)
-static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
+static void _movi(jit_state_t*,int32_t,jit_word_t);
 #  define movi_p(r0,i0)                        _movi_p(_jit,r0,i0)
-static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
+static jit_word_t _movi_p(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_c(r0,r1)                 LB(r0,0,r1)
 #  define ldi_c(r0,i0)                 _ldi_c(_jit,r0,i0)
-static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_c(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_uc(r0,r1)                        LBU(r0,0,r1)
 #  define ldi_uc(r0,i0)                        _ldi_uc(_jit,r0,i0)
-static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_uc(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_s(r0,r1)                 LH(r0,0,r1)
 #  define ldi_s(r0,i0)                 _ldi_s(_jit,r0,i0)
-static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_s(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_us(r0,r1)                        LHU(r0,0,r1)
 #  define ldi_us(r0,i0)                        _ldi_us(_jit,r0,i0)
-static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_us(jit_state_t*,int32_t,jit_word_t);
 #  define ldr_i(r0,r1)                 LW(r0,0,r1)
 #  define ldi_i(r0,i0)                 _ldi_i(_jit,r0,i0)
-static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_i(jit_state_t*,int32_t,jit_word_t);
 #  if __WORDSIZE == 64
 #    define ldr_ui(r0,r1)              LWU(r0,0,r1)
 #    define ldi_ui(r0,i0)              _ldi_ui(_jit,r0,i0)
-static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_ui(jit_state_t*,int32_t,jit_word_t);
 #    define ldr_l(r0,r1)               LD(r0,0,r1)
 #    define ldi_l(r0,i0)               _ldi_l(_jit,r0,i0)
-static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_l(jit_state_t*,int32_t,jit_word_t);
 #  endif
 #  define ldxr_c(r0,r1,r2)             _ldxr_c(_jit,r0,r1,r2)
-static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_c(r0,r1,i0)             _ldxi_c(_jit,r0,r1,i0)
-static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_c(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_uc(r0,r1,r2)            _ldxr_uc(_jit,r0,r1,r2)
-static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_uc(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_uc(r0,r1,i0)            _ldxi_uc(_jit,r0,r1,i0)
-static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_uc(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_s(r0,r1,r2)             _ldxr_s(_jit,r0,r1,r2)
-static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_s(r0,r1,i0)             _ldxi_s(_jit,r0,r1,i0)
-static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_s(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_us(r0,r1,r2)            _ldxr_us(_jit,r0,r1,r2)
-static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_us(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_us(r0,r1,i0)            _ldxi_us(_jit,r0,r1,i0)
-static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_us(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldxr_i(r0,r1,r2)             _ldxr_i(_jit,r0,r1,r2)
-static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_i(r0,r1,i0)             _ldxi_i(_jit,r0,r1,i0)
-static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_i(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 64
 #    define ldxr_ui(r0,r1,r2)          _ldxr_ui(_jit,r0,r1,r2)
-static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_ui(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #    define ldxi_ui(r0,r1,i0)          _ldxi_ui(_jit,r0,r1,i0)
-static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_ui(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #    define ldxr_l(r0,r1,r2)           _ldxr_l(_jit,r0,r1,r2)
-static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_l(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #    define ldxi_l(r0,r1,i0)           _ldxi_l(_jit,r0,r1,i0)
-static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_l(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  endif
 #  define str_c(r0,r1)                 SB(r1,0,r0)
 #  define sti_c(i0,r0)                 _sti_c(_jit,i0,r0)
-static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_c(jit_state_t*,jit_word_t,int32_t);
 #  define str_s(r0,r1)                 SH(r1,0,r0)
 #  define sti_s(i0,r0)                 _sti_s(_jit,i0,r0)
-static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_s(jit_state_t*,jit_word_t,int32_t);
 #  define str_i(r0,r1)                 SW(r1,0,r0)
 #  define sti_i(i0,r0)                 _sti_i(_jit,i0,r0)
-static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_i(jit_state_t*,jit_word_t,int32_t);
 #  if __WORDSIZE == 64
 #    define str_l(r0,r1)               SD(r1,0,r0)
 #    define sti_l(i0,r0)               _sti_l(_jit,i0,r0)
-static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_l(jit_state_t*,jit_word_t,int32_t);
 #  endif
 #  define stxr_c(r0,r1,r2)             _stxr_c(_jit,r0,r1,r2)
-static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_c(i0,r0,r1)             _stxi_c(_jit,i0,r0,r1)
-static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_c(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_s(r0,r1,r2)             _stxr_s(_jit,r0,r1,r2)
-static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_s(i0,r0,r1)             _stxi_s(_jit,i0,r0,r1)
-static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_s(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define stxr_i(r0,r1,r2)             _stxr_i(_jit,r0,r1,r2)
-static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_i(i0,r0,r1)             _stxi_i(_jit,i0,r0,r1)
-static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_i(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  if __WORDSIZE == 64
 #    define stxr_l(r0,r1,r2)           _stxr_l(_jit,r0,r1,r2)
-static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_l(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #    define stxi_l(i0,r0,r1)           _stxi_l(_jit,i0,r0,r1)
-static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_l(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  endif
 #  if __BYTE_ORDER == __LITTLE_ENDIAN
 #    define htonr_us(r0,r1)            _htonr_us(_jit,r0,r1)
-static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_us(jit_state_t*,int32_t,jit_int32_t);
 #    define htonr_ui(r0,r1)            _htonr_ui(_jit,r0,r1)
-static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ui(jit_state_t*,int32_t,jit_int32_t);
 #    if __WORDSIZE == 64
 #      define htonr_ul(r0,r1)          _htonr_ul(_jit,r0,r1)
-static void _htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ul(jit_state_t*,int32_t,jit_int32_t);
 #    endif
 #  else
 #    define htonr_us(r0,r1)            extr_us(r0,r1)
@@ -599,138 +599,138 @@ static void 
_htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
 #    endif
 #  endif
 #  define extr_c(r0,r1)                        _extr_c(_jit,r0,r1)
-static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_c(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_uc(r0,r1)               ANDI(r0,r1,0xff)
 #  define extr_s(r0,r1)                        _extr_s(_jit,r0,r1)
-static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_s(jit_state_t*,int32_t,jit_int32_t);
 #  define extr_us(r0,r1)               ANDI(r0,r1,0xffff)
 #  if __WORDSIZE == 64
 #    define extr_i(r0,r1)              SLL(r0,r1,0)
 #    define extr_ui(r0,r1)             _extr_ui(_jit,r0,r1)
-static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_ui(jit_state_t*,int32_t,jit_int32_t);
 #  endif
 #  define ltr(r0,r1,r2)                        SLT(r0,r1,r2)
 #  define lti(r0,r1,i0)                        _lti(_jit,r0,r1,i0)
-static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lti(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ltr_u(r0,r1,r2)              SLTU(r0,r1,r2)
 #  define lti_u(r0,r1,i0)              _lti_u(_jit,r0,r1,i0)
-static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lti_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ler(r0,r1,r2)                  _ler(_jit,r0,r1,r2)
-static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lei(r0,r1,i0)                  _lei(_jit,r0,r1,i0)
-static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ler_u(r0,r1,r2)                        _ler_u(_jit,r0,r1,r2)
-static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define lei_u(r0,r1,i0)                        _lei_u(_jit,r0,r1,i0)
-static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lei_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define eqr(r0,r1,r2)                  _eqr(_jit,r0,r1,r2)
-static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _eqr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define eqi(r0,r1,i0)                  _eqi(_jit,r0,r1,i0)
-static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _eqi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ger(r0,r1,r2)                  _ger(_jit,r0,r1,r2)
-static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define gei(r0,r1,i0)                  _gei(_jit,r0,r1,i0)
-static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ger_u(r0,r1,i0)                        _ger_u(_jit,r0,r1,i0)
-static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define gei_u(r0,r1,i0)                        _gei_u(_jit,r0,r1,i0)
-static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gei_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define gtr(r0,r1,r2)                        SLT(r0,r2,r1)
 #define gti(r0,r1,i0)                  _gti(_jit,r0,r1,i0)
-static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gti(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define gtr_u(r0,r1,r2)              SLTU(r0,r2,r1)
 #  define gti_u(r0,r1,i0)              _gti_u(_jit,r0,r1,i0)
-static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gti_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define ner(r0,r1,r2)                  _ner(_jit,r0,r1,r2)
-static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #define nei(r0,r1,i0)                  _nei(_jit,r0,r1,i0)
-static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _nei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define bltr(i0,r0,r1)                 _bltr(_jit,i0,r0,r1)
-static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bltr_u(i0,r0,r1)               _bltr_u(_jit,i0,r0,r1)
-static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blti(i0,r0,i1)                 _blti(_jit,i0,r0,i1)
-static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blti(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define blti_u(i0,r0,i1)               _blti_u(_jit,i0,r0,i1)
-static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blti_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bler(i0,r0,r1)                 _bler(_jit,i0,r0,r1)
-static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bler_u(i0,r0,r1)               _bler_u(_jit,i0,r0,r1)
-static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blei(i0,r0,i1)                 _blei(_jit,i0,r0,i1)
-static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define blei_u(i0,r0,i1)               _blei_u(_jit,i0,r0,i1)
-static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blei_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define beqr(i0,r0,r1)                 _beqr(_jit,i0,r0,r1)
-static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define beqi(i0,r0,i1)                 _beqi(_jit,i0,r0,i1)
-static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _beqi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bger(i0,r0,r1)                 _bger(_jit,i0,r0,r1)
-static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bger_u(i0,r0,r1)               _bger_u(_jit,i0,r0,r1)
-static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgei(i0,r0,i1)                 _bgei(_jit,i0,r0,i1)
-static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bgei_u(i0,r0,i1)               _bgei_u(_jit,i0,r0,i1)
-static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgei_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bgtr(i0,r0,r1)                 _bgtr(_jit,i0,r0,r1)
-static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgtr_u(i0,r0,r1)               _bgtr_u(_jit,i0,r0,r1)
-static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgti(i0,r0,i1)                 _bgti(_jit,i0,r0,i1)
-static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgti(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bgti_u(i0,r0,i1)               _bgti_u(_jit,i0,r0,i1)
-static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgti_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bner(i0,r0,r1)                 _bner(_jit,i0,r0,r1)
-static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bnei(i0,r0,i1)                 _bnei(_jit,i0,r0,i1)
-static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bnei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define jmpr(r0)                     _jmpr(_jit,r0)
-static void _jmpr(jit_state_t*,jit_int32_t);
+static void _jmpr(jit_state_t*,int32_t);
 #  define jmpi(i0)                     _jmpi(_jit,i0)
 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
 #  define boaddr(i0,r0,r1)             _boaddr(_jit,i0,r0,r1)
-static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _boaddr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define boaddi(i0,r0,i1)             _boaddi(_jit,i0,r0,i1)
-static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _boaddi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define boaddr_u(i0,r0,r1)           _boaddr_u(_jit,i0,r0,r1)
-static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define boaddi_u(i0,r0,i1)           _boaddi_u(_jit,i0,r0,i1)
-static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bxaddr(i0,r0,r1)             _bxaddr(_jit,i0,r0,r1)
-static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxaddr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bxaddi(i0,r0,i1)             _bxaddi(_jit,i0,r0,i1)
-static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxaddi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bxaddr_u(i0,r0,r1)           _bxaddr_u(_jit,i0,r0,r1)
-static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bxaddi_u(i0,r0,i1)           _bxaddi_u(_jit,i0,r0,i1)
-static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bosubr(i0,r0,r1)             _bosubr(_jit,i0,r0,r1)
-static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bosubr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bosubi(i0,r0,i1)             _bosubi(_jit,i0,r0,i1)
-static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bosubi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bosubr_u(i0,r0,r1)           _bosubr_u(_jit,i0,r0,r1)
-static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bosubi_u(i0,r0,i1)           _bosubi_u(_jit,i0,r0,i1)
-static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bxsubr(i0,r0,r1)             _bxsubr(_jit,i0,r0,r1)
-static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxsubr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bxsubi(i0,r0,i1)             _bxsubi(_jit,i0,r0,i1)
-static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxsubi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bxsubr_u(i0,r0,r1)           _bxsubr_u(_jit,i0,r0,r1)
-static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bxsubi_u(i0,r0,i1)           _bxsubi_u(_jit,i0,r0,i1)
-static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bmsr(i0,r0,r1)               _bmsr(_jit,i0,r0,r1)
-static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bmsr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bmsi(i0,r0,i1)               _bmsi(_jit,i0,r0,i1)
-static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bmsi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define bmcr(i0,r0,r1)               _bmcr(_jit,i0,r0,r1)
-static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bmcr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bmci(i0,r0,i1)               _bmci(_jit,i0,r0,i1)
-static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bmci(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define callr(r0)                    _callr(_jit,r0)
-static void _callr(jit_state_t*,jit_int32_t);
+static void _callr(jit_state_t*,int32_t);
 #  define calli(i0)                    _calli(_jit,i0)
 static void _calli(jit_state_t*,jit_word_t);
 #  define calli_p(i0)                  _calli_p(_jit,i0)
@@ -740,9 +740,9 @@ static void _prolog(jit_state_t*,jit_node_t*);
 #  define epilog(node)                 _epilog(_jit,node)
 static void _epilog(jit_state_t*,jit_node_t*);
 #  define vastart(r0)                  _vastart(_jit, r0)
-static void _vastart(jit_state_t*, jit_int32_t);
+static void _vastart(jit_state_t*, int32_t);
 #  define vaarg(r0, r1)                        _vaarg(_jit, r0, r1)
-static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg(jit_state_t*, int32_t, jit_int32_t);
 #define patch_abs(instr,label)         _patch_abs(_jit,instr,label)
 static void _patch_abs(jit_state_t*,jit_word_t,jit_word_t);
 #define patch_at(jump,label)           _patch_at(_jit,jump,label)
@@ -751,9 +751,9 @@ static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 
 #if CODE
 static void
-_hrrrit(jit_state_t *_jit,jit_int32_t hc,
-       jit_int32_t rs, jit_int32_t rt, jit_int32_t rd,
-       jit_int32_t ic, jit_int32_t tc)
+_hrrrit(jit_state_t *_jit,int32_t hc,
+       int32_t rs, jit_int32_t rt, jit_int32_t rd,
+       int32_t ic, jit_int32_t tc)
 {
     jit_instr_t                i;
     i.tc.b = tc;
@@ -766,8 +766,8 @@ _hrrrit(jit_state_t *_jit,jit_int32_t hc,
 }
 
 static void
-_hrri(jit_state_t *_jit, jit_int32_t hc,
-      jit_int32_t rs, jit_int32_t rt, jit_int32_t im)
+_hrri(jit_state_t *_jit, int32_t hc,
+      int32_t rs, jit_int32_t rt, jit_int32_t im)
 {
     jit_instr_t                i;
     i.op = 0;
@@ -779,7 +779,7 @@ _hrri(jit_state_t *_jit, jit_int32_t hc,
 }
 
 static void
-_hi(jit_state_t *_jit, jit_int32_t hc, jit_int32_t im)
+_hi(jit_state_t *_jit, int32_t hc, jit_int32_t im)
 {
     jit_instr_t                i;
     i.ii.b = im;
@@ -788,7 +788,7 @@ _hi(jit_state_t *_jit, jit_int32_t hc, jit_int32_t im)
 }
 
 static void
-_nop(jit_state_t *_jit, jit_int32_t i0)
+_nop(jit_state_t *_jit, int32_t i0)
 {
     for (; i0 > 0; i0 -= 4)
        NOP();
@@ -796,9 +796,9 @@ _nop(jit_state_t *_jit, jit_int32_t i0)
 }
 
 static void
-_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        movr(r0, r1);
     else if (can_sign_extend_short_p(i0))
@@ -812,9 +812,9 @@ _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addcr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
 
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
@@ -832,9 +832,9 @@ _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
 
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
@@ -862,9 +862,9 @@ _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_addxr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
 
     assert(jit_carry != _NOREG);
     t0 = jit_get_reg(jit_class_gpr);
@@ -875,9 +875,9 @@ _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
 
     assert(jit_carry != _NOREG);
     t0 = jit_get_reg(jit_class_gpr);
@@ -888,9 +888,9 @@ _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        movr(r0, r1);
     else if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
@@ -904,9 +904,9 @@ _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subcr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
 
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
@@ -924,9 +924,9 @@ _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
 
     if (jit_carry == _NOREG)
        jit_carry = jit_get_reg(jit_class_gpr);
@@ -954,9 +954,9 @@ _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_subxr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
 
     assert(jit_carry != _NOREG);
     t0 = jit_get_reg(jit_class_gpr);
@@ -967,9 +967,9 @@ _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
 
     assert(jit_carry != _NOREG);
     t0 = jit_get_reg(jit_class_gpr);
@@ -980,23 +980,23 @@ _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rsbi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     subi(r0, r1, i0);
     negr(r0, r0);
 }
 
 static void
-_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_mulr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     multu(r1, r2);
     MFLO(r0);
 }
 
 static void
-_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_muli(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
@@ -1005,8 +1005,8 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
+_iqmulr(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_int32_t r3, jit_bool_t sign)
 {
     if (sign)
        mult(r2, r3);
@@ -1017,10 +1017,10 @@ _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
+_iqmuli(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     iqmulr(r0, r1, r2, rn(reg), sign);
@@ -1028,16 +1028,16 @@ _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     div(r1, r2);
     MFLO(r0);
 }
 
 static void
-_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     divr(r0, r1, rn(reg));
@@ -1045,16 +1045,16 @@ _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_divr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     divu(r1, r2);
     MFLO(r0);
 }
 
 static void
-_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     divr_u(r0, r1, rn(reg));
@@ -1062,8 +1062,8 @@ _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
+_iqdivr(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_int32_t r3, jit_bool_t sign)
 {
     if (sign)
        div(r2, r3);
@@ -1074,10 +1074,10 @@ _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
+_iqdivi(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     iqdivr(r0, r1, r2, rn(reg), sign);
@@ -1085,16 +1085,16 @@ _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     div(r1, r2);
     MFHI(r0);
 }
 
 static void
-_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     remr(r0, r1, rn(reg));
@@ -1102,16 +1102,16 @@ _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     divu(r1, r2);
     MFHI(r0);
 }
 
 static void
-_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     remr_u(r0, r1, rn(reg));
@@ -1120,7 +1120,7 @@ _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 
 #if __WORDSIZE == 64
 static void
-_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 <= 63);
     if (i0 < 32)
@@ -1130,7 +1130,7 @@ _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 <= 63);
     if (i0 < 32)
@@ -1140,7 +1140,7 @@ _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     assert(i0 >= 0 && i0 <= 63);
     if (i0 < 32)
@@ -1151,9 +1151,9 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 #endif
 
 static void
-_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_andi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        ANDI(r0, r1, i0);
     else {
@@ -1165,9 +1165,9 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        ORI(r0, r1, i0);
     else {
@@ -1179,9 +1179,9 @@ _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_xori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        XORI(r0, r1, i0);
     else {
@@ -1193,7 +1193,7 @@ _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     if (i0 == 0)
        OR(r0, _ZERO_REGNO, _ZERO_REGNO);
@@ -1228,7 +1228,7 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static jit_word_t
-_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi_p(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         w;
 
@@ -1249,9 +1249,9 @@ _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LB(r0, i0, _ZERO_REGNO);
     else {
@@ -1263,9 +1263,9 @@ _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LBU(r0, i0, _ZERO_REGNO);
     else {
@@ -1277,9 +1277,9 @@ _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LH(r0, i0, _ZERO_REGNO);
     else {
@@ -1291,9 +1291,9 @@ _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LHU(r0, i0, _ZERO_REGNO);
     else {
@@ -1305,9 +1305,9 @@ _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LW(r0, i0, _ZERO_REGNO);
     else {
@@ -1320,9 +1320,9 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 
 #if __WORDSIZE == 64
 static void
-_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LWU(r0, i0, _ZERO_REGNO);
     else {
@@ -1334,9 +1334,9 @@ _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LD(r0, i0, _ZERO_REGNO);
     else {
@@ -1349,9 +1349,9 @@ _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 #endif
 
 static void
-_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_ldxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_c(r0, rn(reg));
@@ -1359,9 +1359,9 @@ _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LB(r0, i0, r1);
     else {
@@ -1373,9 +1373,9 @@ _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_ldxr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_uc(r0, rn(reg));
@@ -1383,9 +1383,9 @@ _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1 ,jit_int32_t r2)
 }
 
 static void
-_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LBU(r0, i0, r1);
     else {
@@ -1397,9 +1397,9 @@ _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_ldxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_s(r0, rn(reg));
@@ -1407,9 +1407,9 @@ _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LH(r0, i0, r1);
     else {
@@ -1421,9 +1421,9 @@ _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_ldxr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_us(r0, rn(reg));
@@ -1431,9 +1431,9 @@ _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1 ,jit_int32_t r2)
 }
 
 static void
-_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LHU(r0, i0, r1);
     else {
@@ -1445,9 +1445,9 @@ _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_ldxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_i(r0, rn(reg));
@@ -1455,9 +1455,9 @@ _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LW(r0, i0, r1);
     else {
@@ -1470,9 +1470,9 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 
 #if __WORDSIZE == 64
 static void
-_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_ldxr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_ui(r0, rn(reg));
@@ -1480,9 +1480,9 @@ _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1 ,jit_int32_t r2)
 }
 
 static void
-_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LWU(r0, i0, r1);
     else {
@@ -1494,9 +1494,9 @@ _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_ldxr_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_l(r0, rn(reg));
@@ -1504,9 +1504,9 @@ _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LD(r0, i0, r1);
     else {
@@ -1519,9 +1519,9 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 #endif
 
 static void
-_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SB(r0, i0, _ZERO_REGNO);
     else {
@@ -1533,9 +1533,9 @@ _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SH(r0, i0, _ZERO_REGNO);
     else {
@@ -1547,9 +1547,9 @@ _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SW(r0, i0, _ZERO_REGNO);
     else {
@@ -1562,9 +1562,9 @@ _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 
 #if __WORDSIZE == 64
 static void
-_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SD(r0, i0, _ZERO_REGNO);
     else {
@@ -1577,9 +1577,9 @@ _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 #endif
 
 static void
-_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_c(rn(reg), r2);
@@ -1587,9 +1587,9 @@ _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SB(r1, i0, r0);
     else {
@@ -1601,9 +1601,9 @@ _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_stxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_s(rn(reg), r2);
@@ -1611,9 +1611,9 @@ _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SH(r1, i0, r0);
     else {
@@ -1625,9 +1625,9 @@ _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_stxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_i(rn(reg), r2);
@@ -1635,9 +1635,9 @@ _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SW(r1, i0, r0);
     else {
@@ -1650,9 +1650,9 @@ _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 
 #if __WORDSIZE == 64
 static void
-_stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
+_stxr_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_l(rn(reg), r2);
@@ -1660,9 +1660,9 @@ _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 
,jit_int32_t r2)
 }
 
 static void
-_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SD(r1, i0, r0);
     else {
@@ -1676,9 +1676,9 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 
 #  if __BYTE_ORDER == __LITTLE_ENDIAN
 static void
-_htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr);
     rshi(rn(t0), r1, 8);
     andi(r0, r1, 0xff);
@@ -1689,11 +1689,11 @@ _htonr_us(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
     t0 = jit_get_reg(jit_class_gpr);
     t1 = jit_get_reg(jit_class_gpr);
     t2 = jit_get_reg(jit_class_gpr);
@@ -1716,9 +1716,9 @@ _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ul(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     rshi_u(rn(reg), r1, 32);
     htonr_ui(r0, r1);
@@ -1730,7 +1730,7 @@ _htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 #  endif
 
 static void
-_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_mips2_p())
        SEB(r0, r1);
@@ -1741,7 +1741,7 @@ _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (jit_mips2_p())
        SEH(r0, r1);
@@ -1753,7 +1753,7 @@ _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 
 #  if __WORDSIZE == 64
 static void
-_extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     lshi(r0, r1, 32);
     rshi_u(r0, r0, 32);
@@ -1761,9 +1761,9 @@ _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 #  endif
 
 static void
-_lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lti(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (can_sign_extend_short_p(i0))
        SLTI(r0, r1, i0);
@@ -1776,9 +1776,9 @@ _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lti_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (can_sign_extend_short_p(i0))
        SLTIU(r0, r1, i0);
@@ -1791,16 +1791,16 @@ _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     SLT(r0, r2, r1);
     XORI(r0, r0, 1);
 }
 
 static void
-_lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i0 == 0) {
        SLT(r0, _ZERO_REGNO, r1);
@@ -1815,16 +1815,16 @@ _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     SLTU(r0, r2, r1);
     XORI(r0, r0, 1);
 }
 
 static void
-_lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lei_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i0 == 0) {
        SLTU(r0, _ZERO_REGNO, r1);
@@ -1839,7 +1839,7 @@ _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_eqr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     subr(r0, r1, r2);
     SLTU(r0, _ZERO_REGNO, r0);
@@ -1847,7 +1847,7 @@ _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_eqi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (i0) {
        subi(r0, r1, i0);
@@ -1859,16 +1859,16 @@ _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     SLT(r0, r1, r2);
     XORI(r0, r0, 1);
 }
 
 static void
-_gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
@@ -1877,16 +1877,16 @@ _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     SLTU(r0, r1, r2);
     XORI(r0, r0, 1);
 }
 
 static void
-_gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gei_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
@@ -1895,9 +1895,9 @@ _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gti(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i0 == 0)
        SLT(r0, _ZERO_REGNO, r1);
@@ -1910,9 +1910,9 @@ _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gti_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i0 == 0)
        SLTU(r0, _ZERO_REGNO, r1);
@@ -1925,14 +1925,14 @@ _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     subr(r0, r1, r2);
     SLTU(r0, _ZERO_REGNO, r0);
 }
 
 static void
-_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_nei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (i0) {
        subi(r0, r1, i0);
@@ -1943,10 +1943,10 @@ _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static jit_word_t
-_bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr);
     SLT(rn(reg), r0, r1);
@@ -1959,10 +1959,10 @@ _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     SLTU(rn(reg), r0, r1);
@@ -1975,11 +1975,11 @@ _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blti(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_bool_t         zero_p;
 
     if (!(zero_p = i1 == 0))
@@ -2006,10 +2006,10 @@ _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blti_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     if (can_sign_extend_short_p(i1)) {
@@ -2028,10 +2028,10 @@ _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     SLT(rn(reg), r1, r0);
@@ -2044,10 +2044,10 @@ _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     SLTU(rn(reg), r1, r0);
@@ -2060,10 +2060,10 @@ _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i1 == 0) {
        w = _jit->pc.w;
@@ -2081,10 +2081,10 @@ _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blei_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i1 == 0) {
        w = _jit->pc.w;
@@ -2102,7 +2102,7 @@ _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_beqr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
 
@@ -2114,10 +2114,10 @@ _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_beqi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i1 == 0) {
        w = _jit->pc.w;
@@ -2135,10 +2135,10 @@ _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     SLT(rn(reg), r0, r1);
@@ -2151,10 +2151,10 @@ _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     SLTU(rn(reg), r0, r1);
@@ -2167,11 +2167,11 @@ _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
     jit_word_t         d;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_bool_t         zero_p;
 
     if (!(zero_p = i1 == 0))
@@ -2198,10 +2198,10 @@ _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgei_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     if (can_sign_extend_short_p(i1)) {
@@ -2220,10 +2220,10 @@ _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     SLT(rn(reg), r1, r0);
@@ -2236,10 +2236,10 @@ _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     SLTU(rn(reg), r1, r0);
@@ -2252,10 +2252,10 @@ _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgti(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i1 == 0) {
        w = _jit->pc.w;
@@ -2273,10 +2273,10 @@ _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgti_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i1 == 0) {
        w = _jit->pc.w;
@@ -2294,7 +2294,7 @@ _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bner(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
 
@@ -2306,10 +2306,10 @@ _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bnei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     if (i1 == 0) {
        w = _jit->pc.w;
@@ -2327,7 +2327,7 @@ _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static void
-_jmpr(jit_state_t *_jit, jit_int32_t r0)
+_jmpr(jit_state_t *_jit, int32_t r0)
 {
     JR(r0);
     NOP(1);
@@ -2337,10 +2337,10 @@ static jit_word_t
 _jmpi(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     w = _jit->pc.w;
-    if (((w + sizeof(jit_int32_t)) & 0xf0000000) == (i0 & 0xf0000000)) {
+    if (((w + sizeof(int32_t)) & 0xf0000000) == (i0 & 0xf0000000)) {
        J((i0 & ~0xf0000000) >> 2);
        NOP(1);
     }
@@ -2355,12 +2355,12 @@ _jmpi(jit_state_t *_jit, jit_word_t i0)
 }
 
 static jit_word_t
-_boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_boaddr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
 
     /* t1 = r0 + r1;   overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2383,12 +2383,12 @@ _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_boaddi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
 
     if (can_sign_extend_short_p(i1)) {
        t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2417,11 +2417,11 @@ _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_boaddr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
 
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2437,11 +2437,11 @@ _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_boaddi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
 
     if (can_sign_extend_short_p(i0)) {
        t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2465,12 +2465,12 @@ _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxaddr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
 
     /* t1 = r0 + r1;   overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2493,12 +2493,12 @@ _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxaddi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
 
     if (can_sign_extend_short_p(i1)) {
        t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2527,11 +2527,11 @@ _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxaddr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
 
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2547,11 +2547,11 @@ _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxaddi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
 
     if (can_sign_extend_short_p(i0)) {
        t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2575,12 +2575,12 @@ _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bosubr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
 
     /* t1 = r0 - r1;   overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2603,12 +2603,12 @@ _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bosubi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
 
     if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
        t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2637,11 +2637,11 @@ _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bosubr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
 
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2657,11 +2657,11 @@ _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bosubi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
 
     if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
        t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2685,12 +2685,12 @@ _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxsubr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
 
     /* t1 = r0 - r1;   overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2713,12 +2713,12 @@ _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxsubi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
-    jit_int32_t                t2;
+    int32_t            t0;
+    int32_t            t1;
+    int32_t            t2;
 
     if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
        t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2747,11 +2747,11 @@ _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxsubr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
 
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2767,11 +2767,11 @@ _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxsubi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
-    jit_int32_t                t1;
+    int32_t            t0;
+    int32_t            t1;
 
     if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
        t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
@@ -2795,10 +2795,10 @@ _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bmsr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     AND(rn(t0), r0, r1);
     w = _jit->pc.w;
@@ -2809,10 +2809,10 @@ _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bmsi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     if (can_zero_extend_short_p(i1)) {
        ANDI(rn(t0), r0, i1);
@@ -2829,10 +2829,10 @@ _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bmcr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     AND(rn(t0), r0, r1);
     w = _jit->pc.w;
@@ -2843,10 +2843,10 @@ _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bmci(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
     if (can_zero_extend_short_p(i1)) {
        ANDI(rn(t0), r0, i1);
@@ -2863,7 +2863,7 @@ _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static void
-_callr(jit_state_t *_jit, jit_int32_t r0)
+_callr(jit_state_t *_jit, int32_t r0)
 {
     if (r0 != _T9_REGNO)
        movr(_T9_REGNO, r0);
@@ -2892,24 +2892,24 @@ _calli_p(jit_state_t *_jit, jit_word_t i0)
     return (word);
 }
 
-static jit_int32_t fregs[] = {
+static int32_t fregs[] = {
     _F30, _F28, _F26, _F24, _F22, _F20,
 #if !NEW_ABI
     _F18, _F16,
 #endif
 };
 
-static jit_int32_t iregs[] = {
+static int32_t iregs[] = {
     _S7, _S6, _S5, _S4, _S3, _S2, _S1, _S0,
 };
 
 static void
 _prolog(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                index;
-    jit_int32_t                offset;
+    int32_t            index;
+    int32_t            offset;
     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
-       jit_int32_t     frame = -_jitc->function->frame;
+       int32_t frame = -_jitc->function->frame;
        assert(_jitc->function->self.aoff >= frame);
        if (_jitc->function->assume_frame)
            return;
@@ -2981,8 +2981,8 @@ _prolog(jit_state_t *_jit, jit_node_t *node)
 static void
 _epilog(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                index;
-    jit_int32_t                offset;
+    int32_t            index;
+    int32_t            offset;
     if (_jitc->function->assume_frame)
        return;
     /* callee save registers */
@@ -3012,21 +3012,21 @@ _epilog(jit_state_t *_jit, jit_node_t *node)
 }
 
 static void
-_vastart(jit_state_t *_jit, jit_int32_t r0)
+_vastart(jit_state_t *_jit, int32_t r0)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
     /* Initialize va_list to the first stack argument. */
 #if NEW_ABI
     if (jit_arg_reg_p(_jitc->function->vagp))
        addi(r0, _BP_REGNO, stack_framesize + _jitc->function->vagp *
-            sizeof(jit_int64_t));
+            sizeof(int64_t));
     else
 #endif
        addi(r0, _BP_REGNO, _jitc->function->self.size);
 }
 
 static void
-_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     /* Load argument. */
 #if WORD_ADJUST
@@ -3044,7 +3044,7 @@ _patch_abs(jit_state_t *_jit, jit_word_t instr, 
jit_word_t label)
 {
     jit_instr_t                i;
     union {
-       jit_int32_t     *i;
+       int32_t *i;
        jit_word_t       w;
     } u;
 
@@ -3085,7 +3085,7 @@ _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t 
label)
 {
     jit_instr_t                i;
     union {
-       jit_int32_t     *i;
+       int32_t *i;
        jit_word_t       w;
     } u;
 
@@ -3139,7 +3139,7 @@ _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t 
label)
 
        case MIPS_J:                    case MIPS_JAL:
        case MIPS_JALX:
-           assert(((instr + sizeof(jit_int32_t)) & 0xf0000000) ==
+           assert(((instr + sizeof(int32_t)) & 0xf0000000) ==
                   (label & 0xf0000000));
            i.ii.b = (label & ~0xf0000000) >> 2;
            u.i[0] = i.op;
diff --git a/jit/mips-fpu.c b/jit/mips-fpu.c
index 35fdf8e..95a24b9 100644
--- a/jit/mips-fpu.c
+++ b/jit/mips-fpu.c
@@ -181,38 +181,38 @@
 #  define C_UGT_PS(fs,ft)              
c_cond_fmt(MIPS_fmt_PS,ft,fs,MIPS_cond_UGT)
 #  define c_cond_fmt(fm,ft,fs,cc)      _c_cond_fmt(_jit,fm,ft,fs,cc)
 static void
-_c_cond_fmt(jit_state_t *_jit, jit_int32_t fm,
-           jit_int32_t ft, jit_int32_t fs, jit_int32_t cc);
+_c_cond_fmt(jit_state_t *_jit, int32_t fm,
+           int32_t ft, jit_int32_t fs, jit_int32_t cc);
 #  define addr_f(r0,r1,r2)             ADD_S(r0,r1,r2)
 #  define addi_f(r0,r1,i0)             _addi_f(_jit,r0,r1,i0)
-static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _addi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define addr_d(r0,r1,r2)             ADD_D(r0,r1,r2)
 #  define addi_d(r0,r1,i0)             _addi_d(_jit,r0,r1,i0)
-static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _addi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define subr_f(r0,r1,r2)             SUB_S(r0,r1,r2)
 #  define subi_f(r0,r1,i0)             _subi_f(_jit,r0,r1,i0)
-static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _subi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define subr_d(r0,r1,r2)             SUB_D(r0,r1,r2)
 #  define subi_d(r0,r1,i0)             _subi_d(_jit,r0,r1,i0)
-static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _subi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define rsbr_f(r0,r1,r2)             subr_f(r0,r2,r1)
 #  define rsbi_f(r0,r1,i0)             _rsbi_f(_jit,r0,r1,i0)
-static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _rsbi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define rsbr_d(r0,r1,r2)             subr_d(r0,r2,r1)
 #  define rsbi_d(r0,r1,i0)             _rsbi_d(_jit,r0,r1,i0)
-static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _rsbi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define mulr_f(r0,r1,r2)             MUL_S(r0,r1,r2)
 #  define muli_f(r0,r1,i0)             _muli_f(_jit,r0,r1,i0)
-static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _muli_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define mulr_d(r0,r1,r2)             MUL_D(r0,r1,r2)
 #  define muli_d(r0,r1,i0)             _muli_d(_jit,r0,r1,i0)
-static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _muli_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define divr_f(r0,r1,r2)             DIV_S(r0,r1,r2)
 #  define divi_f(r0,r1,i0)             _divi_f(_jit,r0,r1,i0)
-static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _divi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define divr_d(r0,r1,r2)             DIV_D(r0,r1,r2)
 #  define divi_d(r0,r1,i0)             _divi_d(_jit,r0,r1,i0)
-static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _divi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define absr_f(r0,r1)                        ABS_S(r0,r1)
 #  define absr_d(r0,r1)                        ABS_D(r0,r1)
 #  define negr_f(r0,r1)                        NEG_S(r0,r1)
@@ -222,342 +222,342 @@ static void 
_divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
 #  define movr_w_f(r0, r1)             MTC1(r1, r0)
 #  define movr_f_w(r0, r1)             MFC1(r1, r0)
 #  define movi_f_w(r0, i0)             _movi_f_w(_jit, r0, i0)
-static void _movi_f_w(jit_state_t*,jit_int32_t,jit_float32_t*);
+static void _movi_f_w(jit_state_t*,int32_t,jit_float32_t*);
 #  define extr_f(r0, r1)               _extr_f(_jit, r0, r1)
-static void _extr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define truncr_f_i(r0, r1)           _truncr_f_i(_jit, r0, r1)
-static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_f_i(jit_state_t*,int32_t,jit_int32_t);
 #  if __WORDSIZE == 64
 #    define truncr_f_l(r0, r1)         _truncr_f_l(_jit, r0, r1)
-static void _truncr_f_l(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_f_l(jit_state_t*,int32_t,jit_int32_t);
 #  endif
 #  define extr_d_f(r0, r1)             CVT_S_D(r0, r1)
 #  define ldr_f(r0, r1)                        LWC1(r0, 0, r1)
 #  define ldi_f(r0, i0)                        _ldi_f(_jit, r0, i0)
-static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_f(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_f(r0, r1, r2)           _ldxr_f(_jit, r0, r1, r2)
-static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_f(r0, r1, i0)           _ldxi_f(_jit, r0, r1, i0)
-static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_f(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_f(r0, r1)                        SWC1(r1, 0, r0)
 #  define sti_f(i0, r0)                        _sti_f(_jit, i0, r0)
-static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_f(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_f(r0, r1, r2)           _stxr_f(_jit, r0, r1, r2)
-static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_f(i0, r0, r1)           _stxi_f(_jit, i0, r0, r1)
-static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define movr_f(r0, r1)               _movr_f(_jit, r0, r1)
-static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_f(jit_state_t*,int32_t,jit_int32_t);
 #  define movi_f(r0, i0)               _movi_f(_jit, r0, i0)
-static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
+static void _movi_f(jit_state_t*,int32_t,jit_float32_t*);
 #  if NEW_ABI
 #    if __WORDSIZE == 32
 #      define movi64(r0, i0)           _movi64(_jit, r0, i0)
-static void _movi64(jit_state_t*,jit_int32_t,jit_int64_t);
+static void _movi64(jit_state_t*,int32_t,int64_t);
 #    else
 #      define movi64(r0, i0)           movi(r0, i0)
 #    endif
 #    define movr_w_d(r0, r1)           DMTC1(r1, r0)
 #    define movr_d_w(r0, r1)           DMFC1(r0, r1)
 #    define movi_d_w(r0, i0)           _movi_d_w(_jit,r0,i0)
-static void _movi_d_w(jit_state_t*,jit_int32_t,jit_float64_t*);
+static void _movi_d_w(jit_state_t*,int32_t,jit_float64_t*);
 #  else
 #    define movr_ww_d(r0, r1, r2)      _movr_ww_d(_jit, r0, r1, r2)
-static void _movr_ww_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _movr_ww_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #    define movr_d_ww(r0, r1, r2)      _movr_d_ww(_jit, r0, r1, r2)
-static void _movr_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _movr_d_ww(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #    define movi_d_ww(r0, r1, i0)      _movi_d_ww(_jit, r0, r1, i0)
-static void _movi_d_ww(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _movi_d_ww(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  endif
 #  define extr_d(r0, r1)               _extr_d(_jit, r0, r1)
-static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define truncr_d_i(r0, r1)           _truncr_d_i(_jit, r0, r1)
-static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_d_i(jit_state_t*,int32_t,jit_int32_t);
 #  if __WORDSIZE == 64
 #    define truncr_d_l(r0, r1)         _truncr_d_l(_jit, r0, r1)
-static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_d_l(jit_state_t*,int32_t,jit_int32_t);
 #  endif
 #  define ldr_d(r0, r1)                        _ldr_d(_jit, r0, r1)
-static void _ldr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_d(r0, i0)                        _ldi_d(_jit, r0, i0)
-static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_d(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_d(r0, r1, r2)           _ldxr_d(_jit, r0, r1, r2)
-static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_d(r0, r1, i0)           _ldxi_d(_jit, r0, r1, i0)
-static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_d(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_d(r0, r1)                        _str_d(_jit, r0, r1)
-static void _str_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _str_d(jit_state_t*,int32_t,jit_int32_t);
 #  define sti_d(i0, r0)                        _sti_d(_jit, i0, r0)
-static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_d(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_d(r0, r1, r2)           _stxr_d(_jit, r0, r1, r2)
-static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_d(i0, r0, r1)           _stxi_d(_jit, i0, r0, r1)
-static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define movr_d(r0, r1)               _movr_d(_jit, r0, r1)
-static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define movi_d(r0, i0)               _movi_d(_jit, r0, i0)
-static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
+static void _movi_d(jit_state_t*,int32_t,jit_float64_t*);
 #  define ltr_f(r0, r1, r2)            _ltr_f(_jit, r0, r1, r2)
-static void _ltr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lti_f(r0, r1, i2)            _lti_f(_jit, r0, r1, i2)
-static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _lti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ler_f(r0, r1, r2)            _ler_f(_jit, r0, r1, r2)
-static void _ler_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lei_f(r0, r1, i2)            _lei_f(_jit, r0, r1, i2)
-static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _lei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define eqr_f(r0, r1, r2)            _eqr_f(_jit, r0, r1, r2)
-static void _eqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _eqr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define eqi_f(r0, r1, i2)            _eqi_f(_jit, r0, r1, i2)
-static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _eqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ger_f(r0, r1, r2)            _ger_f(_jit, r0, r1, r2)
-static void _ger_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gei_f(r0, r1, i2)            _gei_f(_jit, r0, r1, i2)
-static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _gei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define gtr_f(r0, r1, r2)            _gtr_f(_jit, r0, r1, r2)
-static void _gtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gti_f(r0, r1, i2)            _gti_f(_jit, r0, r1, i2)
-static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _gti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ner_f(r0, r1, r2)            _ner_f(_jit, r0, r1, r2)
-static void _ner_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define nei_f(r0, r1, i2)            _nei_f(_jit, r0, r1, i2)
-static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _nei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unltr_f(r0, r1, r2)          _unltr_f(_jit, r0, r1, r2)
-static void _unltr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unltr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unlti_f(r0, r1, i2)          _unlti_f(_jit, r0, r1, i2)
-static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unlti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unler_f(r0, r1, r2)          _unler_f(_jit, r0, r1, r2)
-static void _unler_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unler_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unlei_f(r0, r1, i2)          _unlei_f(_jit, r0, r1, i2)
-static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unlei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define uneqr_f(r0, r1, r2)          _uneqr_f(_jit, r0, r1, r2)
-static void _uneqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _uneqr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define uneqi_f(r0, r1, i2)          _uneqi_f(_jit, r0, r1, i2)
-static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _uneqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unger_f(r0, r1, r2)          _unger_f(_jit, r0, r1, r2)
-static void _unger_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unger_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ungei_f(r0, r1, i2)          _ungei_f(_jit, r0, r1, i2)
-static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ungei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ungtr_f(r0, r1, r2)          _ungtr_f(_jit, r0, r1, r2)
-static void _ungtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ungtr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ungti_f(r0, r1, i2)          _ungti_f(_jit, r0, r1, i2)
-static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ungti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ltgtr_f(r0, r1, r2)          _ltgtr_f(_jit, r0, r1, r2)
-static void _ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltgtr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ltgti_f(r0, r1, i2)          _ltgti_f(_jit, r0, r1, i2)
-static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ltgti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ordr_f(r0, r1, r2)           _ordr_f(_jit, r0, r1, r2)
-static void _ordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ordr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ordi_f(r0, r1, i2)           _ordi_f(_jit, r0, r1, i2)
-static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unordr_f(r0, r1, r2)         _unordr_f(_jit, r0, r1, r2)
-static void _unordr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unordr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unordi_f(r0, r1, i2)         _unordi_f(_jit, r0, r1, i2)
-static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define bltr_f(i0, r0, r1)           _bltr_f(_jit, i0, r0, r1)
-static jit_word_t _bltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blti_f(i0, r0, i1)           _blti_f(_jit, i0, r0, i1)
 static jit_word_t
-_blti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_blti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bler_f(i0, r0, r1)           _bler_f(_jit, i0, r0, r1)
-static jit_word_t _bler_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blei_f(i0, r0, i1)           _blei_f(_jit, i0, r0, i1)
 static jit_word_t
-_blei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_blei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define beqr_f(i0, r0, r1)           _beqr_f(_jit, i0, r0, r1)
-static jit_word_t _beqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define beqi_f(i0, r0, i1)           _beqi_f(_jit, i0, r0, i1)
 static jit_word_t
-_beqi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_beqi_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bger_f(i0, r0, r1)           _bger_f(_jit, i0, r0, r1)
-static jit_word_t _bger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgei_f(i0, r0, i1)           _bgei_f(_jit, i0, r0, i1)
 static jit_word_t
-_bgei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bgei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bgtr_f(i0, r0, r1)           _bgtr_f(_jit, i0, r0, r1)
-static jit_word_t _bgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgti_f(i0, r0, i1)           _bgti_f(_jit, i0, r0, i1)
 static jit_word_t
-_bgti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bgti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bner_f(i0, r0, r1)           _bner_f(_jit, i0, r0, r1)
-static jit_word_t _bner_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bnei_f(i0, r0, i1)           _bnei_f(_jit, i0, r0, i1)
 static jit_word_t
-_bnei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bnei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bunltr_f(i0, r0, r1)         _bunltr_f(_jit, i0, r0, r1)
-static jit_word_t _bunltr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunltr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunlti_f(i0, r0, i1)         _bunlti_f(_jit, i0, r0, i1)
 static jit_word_t
-_bunlti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bunlti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bunler_f(i0, r0, r1)         _bunler_f(_jit, i0, r0, r1)
-static jit_word_t _bunler_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunler_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunlei_f(i0, r0, i1)         _bunlei_f(_jit, i0, r0, i1)
 static jit_word_t
-_bunlei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bunlei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define buneqr_f(i0, r0, r1)         _buneqr_f(_jit, i0, r0, r1)
-static jit_word_t _buneqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _buneqr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define buneqi_f(i0, r0, i1)         _buneqi_f(_jit, i0, r0, i1)
 static jit_word_t
-_buneqi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_buneqi_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bunger_f(i0, r0, r1)         _bunger_f(_jit, i0, r0, r1)
-static jit_word_t _bunger_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunger_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bungei_f(i0, r0, i1)         _bungei_f(_jit, i0, r0, i1)
 static jit_word_t
-_bungei_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bungei_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bungtr_f(i0, r0, r1)         _bungtr_f(_jit, i0, r0, r1)
-static jit_word_t _bungtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bungtr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bungti_f(i0, r0, i1)         _bungti_f(_jit, i0, r0, i1)
 static jit_word_t
-_bungti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bungti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bltgtr_f(i0, r0, r1)         _bltgtr_f(_jit, i0, r0, r1)
-static jit_word_t _bltgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltgtr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bltgti_f(i0, r0, i1)         _bltgti_f(_jit, i0, r0, i1)
 static jit_word_t
-_bltgti_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bltgti_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bordr_f(i0, r0, r1)          _bordr_f(_jit, i0, r0, r1)
-static jit_word_t _bordr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bordr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bordi_f(i0, r0, i1)          _bordi_f(_jit, i0, r0, i1)
 static jit_word_t
-_bordi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bordi_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define bunordr_f(i0, r0, r1)                _bunordr_f(_jit, i0, r0, r1)
-static jit_word_t _bunordr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunordr_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunordi_f(i0, r0, i1)                _bunordi_f(_jit, i0, r0, i1)
 static jit_word_t
-_bunordi_f(jit_state_t*, jit_word_t, jit_int32_t, jit_float32_t*);
+_bunordi_f(jit_state_t*, jit_word_t, int32_t, jit_float32_t*);
 #  define extr_f_d(r0, r1)             CVT_D_S(r0, r1)
 #  define ltr_d(r0, r1, r2)            _ltr_d(_jit, r0, r1, r2)
-static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lti_d(r0, r1, i2)            _lti_d(_jit, r0, r1, i2)
-static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _lti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ler_d(r0, r1, r2)            _ler_d(_jit, r0, r1, r2)
-static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lei_d(r0, r1, i2)            _lei_d(_jit, r0, r1, i2)
-static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _lei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define eqr_d(r0, r1, r2)            _eqr_d(_jit, r0, r1, r2)
-static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _eqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define eqi_d(r0, r1, i2)            _eqi_d(_jit, r0, r1, i2)
-static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _eqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ger_d(r0, r1, r2)            _ger_d(_jit, r0, r1, r2)
-static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gei_d(r0, r1, i2)            _gei_d(_jit, r0, r1, i2)
-static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _gei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define gtr_d(r0, r1, r2)            _gtr_d(_jit, r0, r1, r2)
-static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gti_d(r0, r1, i2)            _gti_d(_jit, r0, r1, i2)
-static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _gti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ner_d(r0, r1, r2)            _ner_d(_jit, r0, r1, r2)
-static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define nei_d(r0, r1, i2)            _nei_d(_jit, r0, r1, i2)
-static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _nei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unltr_d(r0, r1, r2)          _unltr_d(_jit, r0, r1, r2)
-static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unltr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unlti_d(r0, r1, i2)          _unlti_d(_jit, r0, r1, i2)
-static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unlti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unler_d(r0, r1, r2)          _unler_d(_jit, r0, r1, r2)
-static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unler_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unlei_d(r0, r1, i2)          _unlei_d(_jit, r0, r1, i2)
-static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unlei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define uneqr_d(r0, r1, r2)          _uneqr_d(_jit, r0, r1, r2)
-static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _uneqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define uneqi_d(r0, r1, i2)          _uneqi_d(_jit, r0, r1, i2)
-static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _uneqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unger_d(r0, r1, r2)          _unger_d(_jit, r0, r1, r2)
-static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unger_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ungei_d(r0, r1, i2)          _ungei_d(_jit, r0, r1, i2)
-static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ungei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ungtr_d(r0, r1, r2)          _ungtr_d(_jit, r0, r1, r2)
-static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ungtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ungti_d(r0, r1, i2)          _ungti_d(_jit, r0, r1, i2)
-static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ungti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ltgtr_d(r0, r1, r2)          _ltgtr_d(_jit, r0, r1, r2)
-static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltgtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ltgti_d(r0, r1, i2)          _ltgti_d(_jit, r0, r1, i2)
-static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ltgti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ordr_d(r0, r1, r2)           _ordr_d(_jit, r0, r1, r2)
-static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ordi_d(r0, r1, i2)           _ordi_d(_jit, r0, r1, i2)
-static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unordr_d(r0, r1, r2)         _unordr_d(_jit, r0, r1, r2)
-static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unordi_d(r0, r1, i2)         _unordi_d(_jit, r0, r1, i2)
-static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define bltr_d(i0, r0, r1)           _bltr_d(_jit, i0, r0, r1)
-static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blti_d(i0, r0, i1)           _blti_d(_jit, i0, r0, i1)
 static jit_word_t
-_blti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_blti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bler_d(i0, r0, r1)           _bler_d(_jit, i0, r0, r1)
-static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blei_d(i0, r0, i1)           _blei_d(_jit, i0, r0, i1)
 static jit_word_t
-_blei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_blei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define beqr_d(i0, r0, r1)           _beqr_d(_jit, i0, r0, r1)
-static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define beqi_d(i0, r0, i1)           _beqi_d(_jit, i0, r0, i1)
 static jit_word_t
-_beqi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_beqi_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bger_d(i0, r0, r1)           _bger_d(_jit, i0, r0, r1)
-static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgei_d(i0, r0, i1)           _bgei_d(_jit, i0, r0, i1)
 static jit_word_t
-_bgei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bgei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bgtr_d(i0, r0, r1)           _bgtr_d(_jit, i0, r0, r1)
-static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgti_d(i0, r0, i1)           _bgti_d(_jit, i0, r0, i1)
 static jit_word_t
-_bgti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bgti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bner_d(i0, r0, r1)           _bner_d(_jit, i0, r0, r1)
-static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bnei_d(i0, r0, i1)           _bnei_d(_jit, i0, r0, i1)
 static jit_word_t
-_bnei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bnei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bunltr_d(i0, r0, r1)         _bunltr_d(_jit, i0, r0, r1)
-static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunlti_d(i0, r0, i1)         _bunlti_d(_jit, i0, r0, i1)
 static jit_word_t
-_bunlti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bunlti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bunler_d(i0, r0, r1)         _bunler_d(_jit, i0, r0, r1)
-static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunler_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunlei_d(i0, r0, i1)         _bunlei_d(_jit, i0, r0, i1)
 static jit_word_t
-_bunlei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bunlei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define buneqr_d(i0, r0, r1)         _buneqr_d(_jit, i0, r0, r1)
-static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define buneqi_d(i0, r0, i1)         _buneqi_d(_jit, i0, r0, i1)
 static jit_word_t
-_buneqi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_buneqi_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bunger_d(i0, r0, r1)         _bunger_d(_jit, i0, r0, r1)
-static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bungei_d(i0, r0, i1)         _bungei_d(_jit, i0, r0, i1)
 static jit_word_t
-_bungei_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bungei_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bungtr_d(i0, r0, r1)         _bungtr_d(_jit, i0, r0, r1)
-static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bungti_d(i0, r0, i1)         _bungti_d(_jit, i0, r0, i1)
 static jit_word_t
-_bungti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bungti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bltgtr_d(i0, r0, r1)         _bltgtr_d(_jit, i0, r0, r1)
-static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bltgti_d(i0, r0, i1)         _bltgti_d(_jit, i0, r0, i1)
 static jit_word_t
-_bltgti_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bltgti_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bordr_d(i0, r0, r1)          _bordr_d(_jit, i0, r0, r1)
-static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bordr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bordi_d(i0, r0, i1)          _bordi_d(_jit, i0, r0, i1)
 static jit_word_t
-_bordi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bordi_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define bunordr_d(i0, r0, r1)                _bunordr_d(_jit, i0, r0, r1)
-static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunordi_d(i0, r0, i1)                _bunordi_d(_jit, i0, r0, i1)
 static jit_word_t
-_bunordi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_float64_t*);
+_bunordi_d(jit_state_t*, jit_word_t, int32_t, jit_float64_t*);
 #  define vaarg_d(r0, r1)              _vaarg_d(_jit, r0, r1)
-static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg_d(jit_state_t*, int32_t, jit_int32_t);
 #endif
 
 #if CODE
 static void
-_c_cond_fmt(jit_state_t *_jit, jit_int32_t fm,
-           jit_int32_t ft, jit_int32_t fs, jit_int32_t cc)
+_c_cond_fmt(jit_state_t *_jit, int32_t fm,
+           int32_t ft, jit_int32_t fs, jit_int32_t cc)
 {
     jit_instr_t                i;
     i.cc.b = cc;
@@ -571,10 +571,10 @@ _c_cond_fmt(jit_state_t *_jit, jit_int32_t fm,
 #  define fpr_opi(name, type, size)                                    \
 static void                                                            \
 _##name##i_##type(jit_state_t *_jit,                                   \
-                 jit_int32_t r0, jit_int32_t r1,                       \
+                 int32_t r0, jit_int32_t r1,                   \
                  jit_float##size##_t *i0)                              \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     movi_##type(rn(reg), i0);                                          \
     name##r_##type(r0, r1, rn(reg));                                   \
     jit_unget_reg(reg);                                                        
\
@@ -582,11 +582,11 @@ _##name##i_##type(jit_state_t *_jit,                      
                \
 #  define fpr_bopi(name, type, size)                                   \
 static jit_word_t                                                      \
 _b##name##i_##type(jit_state_t *_jit,                                  \
-                 jit_word_t i0, jit_int32_t r0,                        \
+                 jit_word_t i0, int32_t r0,                    \
                  jit_float##size##_t *i1)                              \
 {                                                                      \
     jit_word_t         word;                                           \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr|                
\
+    int32_t            reg = jit_get_reg(jit_class_fpr|                \
                                          jit_class_nospill);           \
     movi_##type(rn(reg), i1);                                          \
     word = b##name##r_##type(i0, r0, rn(reg));                         \
@@ -605,10 +605,10 @@ fopi(mul)
 fopi(div)
 
 static void
-_movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
+_movi_f_w(jit_state_t *_jit, int32_t r0, jit_float32_t *i0)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
 
@@ -617,9 +617,9 @@ _movi_f_w(jit_state_t *_jit, jit_int32_t r0, jit_float32_t 
*i0)
 }
 
 static void
-_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_fpr);
 #  if __WORDSIZE == 32
     MTC1(r1, rn(t0));
@@ -632,9 +632,9 @@ _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_f_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_fpr);
     TRUNC_W_S(rn(t0), r1);
     MFC1(r0, rn(t0));
@@ -643,9 +643,9 @@ _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 
 #  if __WORDSIZE == 64
 static void
-_truncr_f_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_f_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_fpr);
     TRUNC_L_S(rn(t0), r1);
     DMFC1(r0, rn(t0));
@@ -654,9 +654,9 @@ _truncr_f_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 #  endif
 
 static void
-_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LWC1(r0, i0, _ZERO_REGNO);
     else {
@@ -668,9 +668,9 @@ _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_f(r0, rn(reg));
@@ -678,9 +678,9 @@ _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        LWC1(r0, i0, r1);
     else {
@@ -692,9 +692,9 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SWC1(r0, i0, _ZERO_REGNO);
     else {
@@ -706,9 +706,9 @@ _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_f(rn(reg), r2);
@@ -716,9 +716,9 @@ _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        SWC1(r1, i0, r0);
     else {
@@ -730,20 +730,20 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        MOV_S(r0, r1);
 }
 
 static void
-_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
+_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t *i0)
 {
     union {
-       jit_int32_t     i;
+       int32_t i;
        jit_float32_t   f;
     } data;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     data.f = *i0;
     if (data.i) {
@@ -769,7 +769,7 @@ dopi(div)
 #if NEW_ABI
 /* n32 abi requires 64 bit cpu */
 static void
-_movi64(jit_state_t *_jit, jit_int32_t r0, jit_int64_t i0)
+_movi64(jit_state_t *_jit, int32_t r0, int64_t i0)
 {
     if (i0 == 0)
        OR(r0, _ZERO_REGNO, _ZERO_REGNO);
@@ -802,11 +802,11 @@ _movi64(jit_state_t *_jit, jit_int32_t r0, jit_int64_t i0)
 }
 
 static void
-_movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
+_movi_d_w(jit_state_t *_jit, int32_t r0, jit_float64_t *i0)
 {
     jit_word_t         w;
     union {
-       jit_int64_t     l;
+       int64_t l;
        jit_float64_t   d;
     } data;
     if (_jitc->no_data) {
@@ -826,7 +826,7 @@ _movi_d_w(jit_state_t *_jit, jit_int32_t r0, jit_float64_t 
*i0)
 
 #else
 static void
-_movr_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_movr_ww_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     assert(r1 == r2 - 1);
     MTC1(r1, r0 + BE_P);
@@ -834,7 +834,7 @@ _movr_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_movr_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_movr_d_ww(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     assert(r0 == r1 - 1);
     MFC1(r0, r2 + BE_P);
@@ -842,11 +842,11 @@ _movr_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_movi_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_float64_t 
*i0)
+_movi_d_ww(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_float64_t *i0)
 {
     union {
-       jit_int32_t     i[2];
-       jit_int64_t     l;
+       int32_t i[2];
+       int64_t l;
        jit_float64_t   d;
     } data;
 
@@ -857,9 +857,9 @@ _movi_d_ww(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_float64_t *i0)
 #endif
 
 static void
-_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_fpr);
 #  if __WORDSIZE == 32
     MTC1(r1, rn(t0));
@@ -872,9 +872,9 @@ _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_d_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_fpr);
     TRUNC_W_D(rn(t0), r1);
     MFC1(r0, rn(t0));
@@ -883,9 +883,9 @@ _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 
 #  if __WORDSIZE == 64
 static void
-_truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_d_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_fpr);
     TRUNC_L_D(rn(t0), r1);
     DMFC1(r0, rn(t0));
@@ -894,7 +894,7 @@ _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 #  endif
 
 static void
-_ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
 #  if __WORDSIZE == 64 || NEW_ABI
     LDC1(r0, 0, r1);
@@ -905,9 +905,9 @@ _ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 #  if __WORDSIZE == 64 || NEW_ABI
     if (can_sign_extend_short_p(i0))
        LDC1(r0, i0, _ZERO_REGNO);
@@ -933,9 +933,9 @@ _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r1, r2);
     ldr_d(r0, rn(reg));
@@ -943,9 +943,9 @@ _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 #  if __WORDSIZE == 64 || NEW_ABI
     if (can_sign_extend_short_p(i0))
        LDC1(r0, i0, r1);
@@ -964,7 +964,7 @@ _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_str_d(jit_state_t *_jit,jit_int32_t r0, jit_int32_t r1)
+_str_d(jit_state_t *_jit,int32_t r0, jit_int32_t r1)
 {
 #  if __WORDSIZE == 64 || NEW_ABI
     SDC1(r1, 0, r0);
@@ -975,9 +975,9 @@ _str_d(jit_state_t *_jit,jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 #  if __WORDSIZE == 64 || NEW_ABI
     if (can_sign_extend_short_p(i0))
        SDC1(r0, i0, _ZERO_REGNO);
@@ -996,9 +996,9 @@ _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     addr(rn(reg), r0, r1);
     str_d(rn(reg), r2);
@@ -1006,9 +1006,9 @@ _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
 #  if __WORDSIZE == 64 || NEW_ABI
     if (can_sign_extend_short_p(i0))
        SDC1(r1, i0, r0);
@@ -1027,21 +1027,21 @@ _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        MOV_D(r0, r1);
 }
 
 static void
-_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
+_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t *i0)
 {
     union {
-       jit_int32_t     i[2];
-       jit_int64_t     l;
+       int32_t i[2];
+       int64_t l;
        jit_float64_t   d;
     } data;
-    jit_int32_t                reg;
+    int32_t            reg;
 
     data.d = *i0;
 #  if __WORDSIZE == 64 || NEW_ABI
@@ -1086,7 +1086,7 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t 
*i0)
 }
 
 static void
-_ltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLT_S(r1, r2);
@@ -1100,7 +1100,7 @@ _ltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(lt)
 
 static void
-_ler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLE_S(r1, r2);
@@ -1114,7 +1114,7 @@ _ler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(le)
 
 static void
-_eqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_eqr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_EQ_S(r1, r2);
@@ -1128,7 +1128,7 @@ _eqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(eq)
 
 static void
-_ger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULT_S(r1, r2);
@@ -1142,7 +1142,7 @@ _ger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(ge)
 
 static void
-_gtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULE_S(r1, r2);
@@ -1156,7 +1156,7 @@ _gtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(gt)
 
 static void
-_ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_EQ_S(r1, r2);
@@ -1170,7 +1170,7 @@ _ner_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 fopi(ne)
 
 static void
-_unltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unltr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULT_S(r1, r2);
@@ -1184,7 +1184,7 @@ _unltr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 fopi(unlt)
 
 static void
-_unler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unler_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULE_S(r1, r2);
@@ -1198,7 +1198,7 @@ _unler_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 fopi(unle)
 
 static void
-_uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_uneqr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UEQ_S(r1, r2);
@@ -1212,7 +1212,7 @@ _uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 fopi(uneq)
 
 static void
-_unger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unger_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLT_S(r1, r2);
@@ -1226,7 +1226,7 @@ _unger_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 fopi(unge)
 
 static void
-_ungtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ungtr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLE_S(r1, r2);
@@ -1240,7 +1240,7 @@ _ungtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 fopi(ungt)
 
 static void
-_ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltgtr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UEQ_S(r1, r2);
@@ -1254,7 +1254,7 @@ _ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 fopi(ltgt)
 
 static void
-_ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ordr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UN_S(r1, r2);
@@ -1268,7 +1268,7 @@ _ordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 fopi(ord)
 
 static void
-_unordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unordr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UN_S(r1, r2);
@@ -1282,7 +1282,7 @@ _unordr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 fopi(unord)
 
 static jit_word_t
-_bltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bltr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLT_S(r1, r2);
@@ -1294,7 +1294,7 @@ _bltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 fbopi(lt)
 
 static jit_word_t
-_bler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bler_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLE_S(r1, r2);
@@ -1306,7 +1306,7 @@ _bler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 fbopi(le)
 
 static jit_word_t
-_beqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_beqr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_EQ_S(r1, r2);
@@ -1318,7 +1318,7 @@ _beqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 fbopi(eq)
 
 static jit_word_t
-_bger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bger_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULT_S(r1, r2);
@@ -1330,7 +1330,7 @@ _bger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 fbopi(ge)
 
 static jit_word_t
-_bgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bgtr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULE_S(r1, r2);
@@ -1342,7 +1342,7 @@ _bgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 fbopi(gt)
 
 static jit_word_t
-_bner_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bner_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_EQ_S(r1, r2);
@@ -1354,7 +1354,7 @@ _bner_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 fbopi(ne)
 
 static jit_word_t
-_bunltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bunltr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULT_S(r1, r2);
@@ -1366,7 +1366,7 @@ _bunltr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 fbopi(unlt)
 
 static jit_word_t
-_bunler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bunler_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULE_S(r1, r2);
@@ -1378,7 +1378,7 @@ _bunler_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 fbopi(unle)
 
 static jit_word_t
-_buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_buneqr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UEQ_S(r1, r2);
@@ -1390,7 +1390,7 @@ _buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 fbopi(uneq)
 
 static jit_word_t
-_bunger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bunger_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLT_S(r1, r2);
@@ -1402,7 +1402,7 @@ _bunger_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 fbopi(unge)
 
 static jit_word_t
-_bungtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bungtr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLE_S(r1, r2);
@@ -1414,7 +1414,7 @@ _bungtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 fbopi(ungt)
 
 static jit_word_t
-_bltgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bltgtr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UEQ_S(r1, r2);
@@ -1426,7 +1426,7 @@ _bltgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 fbopi(ltgt)
 
 static jit_word_t
-_bordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bordr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UN_S(r1, r2);
@@ -1438,7 +1438,7 @@ _bordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 fbopi(ord)
 
 static jit_word_t
-_bunordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bunordr_f(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UN_S(r1, r2);
@@ -1450,7 +1450,7 @@ _bunordr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 fbopi(unord)
 
 static void
-_ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLT_D(r1, r2);
@@ -1464,7 +1464,7 @@ _ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(lt)
 
 static void
-_ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLE_D(r1, r2);
@@ -1478,7 +1478,7 @@ _ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(le)
 
 static void
-_eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_eqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_EQ_D(r1, r2);
@@ -1492,7 +1492,7 @@ _eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(eq)
 
 static void
-_ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULT_D(r1, r2);
@@ -1506,7 +1506,7 @@ _ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(ge)
 
 static void
-_gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULE_D(r1, r2);
@@ -1520,7 +1520,7 @@ _gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(gt)
 
 static void
-_ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_EQ_D(r1, r2);
@@ -1534,7 +1534,7 @@ _ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 dopi(ne)
 
 static void
-_unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unltr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULT_D(r1, r2);
@@ -1548,7 +1548,7 @@ _unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 dopi(unlt)
 
 static void
-_unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unler_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULE_D(r1, r2);
@@ -1562,7 +1562,7 @@ _unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 dopi(unle)
 
 static void
-_uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_uneqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UEQ_D(r1, r2);
@@ -1576,7 +1576,7 @@ _uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 dopi(uneq)
 
 static void
-_unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unger_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLT_D(r1, r2);
@@ -1590,7 +1590,7 @@ _unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 dopi(unge)
 
 static void
-_ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ungtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLE_D(r1, r2);
@@ -1604,7 +1604,7 @@ _ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 dopi(ungt)
 
 static void
-_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltgtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UEQ_D(r1, r2);
@@ -1618,7 +1618,7 @@ _ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 dopi(ltgt)
 
 static void
-_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UN_D(r1, r2);
@@ -1632,7 +1632,7 @@ _ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 dopi(ord)
 
 static void
-_unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UN_D(r1, r2);
@@ -1646,7 +1646,7 @@ _unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 dopi(unord)
 
 static jit_word_t
-_bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bltr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLT_D(r1, r2);
@@ -1658,7 +1658,7 @@ _bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 dbopi(lt)
 
 static jit_word_t
-_bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bler_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLE_D(r1, r2);
@@ -1670,7 +1670,7 @@ _bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 dbopi(le)
 
 static jit_word_t
-_beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_beqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_EQ_D(r1, r2);
@@ -1682,7 +1682,7 @@ _beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 dbopi(eq)
 
 static jit_word_t
-_bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bger_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULT_D(r1, r2);
@@ -1694,7 +1694,7 @@ _bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 dbopi(ge)
 
 static jit_word_t
-_bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULE_D(r1, r2);
@@ -1706,7 +1706,7 @@ _bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 dbopi(gt)
 
 static jit_word_t
-_bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bner_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_EQ_D(r1, r2);
@@ -1718,7 +1718,7 @@ _bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, 
jit_int32_t r2)
 dbopi(ne)
 
 static jit_word_t
-_bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bunltr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULT_D(r1, r2);
@@ -1730,7 +1730,7 @@ _bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 dbopi(unlt)
 
 static jit_word_t
-_bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bunler_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_ULE_D(r1, r2);
@@ -1742,7 +1742,7 @@ _bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 dbopi(unle)
 
 static jit_word_t
-_buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_buneqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UEQ_D(r1, r2);
@@ -1754,7 +1754,7 @@ _buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 dbopi(uneq)
 
 static jit_word_t
-_bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bunger_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLT_D(r1, r2);
@@ -1766,7 +1766,7 @@ _bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 dbopi(unge)
 
 static jit_word_t
-_bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bungtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_OLE_D(r1, r2);
@@ -1778,7 +1778,7 @@ _bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 dbopi(ungt)
 
 static jit_word_t
-_bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bltgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UEQ_D(r1, r2);
@@ -1790,7 +1790,7 @@ _bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 dbopi(ltgt)
 
 static jit_word_t
-_bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bordr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UN_D(r1, r2);
@@ -1802,7 +1802,7 @@ _bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r1, jit_int32_t r2)
 dbopi(ord)
 
 static jit_word_t
-_bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r1, jit_int32_t r2)
+_bunordr_d(jit_state_t *_jit, jit_word_t i0, int32_t r1, jit_int32_t r2)
 {
     jit_word_t         w;
     C_UN_D(r1, r2);
@@ -1814,10 +1814,10 @@ _bunordr_d(jit_state_t *_jit, jit_word_t i0, 
jit_int32_t r1, jit_int32_t r2)
 dbopi(unord)
 
 static void
-_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
 #if !NEW_ABI
-    jit_int32_t                reg;
+    int32_t            reg;
 #endif
     assert(_jitc->function->self.call & jit_call_varargs);
 #if !NEW_ABI
diff --git a/jit/mips.c b/jit/mips.c
index be878f5..5eaeaff 100644
--- a/jit/mips.c
+++ b/jit/mips.c
@@ -41,9 +41,9 @@
 #  define S_DISP                       0
 #  define I_DISP                       0
 #else
-#  define C_DISP                       STACK_SLOT - sizeof(jit_int8_t)
-#  define S_DISP                       STACK_SLOT - sizeof(jit_int16_t)
-#  define I_DISP                       STACK_SLOT - sizeof(jit_int32_t)
+#  define C_DISP                       STACK_SLOT - sizeof(int8_t)
+#  define S_DISP                       STACK_SLOT - sizeof(int16_t)
+#  define I_DISP                       STACK_SLOT - sizeof(int32_t)
 #endif
 
 /*
@@ -169,7 +169,7 @@ _jit_init(jit_state_t *_jit)
 void
 _jit_prolog(jit_state_t *_jit)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
 
     if (_jitc->function)
        jit_epilog();
@@ -188,7 +188,7 @@ _jit_prolog(jit_state_t *_jit)
        _jitc->function->self.aoff = _jitc->function->self.alen = 0;
     _jitc->function->self.call = jit_call_default;
     jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
-             _jitc->reglen * sizeof(jit_int32_t));
+             _jitc->reglen * sizeof(int32_t));
 
     /* _no_link here does not mean the jit_link() call can be removed
      * by rewriting as:
@@ -207,8 +207,8 @@ _jit_prolog(jit_state_t *_jit)
     jit_regset_new(&_jitc->function->regset);
 }
 
-jit_int32_t
-_jit_allocai(jit_state_t *_jit, jit_int32_t length)
+int32_t
+_jit_allocai(jit_state_t *_jit, int32_t length)
 {
     assert(_jitc->function);
     switch (length) {
@@ -226,13 +226,13 @@ _jit_allocai(jit_state_t *_jit, jit_int32_t length)
 }
 
 void
-_jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_allocar(jit_state_t *_jit, int32_t u, jit_int32_t v)
 {
-    jit_int32_t                 reg;
+    int32_t             reg;
     assert(_jitc->function);
     jit_inc_synth_ww(allocar, u, v);
     if (!_jitc->function->allocar) {
-       _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
+       _jitc->function->aoffoff = jit_allocai(sizeof(int32_t));
        _jitc->function->allocar = 1;
     }
     reg = jit_get_reg(jit_class_gpr);
@@ -259,7 +259,7 @@ _jit_ret(jit_state_t *_jit)
 }
 
 void
-_jit_retr(jit_state_t *_jit, jit_int32_t u)
+_jit_retr(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr, u);
     if (JIT_RET != u)
@@ -279,7 +279,7 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_f(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_f, u);
     if (JIT_FRET != u)
@@ -300,7 +300,7 @@ _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_d(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_d, u);
     if (JIT_FRET != u)
@@ -345,7 +345,7 @@ _jit_arg_register_p(jit_state_t *_jit, jit_node_t *u)
 static jit_node_t *
 _jit_make_arg(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
 #if NEW_ABI
     if (jit_arg_reg_p(_jitc->function->self.argi))
        offset = _jitc->function->self.argi++;
@@ -373,7 +373,7 @@ _jit_make_arg(jit_state_t *_jit, jit_node_t *node)
 static jit_node_t *
 _jit_make_arg_f(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
 #if NEW_ABI
     if (jit_arg_reg_p(_jitc->function->self.argi)) {
        offset = _jitc->function->self.argi++;
@@ -416,7 +416,7 @@ _jit_make_arg_f(jit_state_t *_jit, jit_node_t *node)
 static jit_node_t *
 _jit_make_arg_d(jit_state_t *_jit, jit_node_t *node)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
 #if NEW_ABI
     if (jit_arg_reg_p(_jitc->function->self.argi)) {
        offset = _jitc->function->self.argi++;
@@ -490,7 +490,7 @@ _jit_ellipsis(jit_state_t *_jit)
 }
 
 void
-_jit_va_push(jit_state_t *_jit, jit_int32_t u)
+_jit_va_push(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(va_push, u);
     jit_pushargr(u);
@@ -519,7 +519,7 @@ _jit_arg_d(jit_state_t *_jit)
 }
 
 void
-_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_c(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_c, u, v);
@@ -531,7 +531,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_uc(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_uc, u, v);
@@ -543,7 +543,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_s(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_s, u, v);
@@ -555,7 +555,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_us(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_us, u, v);
@@ -567,7 +567,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_i(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_i, u, v);
@@ -585,7 +585,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 
 #if __WORDSIZE == 64
 void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_ui(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_ui, u, v);
@@ -597,7 +597,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_l(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_l, u, v);
@@ -610,7 +610,7 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 #endif
 
 void
-_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     jit_inc_synth_wp(putargr, u, v);
     assert(v->code == jit_code_arg);
@@ -624,7 +624,7 @@ _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargi, u, v);
     if (jit_arg_reg_p(v->u.w))
@@ -639,7 +639,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 }
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(getarg_f, u, v);
@@ -660,7 +660,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(putargr_f, u, v);
@@ -683,7 +683,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_fp(putargi_f, u, v);
 #if NEW_ABI
@@ -715,7 +715,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, 
jit_node_t *v)
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(getarg_d, u, v);
@@ -736,7 +736,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(putargr_d, u, v);
@@ -759,7 +759,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_dp(putargi_d, u, v);
 #if NEW_ABI
@@ -791,7 +791,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, 
jit_node_t *v)
 }
 
 void
-_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(pushargr, u);
     jit_link_prepare();
@@ -822,7 +822,7 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
 #if !NEW_ABI
     jit_word_t         offset;
 #endif
@@ -858,7 +858,7 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_f(jit_state_t *_jit, int32_t u)
 {
 #if !NEW_ABI
     jit_word_t         offset;
@@ -899,7 +899,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
 #if !NEW_ABI
     jit_word_t         offset;
 #endif
@@ -944,7 +944,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_d(jit_state_t *_jit, int32_t u)
 {
 #if !NEW_ABI
     jit_bool_t         adjust;
@@ -992,7 +992,7 @@ _jit_pushargr_d(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
 #if !NEW_ABI
     jit_bool_t         adjust;
     jit_word_t         offset;
@@ -1044,9 +1044,9 @@ _jit_pushargi_d(jit_state_t *_jit, jit_float64_t u)
 }
 
 jit_bool_t
-_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, jit_int32_t regno)
+_jit_regarg_p(jit_state_t *_jit, jit_node_t *node, int32_t regno)
 {
-    jit_int32_t                spec;
+    int32_t            spec;
 
     spec = jit_class(_rvs[regno].spec);
     if (spec & jit_class_arg) {
@@ -1066,7 +1066,7 @@ _jit_regarg_p(jit_state_t *_jit, jit_node_t *node, 
jit_int32_t regno)
 }
 
 void
-_jit_finishr(jit_state_t *_jit, jit_int32_t r0)
+_jit_finishr(jit_state_t *_jit, int32_t r0)
 {
     jit_node_t         *call;
     assert(_jitc->function);
@@ -1112,31 +1112,31 @@ _jit_finishi(jit_state_t *_jit, jit_pointer_t i0)
 }
 
 void
-_jit_retval_c(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_c(jit_state_t *_jit, int32_t r0)
 {
     jit_extr_c(r0, JIT_RET);
 }
 
 void
-_jit_retval_uc(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_uc(jit_state_t *_jit, int32_t r0)
 {
     jit_extr_uc(r0, JIT_RET);
 }
 
 void
-_jit_retval_s(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_s(jit_state_t *_jit, int32_t r0)
 {
     jit_extr_s(r0, JIT_RET);
 }
 
 void
-_jit_retval_us(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_us(jit_state_t *_jit, int32_t r0)
 {
     jit_extr_us(r0, JIT_RET);
 }
 
 void
-_jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_i(jit_state_t *_jit, int32_t r0)
 {
 #if __WORDSIZE == 32
     if (r0 != JIT_RET)
@@ -1148,13 +1148,13 @@ _jit_retval_i(jit_state_t *_jit, jit_int32_t r0)
 
 #if __WORDSIZE == 64
 void
-_jit_retval_ui(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_ui(jit_state_t *_jit, int32_t r0)
 {
     jit_extr_ui(r0, JIT_RET);
 }
 
 void
-_jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_l(jit_state_t *_jit, int32_t r0)
 {
     if (r0 != JIT_RET)
        jit_movr(r0, JIT_RET);
@@ -1162,14 +1162,14 @@ _jit_retval_l(jit_state_t *_jit, jit_int32_t r0)
 #endif
 
 void
-_jit_retval_f(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_f(jit_state_t *_jit, int32_t r0)
 {
     if (r0 != JIT_FRET)
        jit_movr_f(r0, JIT_FRET);
 }
 
 void
-_jit_retval_d(jit_state_t *_jit, jit_int32_t r0)
+_jit_retval_d(jit_state_t *_jit, int32_t r0)
 {
     if (r0 != JIT_FRET)
        jit_movr_d(r0, JIT_FRET);
@@ -1181,15 +1181,15 @@ _emit_code(jit_state_t *_jit)
     jit_node_t         *node;
     jit_node_t         *temp;
     jit_word_t          word;
-    jit_int32_t                 value;
-    jit_int32_t                 offset;
+    int32_t             value;
+    int32_t             offset;
     struct {
        jit_node_t      *node;
        jit_word_t       word;
 #if DEVEL_DISASSEMBLER
        jit_word_t       prevw;
 #endif
-       jit_int32_t      patch_offset;
+       int32_t  patch_offset;
     } undo;
 #if DEVEL_DISASSEMBLER
     jit_word_t          prevw;
@@ -1883,25 +1883,25 @@ jit_flush(void *fptr, void *tptr)
 }
 
 void
-_emit_ldxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi(rn(r0), rn(r1), i0);
 }
 
 void
-_emit_stxi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     stxi(i0, rn(r0), rn(r1));
 }
 
 void
-_emit_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_emit_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi_d(rn(r0), rn(r1), i0);
 }
 
 void
-_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_emit_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     stxi_d(i0, rn(r0), rn(r1));
 }
@@ -1909,7 +1909,7 @@ _emit_stxi_d(jit_state_t *_jit, jit_word_t i0, 
jit_int32_t r0, jit_int32_t r1)
 static void
 _patch(jit_state_t *_jit, jit_word_t instr, jit_node_t *node)
 {
-    jit_int32_t                 flag;
+    int32_t             flag;
 
     assert(node->flag & jit_flag_node);
     if (node->code == jit_code_movi)
diff --git a/jit/ppc-cpu.c b/jit/ppc-cpu.c
index 0fb6959..c0cf416 100644
--- a/jit/ppc-cpu.c
+++ b/jit/ppc-cpu.c
@@ -308,7 +308,7 @@ error handler to be invoked
 #    define MCRXR(d)                   FX(31,d<<2,0,0,512)
 #  else
 #    define MCRXR(cr)                  _MCRXR(_jit,cr);
-static void _MCRXR(jit_state_t*, jit_int32_t);
+static void _MCRXR(jit_state_t*, int32_t);
 #  endif
 #  define MFCR(d)                      FX(31,d,0,0,19)
 #  define MFMSR(d)                     FX(31,d,0,0,83)
@@ -492,13 +492,13 @@ static void _MCRXR(jit_state_t*, jit_int32_t);
 #  define XORI(s,a,u)                  FDu(26,a,s,u)
 #  define XORIS(s,a,u)                 FDu(27,a,s,u)
 #  define nop(c)                       _nop(_jit,c)
-static void _nop(jit_state_t*,jit_int32_t);
+static void _nop(jit_state_t*,int32_t);
 #  define movr(r0,r1)                  _movr(_jit,r0,r1)
-static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr(jit_state_t*,int32_t,jit_int32_t);
 #  define movi(r0,i0)                  _movi(_jit,r0,i0)
-static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
+static void _movi(jit_state_t*,int32_t,jit_word_t);
 #  define movi_p(r0,i0)                        _movi_p(_jit,r0,i0)
-static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
+static jit_word_t _movi_p(jit_state_t*,int32_t,jit_word_t);
 #  define negr(r0,r1)                  NEG(r0,r1)
 #  define comr(r0,r1)                  NOT(r0,r1)
 #  define extr_c(r0,r1)                        EXTSB(r0,r1)
@@ -519,34 +519,34 @@ static jit_word_t 
_movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 #    endif
 #  else
 #    define htonr_us(r0,r1)            _htonr_us(_jit,r0,r1)
-static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_us(jit_state_t*,int32_t,jit_int32_t);
 #    define htonr_ui(r0,r1)            _htonr_ui(_jit,r0,r1)
-static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ui(jit_state_t*,int32_t,jit_int32_t);
 #    if __WORDSIZE == 64
 #      define htonr_ul(r0,r1)          _htonr_ul(_jit,r0,r1)
-static void _htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _htonr_ul(jit_state_t*,int32_t,jit_int32_t);
 #    endif
 #  endif
 #  define addr(r0,r1,r2)               ADD(r0,r1,r2)
 #  define addi(r0,r1,i0)               _addi(_jit,r0,r1,i0)
-static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addcr(r0,r1,r2)              ADDC(r0,r1,r2)
 #  define addci(r0,r1,i0)              _addci(_jit,r0,r1,i0)
-static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define addxr(r0,r1,r2)              ADDE(r0,r1,r2)
 #  define addxi(r0,r1,i0)              _addxi(_jit,r0,r1,i0)
-static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _addxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subr(r0,r1,r2)               SUB(r0,r1,r2)
 #  define subi(r0,r1,i0)               _subi(_jit,r0,r1,i0)
-static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subcr(r0,r1,r2)              SUBC(r0,r1,r2)
 #  define subci(r0,r1,i0)              _subci(_jit,r0,r1,i0)
-static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subci(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define subxr(r0,r1,r2)              SUBFE(r0,r2,r1)
 #  define subxi(r0,r1,i0)              _subxi(_jit,r0,r1,i0)
-static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _subxi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define rsbi(r0, r1, i0)             _rsbi(_jit, r0, r1, i0)
-static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rsbi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 32
 #    define mulr(r0,r1,r2)             MULLW(r0,r1,r2)
 #    define mullr(r0,r1,r2)            MULLW(r0,r1,r2)
@@ -559,293 +559,293 @@ static void 
_rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 #    define mulhr_u(r0,r1,r2)          MULHDU(r0,r1,r2)
 #  endif
 #  define muli(r0,r1,i0)               _muli(_jit,r0,r1,i0)
-static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _muli(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qmulr(r0,r1,r2,r3)           iqmulr(r0,r1,r2,r3,1)
 #  define qmulr_u(r0,r1,r2,r3)         iqmulr(r0,r1,r2,r3,0)
 #  define iqmulr(r0,r1,r2,r3,cc)       _iqmulr(_jit,r0,r1,r2,r3,cc)
-static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_bool_t);
+static void _iqmulr(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_bool_t);
 #  define qmuli(r0,r1,r2,i0)           iqmuli(r0,r1,r2,i0,1)
 #  define qmuli_u(r0,r1,r2,i0)         iqmuli(r0,r1,r2,i0,0)
 #  define iqmuli(r0,r1,r2,i0,cc)       _iqmuli(_jit,r0,r1,r2,i0,cc)
-static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_word_t,jit_bool_t);
+static void _iqmuli(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_word_t,jit_bool_t);
 #  if __WORDSIZE == 32
 #    define divr(r0,r1,r2)             DIVW(r0,r1,r2)
 #  else
 #    define divr(r0,r1,r2)             DIVD(r0,r1,r2)
 #  endif
 #  define divi(r0,r1,i0)               _divi(_jit,r0,r1,i0)
-static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 32
 #    define divr_u(r0,r1,r2)           DIVWU(r0,r1,r2)
 #  else
 #    define divr_u(r0,r1,r2)           DIVDU(r0,r1,r2)
 #  endif
 #  define divi_u(r0,r1,i0)             _divi_u(_jit,r0,r1,i0)
-static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _divi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define qdivr(r0,r1,r2,r3)           iqdivr(r0,r1,r2,r3,1)
 #  define qdivr_u(r0,r1,r2,r3)         iqdivr(r0,r1,r2,r3,0)
 #  define iqdivr(r0,r1,r2,r3,cc)       _iqdivr(_jit,r0,r1,r2,r3,cc)
-static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_int32_t,jit_bool_t);
+static void _iqdivr(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_int32_t,jit_bool_t);
 #  define qdivi(r0,r1,r2,i0)           iqdivi(r0,r1,r2,i0,1)
 #  define qdivi_u(r0,r1,r2,i0)         iqdivi(r0,r1,r2,i0,0)
 #  define iqdivi(r0,r1,r2,i0,cc)       _iqdivi(_jit,r0,r1,r2,i0,cc)
-static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
-                   jit_int32_t,jit_word_t,jit_bool_t);
+static void _iqdivi(jit_state_t*,int32_t,jit_int32_t,
+                   int32_t,jit_word_t,jit_bool_t);
 #  define remr(r0,r1,r2)               _remr(_jit,r0,r1,r2)
-static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi(r0,r1,i0)               _remi(_jit,r0,r1,i0)
-static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define remr_u(r0,r1,r2)             _remr_u(_jit,r0,r1,r2)
-static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _remr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define remi_u(r0,r1,i0)             _remi_u(_jit,r0,r1,i0)
-static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _remi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define andr(r0,r1,r2)               AND(r0,r1,r2)
 #  define andi(r0,r1,i0)               _andi(_jit,r0,r1,i0)
-static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _andi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define orr(r0,r1,r2)                        OR(r0,r1,r2)
 #  define ori(r0,r1,i0)                        _ori(_jit,r0,r1,i0)
-static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define xorr(r0,r1,r2)               XOR(r0,r1,r2)
 #  define xori(r0,r1,i0)               _xori(_jit,r0,r1,i0)
-static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _xori(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 32
 #    define lshr(r0,r1,r2)             SLW(r0,r1,r2)
 #  else
 #    define lshr(r0,r1,r2)             SLD(r0,r1,r2)
 #  endif
 #  define lshi(r0,r1,i0)               _lshi(_jit,r0,r1,i0)
-static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 32
 #    define rshr(r0,r1,r2)             SRAW(r0,r1,r2)
 #  else
 #    define rshr(r0,r1,r2)             SRAD(r0,r1,r2)
 #  endif
 #  define rshi(r0,r1,i0)               _rshi(_jit,r0,r1,i0)
-static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 32
 #    define rshr_u(r0,r1,r2)           SRW(r0,r1,r2)
 #  else
 #    define rshr_u(r0,r1,r2)           SRD(r0,r1,r2)
 #  endif
 #  define rshi_u(r0,r1,i0)             _rshi_u(_jit,r0,r1,i0)
-static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _rshi_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ltr(r0,r1,r2)                        _ltr(_jit,r0,r1,r2)
-static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lti(r0,r1,i0)                        _lti(_jit,r0,r1,i0)
-static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lti(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ltr_u(r0,r1,r2)              _ltr_u(_jit,r0,r1,r2)
-static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lti_u(r0,r1,i0)              _lti_u(_jit,r0,r1,i0)
-static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lti_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ler(r0,r1,r2)                        _ler(_jit,r0,r1,r2)
-static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lei(r0,r1,i0)                        _lei(_jit,r0,r1,i0)
-static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ler_u(r0,r1,r2)              _ler_u(_jit,r0,r1,r2)
-static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lei_u(r0,r1,i0)              _lei_u(_jit,r0,r1,i0)
-static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _lei_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define eqr(r0,r1,r2)                        _eqr(_jit,r0,r1,r2)
-static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _eqr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define eqi(r0,r1,i0)                        _eqi(_jit,r0,r1,i0)
-static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _eqi(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ger(r0,r1,r2)                        _ger(_jit,r0,r1,r2)
-static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gei(r0,r1,i0)                        _gei(_jit,r0,r1,i0)
-static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ger_u(r0,r1,r2)              _ger_u(_jit,r0,r1,r2)
-static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gei_u(r0,r1,i0)              _gei_u(_jit,r0,r1,i0)
-static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gei_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define gtr(r0,r1,r2)                        _gtr(_jit,r0,r1,r2)
-static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gti(r0,r1,i0)                        _gti(_jit,r0,r1,i0)
-static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gti(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define gtr_u(r0,r1,r2)              _gtr_u(_jit,r0,r1,r2)
-static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr_u(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gti_u(r0,r1,i0)              _gti_u(_jit,r0,r1,i0)
-static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _gti_u(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ner(r0,r1,r2)                        _ner(_jit,r0,r1,r2)
-static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define nei(r0,r1,i0)                        _nei(_jit,r0,r1,i0)
-static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _nei(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #define bltr(i0,r0,r1)                 _bltr(_jit,i0,r0,r1)
-static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blti(i0,r0,i1)                 _blti(_jit,i0,r0,i1)
-static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blti(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bltr_u(i0,r0,r1)               _bltr_u(_jit,i0,r0,r1)
-static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blti_u(i0,r0,i1)               _blti_u(_jit,i0,r0,i1)
-static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blti_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bler(i0,r0,r1)                 _bler(_jit,i0,r0,r1)
-static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blei(i0,r0,i1)                 _blei(_jit,i0,r0,i1)
-static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bler_u(i0,r0,r1)               _bler_u(_jit,i0,r0,r1)
-static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define blei_u(i0,r0,i1)               _blei_u(_jit,i0,r0,i1)
-static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _blei_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define beqr(i0,r0,r1)                 _beqr(_jit,i0,r0,r1)
-static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define beqi(i0,r0,i1)                 _beqi(_jit,i0,r0,i1)
-static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _beqi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bger(i0,r0,r1)                 _bger(_jit,i0,r0,r1)
-static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgei(i0,r0,i1)                 _bgei(_jit,i0,r0,i1)
-static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bger_u(i0,r0,r1)               _bger_u(_jit,i0,r0,r1)
-static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgei_u(i0,r0,i1)               _bgei_u(_jit,i0,r0,i1)
-static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgei_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bgtr(i0,r0,r1)                 _bgtr(_jit,i0,r0,r1)
-static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgti(i0,r0,i1)                 _bgti(_jit,i0,r0,i1)
-static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgti(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bgtr_u(i0,r0,r1)               _bgtr_u(_jit,i0,r0,r1)
-static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bgti_u(i0,r0,i1)               _bgti_u(_jit,i0,r0,i1)
-static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bgti_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bner(i0,r0,r1)                 _bner(_jit,i0,r0,r1)
-static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bnei(i0,r0,i1)                 _bnei(_jit,i0,r0,i1)
-static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bnei(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bmsr(i0,r0,r1)                 _bmsr(_jit,i0,r0,r1)
-static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bmsr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bmsi(i0,r0,i1)                 _bmsi(_jit,i0,r0,i1)
-static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bmsi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bmcr(i0,r0,r1)                 _bmcr(_jit,i0,r0,r1)
-static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bmcr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bmci(i0,r0,i1)                 _bmci(_jit,i0,r0,i1)
-static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bmci(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define boaddr(i0,r0,r1)               _boaddr(_jit,i0,r0,r1)
-static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _boaddr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define boaddi(i0,r0,i1)               _boaddi(_jit,i0,r0,i1)
-static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _boaddi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bxaddr(i0,r0,r1)               _bxaddr(_jit,i0,r0,r1)
-static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxaddr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bxaddi(i0,r0,i1)               _bxaddi(_jit,i0,r0,i1)
-static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxaddi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bosubr(i0,r0,r1)               _bosubr(_jit,i0,r0,r1)
-static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bosubr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bosubi(i0,r0,i1)               _bosubi(_jit,i0,r0,i1)
-static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bosubi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bxsubr(i0,r0,r1)               _bxsubr(_jit,i0,r0,r1)
-static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxsubr(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bxsubi(i0,r0,i1)               _bxsubi(_jit,i0,r0,i1)
-static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxsubi(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define boaddr_u(i0,r0,r1)             _boaddr_u(_jit,i0,r0,r1)
-static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define boaddi_u(i0,r0,i1)             _boaddi_u(_jit,i0,r0,i1)
-static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bxaddr_u(i0,r0,r1)             _bxaddr_u(_jit,i0,r0,r1)
-static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bxaddi_u(i0,r0,i1)             _bxaddi_u(_jit,i0,r0,i1)
-static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bosubr_u(i0,r0,r1)             _bosubr_u(_jit,i0,r0,r1)
-static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bosubi_u(i0,r0,i1)             _bosubi_u(_jit,i0,r0,i1)
-static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #define bxsubr_u(i0,r0,r1)             _bxsubr_u(_jit,i0,r0,r1)
-static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #define bxsubi_u(i0,r0,i1)             _bxsubi_u(_jit,i0,r0,i1)
-static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
+static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,int32_t,jit_word_t);
 #  define ldr_c(r0,r1)                 _ldr_c(_jit,r0,r1)
-static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _ldr_c(jit_state_t*,int32_t,jit_int32_t);
 #  define ldi_c(r0,i0)                 _ldi_c(_jit,r0,i0)
-static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_c(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_c(r0,r1,i0)             _ldxr_c(_jit,r0,r1,i0)
-static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_c(r0,r1,i0)             _ldxi_c(_jit,r0,r1,i0)
-static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_c(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldr_uc(r0,r1)                        LBZX(r0, _R0_REGNO, r1)
 #  define ldi_uc(r0,i0)                        _ldi_uc(_jit,r0,i0)
-static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_uc(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_uc(r0,r1,r2)            _ldxr_uc(_jit,r0,r1,r2)
-static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_uc(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_uc(r0,r1,i0)            _ldxi_uc(_jit,r0,r1,i0)
-static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_uc(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldr_s(r0,r1)                 LHAX(r0, _R0_REGNO, r1)
 #  define ldi_s(r0,i0)                 _ldi_s(_jit,r0,i0)
-static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_s(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_s(r0,r1,i0)             _ldxr_s(_jit,r0,r1,i0)
-static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_s(r0,r1,i0)             _ldxi_s(_jit,r0,r1,i0)
-static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_s(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define ldr_us(r0,r1)                        LHZX(r0, _R0_REGNO, r1)
 #  define ldi_us(r0,i0)                        _ldi_us(_jit,r0,i0)
-static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_us(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_us(r0,r1,i0)            _ldxr_us(_jit,r0,r1,i0)
-static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_us(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_us(r0,r1,i0)            _ldxi_us(_jit,r0,r1,i0)
-static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_us(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 32
 #    define ldr_i(r0,r1)               LWZX(r0, _R0_REGNO, r1)
 #  else
 #    define ldr_i(r0,r1)               LWAX(r0, _R0_REGNO, r1)
 #  endif
 #  define ldi_i(r0,i0)                 _ldi_i(_jit,r0,i0)
-static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_i(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_i(r0,r1,i0)             _ldxr_i(_jit,r0,r1,i0)
-static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_i(r0,r1,i0)             _ldxi_i(_jit,r0,r1,i0)
-static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_i(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  if __WORDSIZE == 64
 #    define ldr_ui(r0,r1)              LWZX(r0, _R0_REGNO, r1)
 #    define ldi_ui(r0,i0)              _ldi_ui(_jit,r0,i0)
-static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_ui(jit_state_t*,int32_t,jit_word_t);
 #    define ldxr_ui(r0,r1,i0)          _ldxr_ui(_jit,r0,r1,i0)
-static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_ui(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #    define ldxi_ui(r0,r1,i0)          _ldxi_ui(_jit,r0,r1,i0)
-static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_ui(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #    define ldr_l(r0,r1)               LDX(r0, _R0_REGNO, r1)
 #    define ldi_l(r0,i0)               _ldi_l(_jit,r0,i0)
-static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_l(jit_state_t*,int32_t,jit_word_t);
 #    define ldxr_l(r0,r1,i0)           _ldxr_l(_jit,r0,r1,i0)
-static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_l(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #    define ldxi_l(r0,r1,i0)           _ldxi_l(_jit,r0,r1,i0)
-static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_l(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  endif
 #  define str_c(r0,r1)                 STBX(r1, _R0_REGNO, r0)
 #  define sti_c(i0,r0)                 _sti_c(_jit,i0,r0)
-static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_c(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_c(r0,r1,r2)             _stxr_c(_jit,r0,r1,r2)
-static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_c(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_c(i0,r0,r1)             _stxi_c(_jit,i0,r0,r1)
-static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_c(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define str_s(r0,r1)                 STHX(r1, _R0_REGNO, r0)
 #  define sti_s(i0,r0)                 _sti_s(_jit,i0,r0)
-static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_s(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_s(r0,r1,r2)             _stxr_s(_jit,r0,r1,r2)
-static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_s(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_s(i0,r0,r1)             _stxi_s(_jit,i0,r0,r1)
-static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_s(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define str_i(r0,r1)                 STWX(r1, _R0_REGNO, r0)
 #  define sti_i(i0,r0)                 _sti_i(_jit,i0,r0)
-static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_i(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_i(r0,r1,r2)             _stxr_i(_jit,r0,r1,r2)
-static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_i(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_i(i0,r0,r1)             _stxi_i(_jit,i0,r0,r1)
-static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_i(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  if __WORDSIZE == 64
 #    define str_l(r0,r1)               STDX(r1, _R0_REGNO, r0)
 #    define sti_l(i0,r0)               _sti_l(_jit,i0,r0)
-static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_l(jit_state_t*,jit_word_t,int32_t);
 #    define stxr_l(r0,r1,r2)           _stxr_l(_jit,r0,r1,r2)
-static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_l(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #    define stxi_l(i0,r0,r1)           _stxi_l(_jit,i0,r0,r1)
-static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_l(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  endif
 #  define jmpr(r0)                     _jmpr(_jit,r0)
-static void _jmpr(jit_state_t*,jit_int32_t);
+static void _jmpr(jit_state_t*,int32_t);
 #  define jmpi(i0)                     _jmpi(_jit,i0)
 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
 #  define jmpi_p(i0)                   _jmpi_p(_jit,i0)
 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
 #  define callr(r0)                    _callr(_jit,r0)
-static void _callr(jit_state_t*,jit_int32_t);
+static void _callr(jit_state_t*,int32_t);
 #  define calli(i0)                    _calli(_jit,i0)
 static void _calli(jit_state_t*,jit_word_t);
 #  define calli_p(i0)                  _calli_p(_jit,i0)
@@ -855,9 +855,9 @@ static void _prolog(jit_state_t*, jit_node_t*);
 #  define epilog(node)                 _epilog(_jit, node)
 static void _epilog(jit_state_t*, jit_node_t*);
 #  define vastart(r0)                  _vastart(_jit, r0)
-static void _vastart(jit_state_t*, jit_int32_t);
+static void _vastart(jit_state_t*, int32_t);
 #  define vaarg(r0, r1)                        _vaarg(_jit, r0, r1)
-static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg(jit_state_t*, int32_t, jit_int32_t);
 #  define patch_at(i,l)                        _patch_at(_jit,i,l)
 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 #endif
@@ -1043,9 +1043,9 @@ _FXS(jit_state_t *_jit, int o, int s, int a, int h, int 
x, int i, int r)
  * 
http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
  */
 static void
-_MCRXR(jit_state_t *_jit, jit_int32_t cr)
+_MCRXR(jit_state_t *_jit, int32_t cr)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     MFXER(rn(reg));
     MTCRF(128, rn(reg));
@@ -1056,7 +1056,7 @@ _MCRXR(jit_state_t *_jit, jit_int32_t cr)
 #endif
 
 static void
-_nop(jit_state_t *_jit, jit_int32_t i0)
+_nop(jit_state_t *_jit, int32_t i0)
 {
     for (; i0 > 0; i0 -= 4)
        NOP();
@@ -1064,32 +1064,32 @@ _nop(jit_state_t *_jit, jit_int32_t i0)
 }
 
 static void
-_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        MR(r0, r1);
 }
 
 static void
-_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     if (can_sign_extend_short_p(i0))
        LI(r0, i0);
     else {
        if (can_sign_extend_int_p(i0))
-           LIS(r0, (jit_int16_t)(i0 >> 16));
+           LIS(r0, (int16_t)(i0 >> 16));
        else if (can_zero_extend_int_p(i0)) {
            if (i0 & 0xffff0000) {
-               ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
+               ORI(r0, r0, (uint16_t)(i0 >> 16));
                SLWI(r0, r0, 16);
            }
        }
 #  if __WORDSIZE == 64
        else {
-           movi(r0, (jit_uint32_t)(i0 >> 32));
+           movi(r0, (uint32_t)(i0 >> 32));
            if (i0 & 0xffff0000) {
                SLDI(r0, r0, 16);
-               ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
+               ORI(r0, r0, (uint16_t)(i0 >> 16));
                SLDI(r0, r0, 16);
            }
            else
@@ -1097,33 +1097,33 @@ _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
        }
 #  endif
        if (i0 & 0xffff)
-           ORI(r0, r0, (jit_uint16_t)i0);
+           ORI(r0, r0, (uint16_t)i0);
     }
 }
 
 static jit_word_t
-_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_movi_p(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_word_t         word = _jit->pc.w;
 #  if __WORDSIZE == 32
-    LIS(r0, (jit_int16_t)(i0 >> 16));
-    ORI(r0, r0, (jit_uint16_t)i0);
+    LIS(r0, (int16_t)(i0 >> 16));
+    ORI(r0, r0, (uint16_t)i0);
 #  else
-    LIS(r0, (jit_int16_t)(i0 >> 48));
-    ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
+    LIS(r0, (int16_t)(i0 >> 48));
+    ORI(r0, r0, (uint16_t)(i0 >> 32));
     SLDI(r0, r0, 16);
-    ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
+    ORI(r0, r0, (uint16_t)(i0 >> 16));
     SLDI(r0, r0, 16);
-    ORI(r0, r0, (jit_uint16_t)i0);
+    ORI(r0, r0, (uint16_t)i0);
 #  endif
     return (word);
 }
 
 #  if __BYTE_ORDER == __LITTLE_ENDIAN
 static void
-_htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                t0;
+    int32_t            t0;
     t0 = jit_get_reg(jit_class_gpr);
     rshi(rn(t0), r1, 8);
     andi(r0, r1, 0xff);
@@ -1134,9 +1134,9 @@ _htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 }
 
 static void
-_htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     ROTLWI(rn(reg), r1, 8);
     RLWIMI(rn(reg), r1, 24, 0, 7);
@@ -1147,9 +1147,9 @@ _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 
 #    if __WORDSIZE == 64
 static void
-_htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_htonr_ul(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     rshi_u(rn(reg), r1, 32);
     htonr_ui(r0, r1);
@@ -1162,9 +1162,9 @@ _htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 #  endif
 
 static void
-_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        ADDI(r0, r1, i0);
     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
@@ -1178,9 +1178,9 @@ _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        ADDIC(r0, r1, i0);
     else {
@@ -1192,9 +1192,9 @@ _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_addxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     ADDE(r0, r1, rn(reg));
@@ -1202,9 +1202,9 @@ _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         ni0 = -i0;
     if (can_sign_extend_short_p(ni0))
        ADDI(r0, r1, ni0);
@@ -1219,9 +1219,9 @@ _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subci(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     SUBC(r0, r1, rn(reg));
@@ -1229,9 +1229,9 @@ _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_subxi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     SUBE(r0, r1, rn(reg));
@@ -1239,16 +1239,16 @@ _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rsbi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     subi(r0, r1, i0);
     negr(r0, r0);
 }
 
 static void
-_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_muli(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        MULLI(r0, r1, i0);
     else {
@@ -1260,10 +1260,10 @@ _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
+_iqmulr(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_int32_t r3, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r2 || r0 == r3) {
        reg = jit_get_reg(jit_class_gpr);
        mullr(rn(reg), r2, r3);
@@ -1281,10 +1281,10 @@ _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
+_iqmuli(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     iqmulr(r0, r1, r2, rn(reg), sign);
@@ -1292,9 +1292,9 @@ _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
 }
 
 static void
-_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     divr(r0, r1, rn(reg));
@@ -1302,9 +1302,9 @@ _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_divi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     divr_u(r0, r1, rn(reg));
@@ -1312,11 +1312,11 @@ _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
+_iqdivr(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_int32_t r3, jit_bool_t sign)
 {
-    jit_int32_t                sv0, rg0;
-    jit_int32_t                sv1, rg1;
+    int32_t            sv0, rg0;
+    int32_t            sv1, rg1;
 
     if (r0 == r2 || r0 == r3) {
        sv0 = jit_get_reg(jit_class_gpr);
@@ -1348,10 +1348,10 @@ _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1,
 }
 
 static void
-_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
-       jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
+_iqdivi(jit_state_t *_jit, int32_t r0, jit_int32_t r1,
+       int32_t r2, jit_word_t i0, jit_bool_t sign)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     iqdivr(r0, r1, r2, rn(reg), sign);
@@ -1359,9 +1359,9 @@ _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
 }
 
 static void
-_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r1 || r0 == r2) {
        reg = jit_get_reg(jit_class_gpr);
        divr(rn(reg), r1, r2);
@@ -1377,9 +1377,9 @@ _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     remr(r0, r1, rn(reg));
@@ -1387,9 +1387,9 @@ _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_remr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == r1 || r0 == r2) {
        reg = jit_get_reg(jit_class_gpr);
        divr_u(rn(reg), r1, r2);
@@ -1405,9 +1405,9 @@ _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_remi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     movi(rn(reg), i0);
     remr_u(r0, r1, rn(reg));
@@ -1415,9 +1415,9 @@ _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_andi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        ANDI_(r0, r1, i0);
     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
@@ -1431,9 +1431,9 @@ _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        ORI(r0, r1, i0);
     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
@@ -1447,9 +1447,9 @@ _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_xori(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        XORI(r0, r1, i0);
     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
@@ -1463,7 +1463,7 @@ _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (i0 == 0)
        movr(r0, r1);
@@ -1477,7 +1477,7 @@ _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (i0 == 0)
        movr(r0, r1);
@@ -1491,7 +1491,7 @@ _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_rshi_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     if (i0 == 0)
        movr(r0, r1);
@@ -1505,7 +1505,7 @@ _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPW(r1, r2);
     MFCR(r0);
@@ -1513,9 +1513,9 @@ _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lti(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        CMPWI(r1, i0);
     else {
@@ -1529,7 +1529,7 @@ _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPLW(r1, r2);
     MFCR(r0);
@@ -1537,9 +1537,9 @@ _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lti_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        CMPLWI(r1, i0);
     else {
@@ -1553,7 +1553,7 @@ _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPW(r1, r2);
     CRNOT(CR_GT, CR_GT);
@@ -1562,9 +1562,9 @@ _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        CMPWI(r1, i0);
     else {
@@ -1579,7 +1579,7 @@ _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPLW(r1, r2);
     CRNOT(CR_GT, CR_GT);
@@ -1588,9 +1588,9 @@ _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_lei_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        CMPLWI(r1, i0);
     else {
@@ -1605,7 +1605,7 @@ _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_eqr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPW(r1, r2);
     MFCR(r0);
@@ -1613,9 +1613,9 @@ _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_eqi(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        CMPWI(r1, i0);
     else if (can_zero_extend_short_p(i0))
@@ -1631,7 +1631,7 @@ _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPW(r1, r2);
     CRNOT(CR_LT, CR_LT);
@@ -1640,9 +1640,9 @@ _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        CMPWI(r1, i0);
     else {
@@ -1657,7 +1657,7 @@ _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPLW(r1, r2);
     CRNOT(CR_LT, CR_LT);
@@ -1666,9 +1666,9 @@ _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gei_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        CMPLWI(r1, i0);
     else {
@@ -1683,7 +1683,7 @@ _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPW(r1, r2);
     MFCR(r0);
@@ -1691,9 +1691,9 @@ _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gti(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        CMPWI(r1, i0);
     else {
@@ -1707,7 +1707,7 @@ _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPLW(r1, r2);
     MFCR(r0);
@@ -1715,9 +1715,9 @@ _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_gti_u(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_zero_extend_short_p(i0))
        CMPLWI(r1, i0);
     else {
@@ -1731,7 +1731,7 @@ _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static void
-_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     CMPW(r1, r2);
     CRNOT(CR_EQ, CR_EQ);
@@ -1740,9 +1740,9 @@ _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_nei(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (can_sign_extend_short_p(i0))
        CMPWI(r1, i0);
     else if (can_zero_extend_short_p(i0))
@@ -1759,7 +1759,7 @@ _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_word_t i0)
 }
 
 static jit_word_t
-_bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPW(r0, r1);
@@ -1770,9 +1770,9 @@ _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blti(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_sign_extend_short_p(i1))
        CMPWI(r0, i1);
@@ -1789,7 +1789,7 @@ _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPLW(r0, r1);
@@ -1800,9 +1800,9 @@ _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blti_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_zero_extend_short_p(i1))
        CMPLWI(r0, i1);
@@ -1819,7 +1819,7 @@ _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPW(r0, r1);
@@ -1830,9 +1830,9 @@ _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_sign_extend_short_p(i1))
        CMPWI(r0, i1);
@@ -1849,7 +1849,7 @@ _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPLW(r0, r1);
@@ -1860,9 +1860,9 @@ _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_blei_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_zero_extend_short_p(i1))
        CMPLWI(r0, i1);
@@ -1879,7 +1879,7 @@ _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_beqr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPW(r0, r1);
@@ -1890,9 +1890,9 @@ _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_beqi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_sign_extend_short_p(i1))
        CMPWI(r0, i1);
@@ -1911,7 +1911,7 @@ _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPW(r0, r1);
@@ -1922,9 +1922,9 @@ _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_sign_extend_short_p(i1))
        CMPWI(r0, i1);
@@ -1941,7 +1941,7 @@ _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPLW(r0, r1);
@@ -1952,9 +1952,9 @@ _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgei_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_zero_extend_short_p(i1))
        CMPLWI(r0, i1);
@@ -1971,7 +1971,7 @@ _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPW(r0, r1);
@@ -1982,9 +1982,9 @@ _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgti(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_sign_extend_short_p(i1))
        CMPWI(r0, i1);
@@ -2001,7 +2001,7 @@ _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPLW(r0, r1);
@@ -2012,9 +2012,9 @@ _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bgti_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_zero_extend_short_p(i1))
        CMPLWI(r0, i1);
@@ -2031,7 +2031,7 @@ _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bner(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     CMPW(r0, r1);
@@ -2042,9 +2042,9 @@ _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bnei(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_sign_extend_short_p(i1))
        CMPWI(r0, i1);
@@ -2063,10 +2063,10 @@ _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bmsr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     andr(rn(reg), r0, r1);
     w = bnei(i0, rn(reg), 0);
@@ -2075,10 +2075,10 @@ _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bmsi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     andi(rn(reg), r0, i1);
     w = bnei(i0, rn(reg), 0);
@@ -2087,10 +2087,10 @@ _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bmcr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     andr(rn(reg), r0, r1);
     w = beqi(i0, rn(reg), 0);
@@ -2099,10 +2099,10 @@ _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static jit_word_t
-_bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bmci(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     andi(rn(reg), r0, i1);
     w = beqi(i0, rn(reg), 0);
@@ -2111,7 +2111,7 @@ _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_boaddr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     ADDO(r0, r0, r1);
@@ -2123,10 +2123,10 @@ _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_boaddi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = boaddr(i0, r0, rn(reg));
@@ -2135,7 +2135,7 @@ _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxaddr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     ADDO(r0, r0, r1);
@@ -2147,10 +2147,10 @@ _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxaddi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bxaddr(i0, r0, rn(reg));
@@ -2159,7 +2159,7 @@ _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bosubr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     SUBO(r0, r0, r1);
@@ -2171,10 +2171,10 @@ _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bosubi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bosubr(i0, r0, rn(reg));
@@ -2183,7 +2183,7 @@ _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxsubr(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     SUBO(r0, r0, r1);
@@ -2195,10 +2195,10 @@ _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxsubi(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bxsubr(i0, r0, rn(reg));
@@ -2207,7 +2207,7 @@ _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_word_t i1)
 }
 
 static jit_word_t
-_boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_boaddr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     ADDC(r0, r0, r1);
@@ -2219,9 +2219,9 @@ _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_boaddi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_sign_extend_short_p(i1)) {
        ADDIC(r0, r0, i1);
@@ -2239,7 +2239,7 @@ _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxaddr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     ADDC(r0, r0, r1);
@@ -2251,9 +2251,9 @@ _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxaddi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         d, w;
     if (can_sign_extend_short_p(i1)) {
        ADDIC(r0, r0, i1);
@@ -2271,7 +2271,7 @@ _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bosubr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     SUBC(r0, r0, r1);
@@ -2283,10 +2283,10 @@ _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bosubi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bosubr_u(i0, r0, rn(reg));
@@ -2295,7 +2295,7 @@ _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static jit_word_t
-_bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bxsubr_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     SUBC(r0, r0, r1);
@@ -2307,10 +2307,10 @@ _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static jit_word_t
-_bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
+_bxsubi_u(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_word_t i1)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     movi(rn(reg), i1);
     w = bxsubr_u(i0, r0, rn(reg));
@@ -2319,44 +2319,44 @@ _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_word_t i1)
 }
 
 static void
-_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_ldr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     ldr_uc(r0, r1);
     extr_c(r0, r0);
 }
 
 static void
-_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_c(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     ldi_uc(r0, i0);
     extr_c(r0, r0);
 }
 
 static void
-_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     ldxr_uc(r0, r1, r2);
     extr_c(r0, r0);
 }
 
 static void
-_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
     ldxi_uc(r0, r1, i0);
     extr_c(r0, r0);
 }
 
 static void
-_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_uc(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LBZ(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2373,9 +2373,9 @@ _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LBZX(r0, r2, r1);
@@ -2391,9 +2391,9 @@ _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_uc(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_uc(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2415,16 +2415,16 @@ _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_s(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LHA(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2441,9 +2441,9 @@ _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LHAX(r0, r2, r1);
@@ -2459,9 +2459,9 @@ _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_s(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2483,16 +2483,16 @@ _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LHZ(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2509,9 +2509,9 @@ _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LHZX(r0, r2, r1);
@@ -2527,9 +2527,9 @@ _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_us(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_us(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2552,16 +2552,16 @@ _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 
 #  if __WORDSIZE == 32
 static void
-_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LWZ(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2578,9 +2578,9 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LWZX(r0, r2, r1);
@@ -2596,9 +2596,9 @@ _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_i(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2621,16 +2621,16 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 
 #  else
 static void
-_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LWA(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2647,9 +2647,9 @@ _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LWZX(r0, r2, r1);
@@ -2665,9 +2665,9 @@ _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_i(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2689,16 +2689,16 @@ _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LWZ(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2715,9 +2715,9 @@ _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LWZX(r0, r2, r1);
@@ -2733,9 +2733,9 @@ _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_ui(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_i(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2757,16 +2757,16 @@ _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LD(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2783,9 +2783,9 @@ _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LDX(r0, r2, r1);
@@ -2801,9 +2801,9 @@ _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_l(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2826,16 +2826,16 @@ _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 #  endif
 
 static void
-_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_c(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        STB(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2852,9 +2852,9 @@ _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_c(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == _R0_REGNO) {
        if (r1 != _R0_REGNO)
            STBX(r2, r1, r0);
@@ -2870,9 +2870,9 @@ _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        str_c(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2894,16 +2894,16 @@ _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_s(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        STH(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2920,9 +2920,9 @@ _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_s(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == _R0_REGNO) {
        if (r1 != _R0_REGNO)
            STHX(r2, r1, r0);
@@ -2938,9 +2938,9 @@ _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        str_s(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -2962,16 +2962,16 @@ _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 }
 
 static void
-_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        STW(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -2988,9 +2988,9 @@ _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == _R0_REGNO) {
        if (r1 != _R0_REGNO)
            STWX(r2, r1, r0);
@@ -3006,9 +3006,9 @@ _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        str_i(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -3031,16 +3031,16 @@ _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t 
r0, jit_int32_t r1)
 
 #  if __WORDSIZE == 64
 static void
-_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        STD(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -3057,9 +3057,9 @@ _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == _R0_REGNO) {
        if (r1 != _R0_REGNO)
            STDX(r2, r1, r0);
@@ -3075,9 +3075,9 @@ _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_l(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        str_l(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -3100,7 +3100,7 @@ _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 #  endif
 
 static void
-_jmpr(jit_state_t *_jit, jit_int32_t r0)
+_jmpr(jit_state_t *_jit, int32_t r0)
 {
 #if 0
     MTLR(r0);
@@ -3115,7 +3115,7 @@ _jmpr(jit_state_t *_jit, jit_int32_t r0)
 static jit_word_t
 _jmpi(jit_state_t *_jit, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         w, d;
     w = _jit->pc.w;
     d = (i0 - w) & ~3;
@@ -3135,7 +3135,7 @@ static jit_word_t
 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
     w = movi_p(rn(reg), i0);
     jmpr(rn(reg));
@@ -3144,7 +3144,7 @@ _jmpi_p(jit_state_t *_jit, jit_word_t i0)
 }
 
 static void
-_callr(jit_state_t *_jit, jit_int32_t r0)
+_callr(jit_state_t *_jit, int32_t r0)
 {
 #  if __powerpc__
 #    if ABI_ELFv2
@@ -3180,7 +3180,7 @@ _calli(jit_state_t *_jit, jit_word_t i0)
 #  if __ppc__
     jit_word_t         d;
 #  endif
-    jit_int32_t                reg;
+    int32_t            reg;
 #  if __ppc__
     d = (i0 - _jit->pc.w) & ~3;
     if (can_sign_extend_jump_p(d))
@@ -3200,7 +3200,7 @@ static jit_word_t
 _calli_p(jit_state_t *_jit, jit_word_t i0)
 {
     jit_word_t         w;
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     w = movi_p(rn(reg), i0);
     callr(rn(reg));
@@ -3210,7 +3210,7 @@ _calli_p(jit_state_t *_jit, jit_word_t i0)
 
 #  if __powerpc__
 /* order is not guaranteed to be sequential */
-static jit_int32_t save[] = {
+static int32_t save[] = {
     _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
     _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
 };
@@ -3223,7 +3223,7 @@ _prolog(jit_state_t *_jit, jit_node_t *node)
     jit_word_t         offset;
 
     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
-       jit_int32_t     frame = -_jitc->function->frame;
+       int32_t frame = -_jitc->function->frame;
        assert(_jitc->function->self.aoff >= frame);
        if (_jitc->function->assume_frame)
            return;
@@ -3340,7 +3340,7 @@ _epilog(jit_state_t *_jit, jit_node_t *node)
 }
 
 static void
-_vastart(jit_state_t *_jit, jit_int32_t r0)
+_vastart(jit_state_t *_jit, int32_t r0)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
 
@@ -3349,7 +3349,7 @@ _vastart(jit_state_t *_jit, jit_int32_t r0)
 }
 
 static void
-_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     assert(_jitc->function->self.call & jit_call_varargs);
 
@@ -3365,7 +3365,7 @@ _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t 
label)
 {
     jit_word_t          d;
     union {
-       jit_int32_t     *i;
+       int32_t *i;
        jit_word_t       w;
     } u;
     u.w = instr;
diff --git a/jit/ppc-fpu.c b/jit/ppc-fpu.c
index 8db839a..fa8a58c 100644
--- a/jit/ppc-fpu.c
+++ b/jit/ppc-fpu.c
@@ -117,25 +117,25 @@ static void _FXFL(jit_state_t*,int,int,int,int,int) 
maybe_unused;
 #  define STFSX(s,a,b)                 FX(31,s,a,b,663)
 #  define movr_f(r0,r1)                        movr_d(r0,r1)
 #  define movr_d(r0,r1)                        _movr_d(_jit,r0,r1)
-static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _movr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define movi_f(r0,i0)                        _movi_f(_jit,r0,i0)
-static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t*);
+static void _movi_f(jit_state_t*,int32_t,jit_float32_t*);
 #  define movi_d(r0,i0)                        _movi_d(_jit,r0,i0)
-static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t*);
+static void _movi_d(jit_state_t*,int32_t,jit_float64_t*);
 #  define extr_f(r0,r1)                        extr_d(r0,r1)
 #  define extr_d(r0,r1)                        _extr_d(_jit,r0,r1)
-static void _extr_d(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _extr_d(jit_state_t*,int32_t,jit_int32_t);
 #  define truncr_f(r0,r1)              truncr_d(r0,r1)
 #  define truncr_f_i(r0,r1)            truncr_d_i(r0,r1)
 #  define truncr_d_i(r0,r1)            _truncr_d_i(_jit,r0,r1)
-static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_d_i(jit_state_t*,int32_t,jit_int32_t);
 #  if __WORDSIZE == 32
 #    define truncr_d(r0,r1)            truncr_d_i(r0,r1)
 #  else
 #    define truncr_d(r0,r1)            truncr_d_l(r0,r1)
 #    define truncr_f_l(r0,r1)          truncr_d_l(r0,r1)
 #    define truncr_d_l(r0,r1)          _truncr_d_l(_jit,r0,r1)
-static void _truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
+static void _truncr_d_l(jit_state_t*,int32_t,jit_int32_t);
 #  endif
 #  define extr_d_f(r0,r1)              FRSP(r0,r1)
 #  define extr_f_d(r0,r1)              movr_d(r0,r1)
@@ -148,259 +148,259 @@ static void 
_truncr_d_l(jit_state_t*,jit_int32_t,jit_int32_t);
 #  define addr_f(r0,r1,r2)             FADDS(r0,r1,r2)
 #  define addr_d(r0,r1,r2)             FADD(r0,r1,r2)
 #  define addi_f(r0,r1,i0)             _addi_f(_jit,r0,r1,i0)
-static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _addi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define addi_d(r0,r1,i0)             _addi_d(_jit,r0,r1,i0)
-static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _addi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define subr_f(r0,r1,r2)             FSUBS(r0,r1,r2)
 #  define subi_f(r0,r1,i0)             _subi_f(_jit,r0,r1,i0)
-static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _subi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define subr_d(r0,r1,r2)             FSUB(r0,r1,r2)
 #  define subi_d(r0,r1,i0)             _subi_d(_jit,r0,r1,i0)
-static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _subi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define rsbr_f(r0,r1,r2)             subr_f(r0,r2,r1)
 #  define rsbi_f(r0,r1,i0)             _rsbi_f(_jit,r0,r1,i0)
-static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _rsbi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define rsbr_d(r0,r1,r2)             subr_d(r0,r2,r1)
 #  define rsbi_d(r0,r1,i0)             _rsbi_d(_jit,r0,r1,i0)
-static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _rsbi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define mulr_f(r0,r1,r2)             FMULS(r0,r1,r2)
 #  define muli_f(r0,r1,i0)             _muli_f(_jit,r0,r1,i0)
-static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _muli_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define mulr_d(r0,r1,r2)             FMUL(r0,r1,r2)
 #  define muli_d(r0,r1,i0)             _muli_d(_jit,r0,r1,i0)
-static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _muli_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define divr_f(r0,r1,r2)             FDIVS(r0,r1,r2)
 #  define divi_f(r0,r1,i0)             _divi_f(_jit,r0,r1,i0)
-static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _divi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define divr_d(r0,r1,r2)             FDIV(r0,r1,r2)
 #  define divi_d(r0,r1,i0)             _divi_d(_jit,r0,r1,i0)
-static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _divi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ltr_f(r0,r1,r2)              ltr_d(r0,r1,r2)
 #  define ltr_d(r0,r1,r2)              _ltr_d(_jit,r0,r1,r2)
-static void _ltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lti_f(r0,r1,i0)              _lti_f(_jit,r0,r1,i0)
-static void _lti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _lti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define lti_d(r0,r1,i0)              _lti_d(_jit,r0,r1,i0)
-static void _lti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _lti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ler_f(r0,r1,r2)              ler_d(r0,r1,r2)
 #  define ler_d(r0,r1,r2)              _ler_d(_jit,r0,r1,r2)
-static void _ler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ler_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define lei_f(r0,r1,i0)              _lei_f(_jit,r0,r1,i0)
-static void _lei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _lei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define lei_d(r0,r1,i0)              _lei_d(_jit,r0,r1,i0)
-static void _lei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _lei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define eqr_f(r0,r1,r2)              eqr_d(r0,r1,r2)
 #  define eqr_d(r0,r1,r2)              _eqr_d(_jit,r0,r1,r2)
-static void _eqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _eqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define eqi_f(r0,r1,i0)              _eqi_f(_jit,r0,r1,i0)
-static void _eqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _eqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define eqi_d(r0,r1,i0)              _eqi_d(_jit,r0,r1,i0)
-static void _eqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _eqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ger_f(r0,r1,r2)              ger_d(r0,r1,r2)
 #  define ger_d(r0,r1,r2)              _ger_d(_jit,r0,r1,r2)
-static void _ger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ger_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gei_f(r0,r1,i0)              _gei_f(_jit,r0,r1,i0)
-static void _gei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _gei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define gei_d(r0,r1,i0)              _gei_d(_jit,r0,r1,i0)
-static void _gei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _gei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define gtr_f(r0,r1,r2)              gtr_d(r0,r1,r2)
 #  define gtr_d(r0,r1,r2)              _gtr_d(_jit,r0,r1,r2)
-static void _gtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _gtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define gti_f(r0,r1,i0)              _gti_f(_jit,r0,r1,i0)
-static void _gti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _gti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define gti_d(r0,r1,i0)              _gti_d(_jit,r0,r1,i0)
-static void _gti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _gti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ner_f(r0,r1,r2)              ner_d(r0,r1,r2)
 #  define ner_d(r0,r1,r2)              _ner_d(_jit,r0,r1,r2)
-static void _ner_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ner_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define nei_f(r0,r1,i0)              _nei_f(_jit,r0,r1,i0)
-static void _nei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _nei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define nei_d(r0,r1,i0)              _nei_d(_jit,r0,r1,i0)
-static void _nei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _nei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unltr_f(r0,r1,r2)            unltr_d(r0,r1,r2)
 #  define unltr_d(r0,r1,r2)            _unltr_d(_jit,r0,r1,r2)
-static void _unltr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unltr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unlti_f(r0,r1,i0)            _unlti_f(_jit,r0,r1,i0)
-static void _unlti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unlti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unlti_d(r0,r1,i0)            _unlti_d(_jit,r0,r1,i0)
-static void _unlti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unlti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unler_f(r0,r1,r2)            unler_d(r0,r1,r2)
 #  define unler_d(r0,r1,r2)            _unler_d(_jit,r0,r1,r2)
-static void _unler_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unler_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unlei_f(r0,r1,i0)            _unlei_f(_jit,r0,r1,i0)
-static void _unlei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unlei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unlei_d(r0,r1,i0)            _unlei_d(_jit,r0,r1,i0)
-static void _unlei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unlei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define uneqr_f(r0,r1,r2)            uneqr_d(r0,r1,r2)
 #  define uneqr_d(r0,r1,r2)            _uneqr_d(_jit,r0,r1,r2)
-static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _uneqr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define uneqi_f(r0,r1,i0)            _uneqi_f(_jit,r0,r1,i0)
-static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _uneqi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define uneqi_d(r0,r1,i0)            _uneqi_d(_jit,r0,r1,i0)
-static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _uneqi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unger_f(r0,r1,r2)            unger_d(r0,r1,r2)
 #  define unger_d(r0,r1,r2)            _unger_d(_jit,r0,r1,r2)
-static void _unger_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unger_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ungei_f(r0,r1,i0)            _ungei_f(_jit,r0,r1,i0)
-static void _ungei_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ungei_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ungei_d(r0,r1,i0)            _ungei_d(_jit,r0,r1,i0)
-static void _ungei_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ungei_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ungtr_f(r0,r1,r2)            ungtr_d(r0,r1,r2)
 #  define ungtr_d(r0,r1,r2)            _ungtr_d(_jit,r0,r1,r2)
-static void _ungtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ungtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ungti_f(r0,r1,i0)            _ungti_f(_jit,r0,r1,i0)
-static void _ungti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ungti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ungti_d(r0,r1,i0)            _ungti_d(_jit,r0,r1,i0)
-static void _ungti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ungti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ltgtr_f(r0,r1,r2)            ltgtr_d(r0,r1,r2)
 #  define ltgtr_d(r0,r1,r2)            _ltgtr_d(_jit,r0,r1,r2)
-static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ltgtr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ltgti_f(r0,r1,i0)            _ltgti_f(_jit,r0,r1,i0)
-static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ltgti_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ltgti_d(r0,r1,i0)            _ltgti_d(_jit,r0,r1,i0)
-static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ltgti_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define ordr_f(r0,r1,r2)             ordr_d(r0,r1,r2)
 #  define ordr_d(r0,r1,r2)             _ordr_d(_jit,r0,r1,r2)
-static void _ordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ordi_f(r0,r1,i0)             _ordi_f(_jit,r0,r1,i0)
-static void _ordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _ordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define ordi_d(r0,r1,i0)             _ordi_d(_jit,r0,r1,i0)
-static void _ordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _ordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define unordr_f(r0,r1,r2)           unordr_d(r0,r1,r2)
 #  define unordr_d(r0,r1,r2)           _unordr_d(_jit,r0,r1,r2)
-static void _unordr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _unordr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define unordi_f(r0,r1,i0)           _unordi_f(_jit,r0,r1,i0)
-static void _unordi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t*);
+static void _unordi_f(jit_state_t*,int32_t,jit_int32_t,jit_float32_t*);
 #  define unordi_d(r0,r1,i0)           _unordi_d(_jit,r0,r1,i0)
-static void _unordi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t*);
+static void _unordi_d(jit_state_t*,int32_t,jit_int32_t,jit_float64_t*);
 #  define bltr_f(i0,r0,r1)             bltr_d(i0,r0,r1)
 #  define bltr_d(i0,r0,r1)             _bltr_d(_jit,i0,r0,r1)
-static jit_word_t _bltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blti_f(i0,r0,i1)             _blti_f(_jit,i0,r0,i1)
-static jit_word_t _blti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _blti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define blti_d(i0,r0,i1)             _blti_d(_jit,i0,r0,i1)
-static jit_word_t _blti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _blti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bler_f(i0,r0,r1)             bler_d(i0,r0,r1)
 #  define bler_d(i0,r0,r1)             _bler_d(_jit,i0,r0,r1)
-static jit_word_t _bler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bler_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define blei_f(i0,r0,i1)             _blei_f(_jit,i0,r0,i1)
-static jit_word_t _blei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _blei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define blei_d(i0,r0,i1)             _blei_d(_jit,i0,r0,i1)
-static jit_word_t _blei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _blei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define beqr_f(i0,r0,r1)             beqr_d(i0,r0,r1)
 #  define beqr_d(i0,r0,r1)             _beqr_d(_jit,i0,r0,r1)
-static jit_word_t _beqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _beqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define beqi_f(i0,r0,i1)             _beqi_f(_jit,i0,r0,i1)
-static jit_word_t _beqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _beqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define beqi_d(i0,r0,i1)             _beqi_d(_jit,i0,r0,i1)
-static jit_word_t _beqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _beqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bger_f(i0,r0,r1)             bger_d(i0,r0,r1)
 #  define bger_d(i0,r0,r1)             _bger_d(_jit,i0,r0,r1)
-static jit_word_t _bger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgei_f(i0,r0,i1)             _bgei_f(_jit,i0,r0,i1)
-static jit_word_t _bgei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bgei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bgei_d(i0,r0,i1)             _bgei_d(_jit,i0,r0,i1)
-static jit_word_t _bgei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bgei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bgtr_f(i0,r0,r1)             bgtr_d(i0,r0,r1)
 #  define bgtr_d(i0,r0,r1)             _bgtr_d(_jit,i0,r0,r1)
-static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bgti_f(i0,r0,i1)             _bgti_f(_jit,i0,r0,i1)
-static jit_word_t _bgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bgti_d(i0,r0,i1)             _bgti_d(_jit,i0,r0,i1)
-static jit_word_t _bgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bner_f(i0,r0,r1)             bner_d(i0,r0,r1)
 #  define bner_d(i0,r0,r1)             _bner_d(_jit,i0,r0,r1)
-static jit_word_t _bner_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bner_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bnei_f(i0,r0,i1)             _bnei_f(_jit,i0,r0,i1)
-static jit_word_t _bnei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bnei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bnei_d(i0,r0,i1)             _bnei_d(_jit,i0,r0,i1)
-static jit_word_t _bnei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bnei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bunltr_f(i0,r0,r1)           bunltr_d(i0,r0,r1)
 #  define bunltr_d(i0,r0,r1)           _bunltr_d(_jit,i0,r0,r1)
-static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunltr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunlti_f(i0,r0,i1)           _bunlti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunlti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunlti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bunlti_d(i0,r0,i1)           _bunlti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunlti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunlti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bunler_f(i0,r0,r1)           bunler_d(i0,r0,r1)
 #  define bunler_d(i0,r0,r1)           _bunler_d(_jit,i0,r0,r1)
-static jit_word_t _bunler_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunler_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunlei_f(i0,r0,i1)           _bunlei_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunlei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunlei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bunlei_d(i0,r0,i1)           _bunlei_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunlei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunlei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define buneqr_f(i0,r0,r1)           buneqr_d(i0,r0,r1)
 #  define buneqr_d(i0,r0,r1)           _buneqr_d(_jit,i0,r0,r1)
-static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define buneqi_f(i0,r0,i1)           _buneqi_f(_jit,i0,r0,i1)
-static jit_word_t 
_buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define buneqi_d(i0,r0,i1)           _buneqi_d(_jit,i0,r0,i1)
-static jit_word_t 
_buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bunger_f(i0,r0,r1)           bunger_d(i0,r0,r1)
 #  define bunger_d(i0,r0,r1)           _bunger_d(_jit,i0,r0,r1)
-static jit_word_t _bunger_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunger_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bungei_f(i0,r0,i1)           _bungei_f(_jit,i0,r0,i1)
-static jit_word_t 
_bungei_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bungei_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bungei_d(i0,r0,i1)           _bungei_d(_jit,i0,r0,i1)
-static jit_word_t 
_bungei_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bungei_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bungtr_f(i0,r0,r1)           bungtr_d(i0,r0,r1)
 #  define bungtr_d(i0,r0,r1)           _bungtr_d(_jit,i0,r0,r1)
-static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bungtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bungti_f(i0,r0,i1)           _bungti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bungti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bungti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bungti_d(i0,r0,i1)           _bungti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bungti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bungti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bltgtr_f(i0,r0,r1)           bltgtr_d(i0,r0,r1)
 #  define bltgtr_d(i0,r0,r1)           _bltgtr_d(_jit,i0,r0,r1)
-static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bltgti_f(i0,r0,i1)           _bltgti_f(_jit,i0,r0,i1)
-static jit_word_t 
_bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bltgti_d(i0,r0,i1)           _bltgti_d(_jit,i0,r0,i1)
-static jit_word_t 
_bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bordr_f(i0,r0,r1)            bordr_d(i0,r0,r1)
 #  define bordr_d(i0,r0,r1)            _bordr_d(_jit,i0,r0,r1)
-static jit_word_t _bordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bordr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bordi_f(i0,r0,i1)            _bordi_f(_jit,i0,r0,i1)
-static jit_word_t _bordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bordi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bordi_d(i0,r0,i1)            _bordi_d(_jit,i0,r0,i1)
-static jit_word_t _bordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bordi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define bunordr_f(i0,r0,r1)          bunordr_d(i0,r0,r1)
 #  define bunordr_d(i0,r0,r1)          _bunordr_d(_jit,i0,r0,r1)
-static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static jit_word_t _bunordr_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define bunordi_f(i0,r0,i1)          _bunordi_f(_jit,i0,r0,i1)
-static jit_word_t 
_bunordi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t*);
+static jit_word_t _bunordi_f(jit_state_t*,jit_word_t,int32_t,jit_float32_t*);
 #  define bunordi_d(i0,r0,i1)          _bunordi_d(_jit,i0,r0,i1)
-static jit_word_t 
_bunordi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t*);
+static jit_word_t _bunordi_d(jit_state_t*,jit_word_t,int32_t,jit_float64_t*);
 #  define ldr_f(r0,r1)                 LFSX(r0, _R0_REGNO, r1)
 #  define ldi_f(r0,i0)                 _ldi_f(_jit,r0,i0)
-static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_f(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_f(r0,r1,r2)             _ldxr_f(_jit,r0,r1,r2)
-static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_f(r0,r1,i0)             _ldxi_f(_jit,r0,r1,i0)
-static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_f(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_f(r0,r1)                 STFSX(r1, _R0_REGNO, r0)
 #  define sti_f(i0,r0)                 _sti_f(_jit,i0,r0)
-static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_f(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_f(r0,r1,r2)             _stxr_f(_jit,r0,r1,r2)
-static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_f(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_f(i0,r0,r1)             _stxi_f(_jit,i0,r0,r1)
-static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_f(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define ldr_d(r0,r1)                 LFDX(r0, _R0_REGNO, r1)
 #  define ldi_d(r0,i0)                 _ldi_d(_jit,r0,i0)
-static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
+static void _ldi_d(jit_state_t*,int32_t,jit_word_t);
 #  define ldxr_d(r0,r1,r2)             _ldxr_d(_jit,r0,r1,r2)
-static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _ldxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define ldxi_d(r0,r1,i0)             _ldxi_d(_jit,r0,r1,i0)
-static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
+static void _ldxi_d(jit_state_t*,int32_t,jit_int32_t,jit_word_t);
 #  define str_d(r0,r1)                 STFDX(r1, _R0_REGNO, r0)
 #  define sti_d(i0,r0)                 _sti_d(_jit,i0,r0)
-static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
+static void _sti_d(jit_state_t*,jit_word_t,int32_t);
 #  define stxr_d(r0,r1,r2)             _stxr_d(_jit,r0,r1,r2)
-static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
+static void _stxr_d(jit_state_t*,int32_t,jit_int32_t,jit_int32_t);
 #  define stxi_d(i0,r0,r1)             _stxi_d(_jit,i0,r0,r1)
-static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
+static void _stxi_d(jit_state_t*,jit_word_t,int32_t,jit_int32_t);
 #  define vaarg_d(r0, r1)              _vaarg_d(_jit, r0, r1)
-static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
+static void _vaarg_d(jit_state_t*, int32_t, jit_int32_t);
 #endif
 
 #if CODE
@@ -430,20 +430,20 @@ _FXFL(jit_state_t *_jit, int o, int m, int b, int x, int 
r)
 }
 
 static void
-_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_movr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     if (r0 != r1)
        FMR(r0,r1);
 }
 
 static void
-_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
+_movi_f(jit_state_t *_jit, int32_t r0, jit_float32_t *i0)
 {
     union {
-       jit_int32_t      i;
+       int32_t  i;
        jit_float32_t    f;
     } data;
-    jit_int32_t                 reg;
+    int32_t             reg;
 
     if (_jitc->no_data) {
        data.f = *i0;
@@ -458,14 +458,14 @@ _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t 
*i0)
 }
 
 static void
-_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
+_movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t *i0)
 {
     union {
-       jit_int32_t      i[2];
+       int32_t  i[2];
        jit_word_t       w;
        jit_float64_t    d;
     } data;
-    jit_int32_t                 reg;
+    int32_t             reg;
 
     if (_jitc->no_data) {
        data.d = *i0;
@@ -488,10 +488,10 @@ _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t 
*i0)
 
 /* should only work on newer ppc (fcfid is a ppc64 instruction) */
 static void
-_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_extr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
 #  if __WORDSIZE == 32
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_gpr);
     rshi(rn(reg), r1, 31);
     /* use reserved 8 bytes area */
@@ -506,9 +506,9 @@ _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 }
 
 static void
-_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_d_i(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     FCTIWZ(rn(reg), r1);
     /* use reserved 8 bytes area */
@@ -519,9 +519,9 @@ _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1)
 
 #  if __WORDSIZE == 64
 static void
-_truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_truncr_d_l(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     reg = jit_get_reg(jit_class_fpr);
     FCTIDZ(rn(reg), r1);
     /* use reserved 8 bytes area */
@@ -534,10 +534,10 @@ _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, 
jit_int32_t r1)
 #  define fpr_opi(name, type, size)                                    \
 static void                                                            \
 _##name##i_##type(jit_state_t *_jit,                                   \
-                 jit_int32_t r0, jit_int32_t r1,                       \
+                 int32_t r0, jit_int32_t r1,                   \
                  jit_float##size##_t *i0)                              \
 {                                                                      \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr);               
\
+    int32_t            reg = jit_get_reg(jit_class_fpr);               \
     movi_##type(rn(reg), i0);                                          \
     name##r_##type(r0, r1, rn(reg));                                   \
     jit_unget_reg(reg);                                                        
\
@@ -545,11 +545,11 @@ _##name##i_##type(jit_state_t *_jit,                      
                \
 #  define fpr_bopi(name, type, size)                                   \
 static jit_word_t                                                      \
 _b##name##i_##type(jit_state_t *_jit,                                  \
-                 jit_word_t i0, jit_int32_t r0,                        \
+                 jit_word_t i0, int32_t r0,                    \
                  jit_float##size##_t *i1)                              \
 {                                                                      \
     jit_word_t         word;                                           \
-    jit_int32_t                reg = jit_get_reg(jit_class_fpr|                
\
+    int32_t            reg = jit_get_reg(jit_class_fpr|                \
                                          jit_class_nospill);           \
     movi_##type(rn(reg), i1);                                          \
     word = b##name##r_##type(i0, r0, rn(reg));                         \
@@ -573,7 +573,7 @@ fopi(div)
 dopi(div)
 
 static void
-_ltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPO(CR_0, r1, r2);
     MFCR(r0);
@@ -583,7 +583,7 @@ fopi(lt)
 dopi(lt)
 
 static void
-_ler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ler_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPO(CR_0, r1, r2);
     CREQV(CR_GT, CR_GT, CR_UN);
@@ -594,7 +594,7 @@ fopi(le)
 dopi(le)
 
 static void
-_eqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_eqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPO(CR_0, r1, r2);
     MFCR(r0);
@@ -604,7 +604,7 @@ fopi(eq)
 dopi(eq)
 
 static void
-_ger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ger_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPO(CR_0, r1, r2);
     CREQV(CR_LT, CR_LT, CR_UN);
@@ -615,7 +615,7 @@ fopi(ge)
 dopi(ge)
 
 static void
-_gtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_gtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPO(CR_0, r1, r2);
     MFCR(r0);
@@ -625,7 +625,7 @@ fopi(gt)
 dopi(gt)
 
 static void
-_ner_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ner_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPO(CR_0, r1, r2);
     CRNOT(CR_EQ, CR_EQ);
@@ -636,7 +636,7 @@ fopi(ne)
 dopi(ne)
 
 static void
-_unltr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unltr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPU(CR_0, r1, r2);
     CROR(CR_LT, CR_LT, CR_UN);
@@ -647,7 +647,7 @@ fopi(unlt)
 dopi(unlt)
 
 static void
-_unler_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unler_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPU(CR_0, r1, r2);
     CRNOT(CR_GT, CR_GT);
@@ -658,7 +658,7 @@ fopi(unle)
 dopi(unle)
 
 static void
-_uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_uneqr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPU(CR_0, r1, r2);
     CROR(CR_EQ, CR_EQ, CR_UN);
@@ -669,7 +669,7 @@ fopi(uneq)
 dopi(uneq)
 
 static void
-_unger_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unger_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPU(CR_0, r1, r2);
     CRNOT(CR_LT, CR_LT);
@@ -680,7 +680,7 @@ fopi(unge)
 dopi(unge)
 
 static void
-_ungtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ungtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPU(CR_0, r1, r2);
     CROR(CR_GT, CR_GT, CR_UN);
@@ -691,7 +691,7 @@ fopi(ungt)
 dopi(ungt)
 
 static void
-_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ltgtr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPU(CR_0, r1, r2);
     CROR(CR_GT, CR_GT, CR_LT);
@@ -702,7 +702,7 @@ fopi(ltgt)
 dopi(ltgt)
 
 static void
-_ordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPU(CR_0, r1, r2);
     CRNOT(CR_UN, CR_UN);
@@ -713,7 +713,7 @@ fopi(ord)
 dopi(ord)
 
 static void
-_unordr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_unordr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
     FCMPU(CR_0, r1, r2);
     MFCR(r0);
@@ -723,7 +723,7 @@ fopi(unord)
 dopi(unord)
 
 static jit_word_t
-_bltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPO(CR_0, r0, r1);
@@ -736,7 +736,7 @@ fbopi(lt)
 dbopi(lt)
 
 static jit_word_t
-_bler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bler_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPO(CR_0, r0, r1);
@@ -750,7 +750,7 @@ fbopi(le)
 dbopi(le)
 
 static jit_word_t
-_beqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_beqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPO(CR_0, r0, r1);
@@ -763,7 +763,7 @@ fbopi(eq)
 dbopi(eq)
 
 static jit_word_t
-_bger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bger_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPO(CR_0, r0, r1);
@@ -777,7 +777,7 @@ fbopi(ge)
 dbopi(ge)
 
 static jit_word_t
-_bgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPO(CR_0, r0, r1);
@@ -790,7 +790,7 @@ fbopi(gt)
 dbopi(gt)
 
 static jit_word_t
-_bner_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bner_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPO(CR_0, r0, r1);
@@ -803,7 +803,7 @@ fbopi(ne)
 dbopi(ne)
 
 static jit_word_t
-_bunltr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunltr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPU(CR_0, r0, r1);
@@ -817,7 +817,7 @@ fbopi(unlt)
 dbopi(unlt)
 
 static jit_word_t
-_bunler_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunler_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPU(CR_0, r0, r1);
@@ -830,7 +830,7 @@ fbopi(unle)
 dbopi(unle)
 
 static jit_word_t
-_buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_buneqr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPU(CR_0, r0, r1);
@@ -844,7 +844,7 @@ fbopi(uneq)
 dbopi(uneq)
 
 static jit_word_t
-_bunger_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunger_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPU(CR_0, r0, r1);
@@ -857,7 +857,7 @@ fbopi(unge)
 dbopi(unge)
 
 static jit_word_t
-_bungtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bungtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPU(CR_0, r0, r1);
@@ -871,7 +871,7 @@ fbopi(ungt)
 dbopi(ungt)
 
 static jit_word_t
-_bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bltgtr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPU(CR_0, r0, r1);
@@ -885,7 +885,7 @@ fbopi(ltgt)
 dbopi(ltgt)
 
 static jit_word_t
-_bordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bordr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPU(CR_0, r0, r1);
@@ -898,7 +898,7 @@ fbopi(ord)
 dbopi(ord)
 
 static jit_word_t
-_bunordr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_bunordr_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
     jit_word_t         d, w;
     FCMPU(CR_0, r0, r1);
@@ -911,16 +911,16 @@ fbopi(unord)
 dbopi(unord)
 
 static void
-_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LFS(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -937,16 +937,16 @@ _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
+_ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        LFD(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -963,9 +963,9 @@ _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 }
 
 static void
-_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LFSX(r0, r2, r1);
@@ -981,9 +981,9 @@ _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_ldxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r1 == _R0_REGNO) {
        if (r2 != _R0_REGNO)
            LFDX(r0, r2, r1);
@@ -999,9 +999,9 @@ _ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, 
jit_int32_t r2)
 }
 
 static void
-_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_f(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -1023,9 +1023,9 @@ _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
+_ldxi_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_word_t i0)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        ldr_d(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -1047,16 +1047,16 @@ _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_word_t i0)
 }
 
 static void
-_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        STFS(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -1073,16 +1073,16 @@ _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
+_sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
 {
     jit_bool_t         inv;
-    jit_int32_t                reg;
+    int32_t            reg;
     jit_word_t         lo, hi;
     if (can_sign_extend_short_p(i0))
        STFD(r0, _R0_REGNO, i0);
     else if (can_sign_extend_int_p(i0)) {
-       hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
-       lo = (jit_int16_t)(i0 - (hi << 16));
+       hi = (int16_t)((i0 >> 16) + ((uint16_t)i0 >> 15));
+       lo = (int16_t)(i0 - (hi << 16));
        reg = jit_get_reg(jit_class_gpr);
        if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
        LIS(rn(reg), hi);
@@ -1099,9 +1099,9 @@ _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
 }
 
 static void
-_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_f(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == _R0_REGNO) {
        if (r1 != _R0_REGNO)
            STFSX(r2, r1, r0);
@@ -1117,9 +1117,9 @@ _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
+_stxr_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1, jit_int32_t r2)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (r0 == _R0_REGNO) {
        if (r1 != _R0_REGNO)
            STFDX(r2, r1, r0);
@@ -1135,9 +1135,9 @@ _stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t 
r1, jit_int32_t r2)
 }
 
 static void
-_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        str_f(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -1159,9 +1159,9 @@ _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
+_stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, jit_int32_t r1)
 {
-    jit_int32_t                reg;
+    int32_t            reg;
     if (i0 == 0)
        str_d(r0, r1);
     else if (can_sign_extend_short_p(i0)) {
@@ -1183,7 +1183,7 @@ _stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, 
jit_int32_t r1)
 }
 
 static void
-_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
+_vaarg_d(jit_state_t *_jit, int32_t r0, jit_int32_t r1)
 {
     /* Load argument. */
     ldr_d(r0, r1);
diff --git a/jit/ppc.c b/jit/ppc.c
index c43b074..2a2ccee 100644
--- a/jit/ppc.c
+++ b/jit/ppc.c
@@ -25,9 +25,9 @@
 #  define I_DISP                       0
 #  define F_DISP                       0
 #else
-#  define C_DISP                       (__WORDSIZE >> 3) - sizeof(jit_int8_t)
-#  define S_DISP                       (__WORDSIZE >> 3) - sizeof(jit_int16_t)
-#  define I_DISP                       (__WORDSIZE >> 3) - sizeof(jit_int32_t)
+#  define C_DISP                       (__WORDSIZE >> 3) - sizeof(int8_t)
+#  define S_DISP                       (__WORDSIZE >> 3) - sizeof(int16_t)
+#  define I_DISP                       (__WORDSIZE >> 3) - sizeof(int32_t)
 #  define F_DISP                       (__WORDSIZE >> 3) - 
sizeof(jit_float32_t)
 #endif
 
@@ -145,7 +145,7 @@ _jit_init(jit_state_t *_jit)
 void
 _jit_prolog(jit_state_t *_jit)
 {
-    jit_int32_t                 offset;
+    int32_t             offset;
 
     if (_jitc->function)
        jit_epilog();
@@ -166,7 +166,7 @@ _jit_prolog(jit_state_t *_jit)
     _jitc->function->self.aoff = alloca_offset - 8;
     _jitc->function->self.call = jit_call_default;
     jit_alloc((jit_pointer_t *)&_jitc->function->regoff,
-             _jitc->reglen * sizeof(jit_int32_t));
+             _jitc->reglen * sizeof(int32_t));
 
     /* _no_link here does not mean the jit_link() call can be removed
      * by rewriting as:
@@ -185,8 +185,8 @@ _jit_prolog(jit_state_t *_jit)
     jit_regset_new(&_jitc->function->regset);
 }
 
-jit_int32_t
-_jit_allocai(jit_state_t *_jit, jit_int32_t length)
+int32_t
+_jit_allocai(jit_state_t *_jit, int32_t length)
 {
     assert(_jitc->function);
     switch (length) {
@@ -204,13 +204,13 @@ _jit_allocai(jit_state_t *_jit, jit_int32_t length)
 }
 
 void
-_jit_allocar(jit_state_t *_jit, jit_int32_t u, jit_int32_t v)
+_jit_allocar(jit_state_t *_jit, int32_t u, jit_int32_t v)
 {
-    jit_int32_t                 r0, r1;
+    int32_t             r0, r1;
     assert(_jitc->function);
     jit_inc_synth_ww(allocar, u, v);
     if (!_jitc->function->allocar) {
-       _jitc->function->aoffoff = jit_allocai(sizeof(jit_int32_t));
+       _jitc->function->aoffoff = jit_allocai(sizeof(int32_t));
        _jitc->function->allocar = 1;
     }
     r0 = jit_get_reg(jit_class_gpr);
@@ -241,7 +241,7 @@ _jit_ret(jit_state_t *_jit)
 }
 
 void
-_jit_retr(jit_state_t *_jit, jit_int32_t u)
+_jit_retr(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr, u);
     if (JIT_RET != u)
@@ -261,7 +261,7 @@ _jit_reti(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_retr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_f(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_f, u);
     if (JIT_RET != u)
@@ -282,7 +282,7 @@ _jit_reti_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_retr_d(jit_state_t *_jit, jit_int32_t u)
+_jit_retr_d(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(retr_d, u);
     if (JIT_FRET != u)
@@ -341,7 +341,7 @@ _jit_ellipsis(jit_state_t *_jit)
 }
 
 void
-_jit_va_push(jit_state_t *_jit, jit_int32_t u)
+_jit_va_push(jit_state_t *_jit, int32_t u)
 {
     jit_inc_synth_w(va_push, u);
     jit_pushargr(u);
@@ -352,7 +352,7 @@ jit_node_t *
 _jit_arg(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     if (jit_arg_reg_p(_jitc->function->self.argi))
        offset = _jitc->function->self.argi++;
@@ -369,7 +369,7 @@ jit_node_t *
 _jit_arg_f(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     if (jit_arg_f_reg_p(_jitc->function->self.argf))
        offset = _jitc->function->self.argf++;
@@ -393,7 +393,7 @@ jit_node_t *
 _jit_arg_d(jit_state_t *_jit)
 {
     jit_node_t         *node;
-    jit_int32_t                 offset;
+    int32_t             offset;
     assert(_jitc->function);
     if (jit_arg_f_reg_p(_jitc->function->self.argf))
        offset = _jitc->function->self.argf++;
@@ -414,7 +414,7 @@ _jit_arg_d(jit_state_t *_jit)
 }
 
 void
-_jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_c(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_c, u, v);
@@ -426,7 +426,7 @@ _jit_getarg_c(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_uc(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_uc, u, v);
@@ -438,7 +438,7 @@ _jit_getarg_uc(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_s(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_s, u, v);
@@ -450,7 +450,7 @@ _jit_getarg_s(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_us(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_us, u, v);
@@ -462,7 +462,7 @@ _jit_getarg_us(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_i(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_i, u, v);
@@ -480,7 +480,7 @@ _jit_getarg_i(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 
 #if __WORDSIZE == 64
 void
-_jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_ui(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_ui, u, v);
@@ -492,7 +492,7 @@ _jit_getarg_ui(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_l(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(getarg_l, u, v);
@@ -505,7 +505,7 @@ _jit_getarg_l(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 #endif
 
 void
-_jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg);
     jit_inc_synth_wp(putargr, u, v);
@@ -519,7 +519,7 @@ _jit_putargr(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     jit_inc_synth_wp(putargi, u, v);
     assert(v->code == jit_code_arg);
     if (jit_arg_reg_p(v->u.w))
@@ -534,7 +534,7 @@ _jit_putargi(jit_state_t *_jit, jit_word_t u, jit_node_t *v)
 }
 
 void
-_jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(getarg_f, u, v);
@@ -546,7 +546,7 @@ _jit_getarg_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_f(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_wp(putargr_f, u, v);
@@ -560,7 +560,7 @@ _jit_putargr_f(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_f);
     jit_inc_synth_fp(putargi_f, u, v);
     if (jit_arg_f_reg_p(v->u.w))
@@ -575,7 +575,7 @@ _jit_putargi_f(jit_state_t *_jit, jit_float32_t u, 
jit_node_t *v)
 }
 
 void
-_jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_getarg_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(getarg_d, u, v);
@@ -587,7 +587,7 @@ _jit_getarg_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 }
 
 void
-_jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t *v)
+_jit_putargr_d(jit_state_t *_jit, int32_t u, jit_node_t *v)
 {
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_wp(putargr_d, u, v);
@@ -601,7 +601,7 @@ _jit_putargr_d(jit_state_t *_jit, jit_int32_t u, jit_node_t 
*v)
 void
 _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, jit_node_t *v)
 {
-    jit_int32_t                regno;
+    int32_t            regno;
     assert(v->code == jit_code_arg_d);
     jit_inc_synth_dp(putargi_d, u, v);
     if (jit_arg_f_reg_p(v->u.w))
@@ -616,7 +616,7 @@ _jit_putargi_d(jit_state_t *_jit, jit_float64_t u, 
jit_node_t *v)
 }
 
 void
-_jit_pushargr(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr, u);
@@ -634,7 +634,7 @@ _jit_pushargr(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_w(pushargi, u);
     jit_link_prepare();
@@ -653,7 +653,7 @@ _jit_pushargi(jit_state_t *_jit, jit_word_t u)
 }
 
 void
-_jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
+_jit_pushargr_f(jit_state_t *_jit, int32_t u)
 {
     assert(_jitc->function);
     jit_inc_synth_w(pushargr_f, u);
@@ -699,7 +699,7 @@ _jit_pushargr_f(jit_state_t *_jit, jit_int32_t u)
 void
 _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 {
-    jit_int32_t                 regno;
+    int32_t             regno;
     assert(_jitc->function);
     jit_inc_synth_f(pushargi_f, u);
     jit_link_prepare();
@@ -745,7 +745,7 @@ _jit_pushargi_f(jit_state_t *_jit, jit_float32_t u)
 }
 
 void
-_jit_pushargr_d(jit