deps/lightning/lib/jit_hppa-cpu.c

   1 /*
   2  * Copyright (C) 2013-2023  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 typedef struct idiv {
  22     int                 quo;
  23     int                 rem;
  24 } idiv_t;
  25
  26 typedef struct udiv {
  27     unsigned int        quo;
  28     unsigned int        rem;
  29 } udiv_t;
  30
  31 #define jit_imm_idx_p()         jit_cpu.imm_idx
  32
  33 /* 16 spill bytes; -52 for first actual stack argument */
  34 #define params_offset           -32
  35 /* Assume all callee save registers may need to be spilled */
  36 #define alloca_offset           192
  37 #define _R0_REGNO               0
  38 #define _R1_REGNO               1
  39 #define _RP_REGNO               2
  40 #define _FP_REGNO               3
  41 #define _R19_REGNO              19
  42 #define _R23_REGNO              23
  43 #define _R24_REGNO              24
  44 #define _R25_REGNO              25
  45 #define _R26_REGNO              26
  46 #define _R28_REGNO              28
  47 #define _R29_REGNO              29
  48 #define _SP_REGNO               30
  49 #define _R31_REGNO              31
  50 #define _CR11_REGNO             11
  51 #define ii(v)                   *_jit->pc.ui++ = v
  52 #define ldr(r0,r1)              ldr_ui(r0,r1)
  53 #define ldi(r0,i0)              ldi_ui(r0,i0)
  54 #define ldxr(r0,r1,r2)          ldxr_ui(r0,r1,r2)
  55 #define ldxi(r0,r1,i0)          ldxi_ui(r0,r1,i0)
  56 #define str(r0,r1)              str_i(r0,r1)
  57 #define sti(i0,r0)              sti_i(i0,r0)
  58 #define stxr(r0,r1,r2)          stxr_i(r0,r1,r2)
  59 #define stxi(i0,r0,r1)          stxi_i(i0,r0,r1)
  60 #define f1(o,b,t,i)                     _f1(_jit,o,b,t,i)
  61 static void _f1(jit_state_t*,jit_int32_t,
  62                 jit_int32_t,jit_int32_t,jit_int32_t);
  63 #define f2(o,b,r,i,j)                   _f2(_jit,o,b,r,i,j)
  64 static void _f2(jit_state_t*,jit_int32_t,jit_int32_t,
  65                 jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
  66 #define f3(o,b,t,i,j)                   _f3(_jit,o,b,t,i,j)
  67 static void _f3(jit_state_t*,jit_int32_t,jit_int32_t,
  68                 jit_int32_t,jit_int32_t,jit_int32_t);
  69 #define f4(o,b,x,s,u,y,c,z,m,t)         _f4(_jit,o,b,x,s,u,y,c,z,m,t)
  70 static void _f4(jit_state_t*,jit_int32_t,jit_int32_t,
  71                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  72                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  73 #define f5(o,b,i,s,a,y,c,z,m,t)         _f5(_jit,o,b,i,s,a,y,c,z,m,t)
  74 static void _f5(jit_state_t*,jit_int32_t,jit_int32_t,
  75                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  76                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  77 #define f6(o,b,r,s,a,x,c,y,m,i)         _f6(_jit,o,b,r,s,a,x,c,y,m,i)
  78 static void _f6(jit_state_t*,jit_int32_t,jit_int32_t,
  79                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  80                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  81 #define f7(o,r,i)                       _f7(_jit,o,r,i)
  82 static void _f7(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
  83 #define f8(o,r2,r1,cf,e1,x,e2,y,d,t)    _f8(_jit,o,r2,r1,cf,e1,x,e2,y,d,t)
  84 static void _f8(jit_state_t*,jit_int32_t,
  85                 jit_int32_t,jit_int32_t,jit_int32_t,
  86                 jit_int32_t,jit_int32_t,jit_int32_t,
  87                 jit_int32_t,jit_int32_t,jit_int32_t);
  88 #define f9(o,r,t,cf,e1,im)              _f9(_jit,o,r,t,cf,e1,im)
  89 static void _f9(jit_state_t*,
  90                 jit_int32_t,jit_int32_t,jit_int32_t,
  91                 jit_int32_t,jit_int32_t,jit_int32_t);
  92 #define f10(o,r2,r1,u,v,w,x,sa,y,t)     _f10(_jit,o,r2,r1,u,v,w,x,sa,y,t)
  93 static void _f10(jit_state_t*,jit_int32_t,jit_int32_t,
  94                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  95                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
  96 #define f11(o,r2,r1,c,x,y,z,u,t)        _f11(_jit,o,r2,r1,c,x,y,z,u,t)
  97 static void _f11(jit_state_t*,jit_int32_t,
  98                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
  99                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 100 #define f12(o,r,t,c,x,se,y,c1,z,clen)   _f12(_jit,o,r,t,c,x,se,y,c1,z,clen)
 101 static void _f12(jit_state_t*,jit_int32_t,jit_int32_t,
 102                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
 103                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 104 #define f13(o,t,r,c,x,nz,c1,clen)       _f13(_jit,o,t,r,c,x,nz,c1,clen)
 105 static void _f13(jit_state_t*,jit_int32_t,jit_int32_t,
 106                  jit_int32_t,jit_int32_t,jit_int32_t,
 107                  jit_int32_t,jit_int32_t,jit_int32_t);
 108 #define f13x(o,t,i,c,x,nz,c1,clen)      _f13x(_jit,o,t,i,c,x,nz,c1,clen)
 109 static void _f13x(jit_state_t*,jit_int32_t,jit_int32_t,
 110                   jit_int32_t,jit_int32_t,jit_int32_t,
 111                   jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 112 #define f14(o,r2,r1,c,x,cp,y,cpos,t)    _f14(_jit,o,r2,r1,c,x,cp,y,cpos,t)
 113 static void _f14(jit_state_t*,jit_int32_t,
 114                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
 115                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 116 #define f15(o,r,t,c,c1,p,se,pos,clen)   _f15(_jit,o,r,t,c,c1,p,se,pos,clen)
 117 static void _f15(jit_state_t*,jit_int32_t,
 118                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
 119                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 120 #define f16(o,t,r,c,c1,cp,nz,cpos,clen) _f16(_jit,o,t,r,c,c1,cp,nz,cpos,clen)
 121 static void _f16(jit_state_t*,jit_int32_t,
 122                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
 123                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 124 #define f16x(o,t,i,c,c1,cp,nz,cpos,clen) _f16x(_jit,o,t,i,c,c1,cp,nz,cpos,clen)
 125 static void _f16x(jit_state_t*,jit_int32_t,
 126                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
 127                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 128 #define f17(o,r2,r1,c,i,n)              _f17(_jit,o,r2,r1,c,i,n)
 129 static void _f17(jit_state_t*,jit_int32_t,jit_int32_t,
 130                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 131 #define f17x(o,r2,r1,c,i,n)             _f17x(_jit,o,r2,r1,c,i,n)
 132 static void _f17x(jit_state_t*,jit_int32_t,jit_int32_t,
 133                   jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 134 #define f18(o,p,r,c,i,n)                _f18(_jit,o,p,r,c,i,n)
 135 static void _f18(jit_state_t*,jit_int32_t,jit_int32_t,
 136                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 137 #define f19(o,b,s,i,n)                  _f19(_jit,o,b,s,i,n)
 138 static void _f19(jit_state_t*,jit_int32_t,jit_int32_t,
 139                  jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 140 #define f20(o,t,i,g,n)                  _f20(_jit,o,t,i,g,n)
 141 static void _f20(jit_state_t*,jit_int32_t,jit_int32_t,
 142                 jit_int32_t,jit_int32_t,jit_int32_t);
 143 #define f21(o,t,x,y,n)                  _f21(_jit,o,t,x,y,n)
 144 static void _f21(jit_state_t*,jit_int32_t,jit_int32_t,
 145                 jit_int32_t,jit_int32_t,jit_int32_t);
 146 #define f22(o,b,x,r,n,p)                _f22(_jit,o,b,x,r,n,p)
 147 static void _f22(jit_state_t*,jit_int32_t,jit_int32_t,
 148                 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 149 #define f23(o,a,b,c,d,e,f,g,h)          _f23(_jit,o,a,b,c,d,e,f,g,h)
 150 static void _f23(jit_state_t*,jit_int32_t,
 151                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
 152                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 153 #define f24(o,b,x,s,y,m,r)              _f24(_jit,o,b,x,s,y,m,r)
 154 static void _f24(jit_state_t*,jit_int32_t,
 155                  jit_int32_t,jit_int32_t,jit_int32_t,
 156                  jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 157 #define f25(o,b,i,s,y,m,r)              _f25(_jit,o,b,i,s,y,m,r)
 158 static void _f25(jit_state_t*,jit_int32_t,
 159                  jit_int32_t,jit_int32_t,jit_int32_t,
 160                  jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 161 #define f26(o,b,x,s,y,m,r)              _f26(_jit,o,b,x,s,y,m,r)
 162 static void _f26(jit_state_t*,jit_int32_t,
 163                  jit_int32_t,jit_int32_t,jit_int32_t,
 164                  jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 165 #define f27(o,i,j)                      _f27(_jit,o,i,j)
 166 static void _f27(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 167 #define f28(o,i)                        _f28(_jit,o,i)
 168 static void _f28(jit_state_t*,jit_int32_t,jit_int32_t) maybe_unused;
 169 #define f29(o,r,x,s,y,t)                _f29(_jit,o,r,x,s,y,t)
 170 static void _f29(jit_state_t*,jit_int32_t,jit_int32_t,
 171                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 172 #define f30(o,b,r,s,x,y,t)              _f30(_jit,o,b,r,s,x,y,t)
 173 static void _f30(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
 174                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 175 #define f31(o,t,r,v,x,y)                _f31(_jit,o,t,r,v,x,y)
 176 static void _f31(jit_state_t*,jit_int32_t,jit_int32_t,
 177                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 178 #define f33(o,x,r,y,z,u)                _f33(_jit,o,x,r,y,z,u)
 179 static void _f33(jit_state_t*,jit_int32_t,jit_int32_t,
 180                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 181 #define f34(o,o1,x,sf,n,o2)             _f34(_jit,o,o1,x,sf,n,o2)
 182 static void _f34(jit_state_t*,jit_int32_t,jit_int32_t,
 183                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 184 #define f35(o,op,x,sf,n,t)              _f35(_jit,o,op,x,sf,n,t)
 185 static void _f35(jit_state_t*,jit_int32_t,jit_int32_t,
 186                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 187 #define f36(o,r,o1,x,sf,n,o2)           _f36(_jit,o,r,o1,x,sf,n,o2)
 188 static void _f36(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
 189                  jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 190 #define f37(o,r2,r1,o1,x,sf,n,o2)       _f37(_jit,o,r2,r1,o1,x,sf,n,o2)
 191 static void _f37(jit_state_t*,jit_int32_t,jit_int32_t,
 192                  jit_int32_t,jit_int32_t,jit_int32_t,
 193                  jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 194 #define f38(o,s,u,n)                    _f38(_jit,o,s,u,n)
 195 static void _f38(jit_state_t*,jit_int32_t,
 196                  jit_int32_t,jit_int32_t,jit_int32_t) maybe_unused;
 197 /* nulify next instruction if condition is met with addition */
 198 #define ADD_CF_NV               0       /* never */
 199 #define ADD_CF_EQ               2       /* O1 == -O2 (word) */
 200 #define ADD_CF_LT               4       /* O1 <  -O2 (signed)*/
 201 #define ADD_CF_LE               6       /* O1 <= -O2 (signed) */
 202 #define ADD_CF_NUV              8       /* O1 +   O2 does not overflow (unsigned) */
 203 #define ADD_CF_ZNV              10      /* O1 +   O2 is zero or no overflow (unsigned) */
 204 #define ADD_CF_SV               12      /* O1 +   O2 overflows (signed) */
 205 #define ADD_CF_OD               14      /* O1 +   O2 is odd */
 206 #define ADD_CF_TR               1       /* always */
 207 #define ADD_CF_NE               3       /* O1 != -O2 */
 208 #define ADD_CF_GE               5       /* O1 >= -O2 (signed) */
 209 #define ADD_CF_GT               7       /* O1 >  -O2 (signed) */
 210 #define ADD_CF_UV               9       /* O1 +   O2 overflows (unsigned) */
 211 #define ADD_CF_VNZ              11      /* O1 +   O2 is nonzero and overflows (unsigned) */
 212 #define ADD_CF_NSV              13      /* O1 +   O2 does not overflow (signed) */
 213 #define ADD_CF_EV               15      /* O1 +   O2 is even */
 214 #define ADD_EN_NONE             6       /* none */
 215 #define ADD_EN_C                7       /* with carry */
 216 #define ADD_EN_L                10      /* logical */
 217 #define ADD_EN_TSV              12      /* trap on signed overflow */
 218 #define ADD_EN_C_TSV            13      /* with carry and trap on signed overflow */
 219 #define ADDI_OE_TC              0       /* trap on condition */
 220 #define ADDI_OE_TSV_TC          1       /* trap on signed overflow or condition */
 221 #define ADDI_OE_NONE            2       /* none */
 222 #define ADDI_OE_TSV             3       /* trap on signed overflow */
 223 #define ADD_(en,cf,r1,r2,t)     f8(0x2,r2,r1,cf,en>>2,1,en&1,0,0,t)
 224 #define ADD(r1,r2,t)            ADD_(ADD_EN_NONE,ADD_CF_NV,r1,r2,t)
 225 #define ADD_C(r1,r2,t)          ADD_(ADD_EN_C,ADD_CF_NV,r1,r2,t)
 226 #define ADD_L(r1,r2,t)          ADD_(ADD_EN_L,ADD_CF_NV,r1,r2,t)
 227 #define ADDB_(cc,r1,r2,t)       f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,0)
 228 #define ADDB(r1,r2,t)           ADDB_(ADD_CF_NV,r1,r2,t)
 229 #define ADDB_EQ(r1,r2,t)        ADDB_(ADD_CF_EQ,r1,r2,t)
 230 #define ADDB_LT(r1,r2,t)        ADDB_(ADD_CF_LT,r1,r2,t)
 231 #define ADDB_LE(r1,r2,t)        ADDB_(ADD_CF_LE,r1,r2,t)
 232 #define ADDB_NUV(r1,r2,t)       ADDB_(ADD_CF_NUV,r1,r2,t)
 233 #define ADDB_ZNV(r1,r2,t)       ADDB_(ADD_CF_ZNV,r1,r2,t)
 234 #define ADDB_SV(r1,r2,t)        ADDB_(ADD_CF_SV,r1,r2,t)
 235 #define ADDB_OD(r1,r2,t)        ADDB_(ADD_CF_OD,r1,r2,t)
 236 #define ADDB_TR(r1,r2,t)        ADDB_(ADD_CF_TR,r1,r2,t)
 237 #define ADDB_NE(r1,r2,t)        ADDB_(ADD_CF_NE,r1,r2,t)
 238 #define ADDB_GE(r1,r2,t)        ADDB_(ADD_CF_GE,r1,r2,t)
 239 #define ADDB_GT(r1,r2,t)        ADDB_(ADD_CF_GT,r1,r2,t)
 240 #define ADDB_UV(r1,r2,t)        ADDB_(ADD_CF_UV,r1,r2,t)
 241 #define ADDB_VNZ(r1,r2,t)       ADDB_(ADD_CF_VNZ,r1,r2,t)
 242 #define ADDB_NSV(r1,r2,t)       ADDB_(ADD_CF_NSV,r1,r2,t)
 243 #define ADDB_EV(r1,r2,t)        ADDB_(ADD_CF_EV,r2,r1,t)
 244 #define ADDB_N_(cc,r1,r2,t)     f17(0x28|((cc&1)<<1),r2,r1,cc>>1,t,1)
 245 #define ADDB_N(r1,r2,t)         ADDB_N_(ADD_CF_NV,r1,r2,t)
 246 #define ADDB_N_EQ(r1,r2,t)      ADDB_N_(ADD_CF_EQ,r1,r2,t)
 247 #define ADDB_N_LT(r1,r2,t)      ADDB_N_(ADD_CF_LT,r1,r2,t)
 248 #define ADDB_N_LE(r1,r2,t)      ADDB_N_(ADD_CF_LE,r1,r2,t)
 249 #define ADDB_N_NUV(r1,r2,t)     ADDB_N_(ADD_CF_NUV,r1,r2,t)
 250 #define ADDB_N_ZNV(r1,r2,t)     ADDB_N_(ADD_CF_ZNV,r1,r2,t)
 251 #define ADDB_N_SV(r1,r2,t)      ADDB_N_(ADD_CF_SV,r1,r2,t)
 252 #define ADDB_N_OD(r1,r2,t)      ADDB_N_(ADD_CF_OD,r1,r2,t)
 253 #define ADDB_N_TR(r1,r2,t)      ADDB_N_(ADD_CF_TR,r1,r2,t)
 254 #define ADDB_N_NE(r1,r2,t)      ADDB_N_(ADD_CF_NE,r1,r2,t)
 255 #define ADDB_N_GE(r1,r2,t)      ADDB_N_(ADD_CF_GE,r1,r2,t)
 256 #define ADDB_N_GT(r1,r2,t)      ADDB_N_(ADD_CF_GT,r1,r2,t)
 257 #define ADDB_N_UV(r1,r2,t)      ADDB_N_(ADD_CF_UV,r1,r2,t)
 258 #define ADDB_N_VNZ(r1,r2,t)     ADDB_N_(ADD_CF_VNZ,r1,r2,t)
 259 #define ADDB_N_NSV(r1,r2,t)     ADDB_N_(ADD_CF_NSV,r1,r2,t)
 260 #define ADDB_N_EV(r1,r2,t)      ADDB_N_(ADD_CF_EV,r1,r2,t)
 261 #define ADDI_(ec,cf,i,r,t)      f9(0x2c|(ec>>1),r,t,cf,ec&1,i)
 262 #define ADDI(i,r,t)             ADDI_(ADDI_OE_NONE,ADD_CF_NV,i,r,t)
 263 #define ADDIB_(cc,i,r,t)        f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,0)
 264 #define ADDIB(i,r,t)            ADDIB_(ADD_CF_NV,i,r,t)
 265 #define ADDIB_EQ(i,r,t)         ADDIB_(ADD_CF_EQ,i,r,t)
 266 #define ADDIB_LT(i,r,t)         ADDIB_(ADD_CF_LT,i,r,t)
 267 #define ADDIB_LE(i,r,t)         ADDIB_(ADD_CF_LE,i,r,t)
 268 #define ADDIB_NUV(i,r,t)        ADDIB_(ADD_CF_NUV,i,r,t)
 269 #define ADDIB_ZNV(i,r,t)        ADDIB_(ADD_CF_ZNV,i,r,t)
 270 #define ADDIB_SV(i,r,t)         ADDIB_(ADD_CF_SV,i,r,t)
 271 #define ADDIB_OD(i,r,t)         ADDIB_(ADD_CF_OD,i,r,t)
 272 #define ADDIB_TR(i,r,t)         ADDIB_(ADD_CF_TR,i,r,t)
 273 #define ADDIB_NE(i,r,t)         ADDIB_(ADD_CF_NE,i,r,t)
 274 #define ADDIB_GE(i,r,t)         ADDIB_(ADD_CF_GE,i,r,t)
 275 #define ADDIB_GT(i,r,t)         ADDIB_(ADD_CF_GT,i,r,t)
 276 #define ADDIB_UV(i,r,t)         ADDIB_(ADD_CF_UV,i,r,t)
 277 #define ADDIB_VNZ(i,r,t)        ADDIB_(ADD_CF_VNZ,i,r,t)
 278 #define ADDIB_NSV(i,r,t)        ADDIB_(ADD_CF_NSV,i,r,t)
 279 #define ADDIB_EV(i,r,t)         ADDIB_(ADD_CF_EV,i,r,t)
 280 #define ADDIB_N_(cc,i,r,t)      f17x(0x29|((cc&1)<<1),r,i,cc>>1,t,1)
 281 #define ADDIB_N(i,r,t)          ADDIB_N_(ADD_CF_NV,i,r,t)
 282 #define ADDIB_N_EQ(i,r,t)       ADDIB_N_(ADD_CF_EQ,i,r,t)
 283 #define ADDIB_N_LT(i,r,t)       ADDIB_N_(ADD_CF_LT,i,r,t)
 284 #define ADDIB_N_LE(i,r,t)       ADDIB_N_(ADD_CF_LE,i,r,t)
 285 #define ADDIB_N_NUV(i,r,t)      ADDIB_N_(ADD_CF_NUV,i,r,t)
 286 #define ADDIB_N_ZNV(i,r,t)      ADDIB_N_(ADD_CF_ZNV,i,r,t)
 287 #define ADDIB_N_SV(i,r,t)       ADDIB_N_(ADD_CF_SV,i,r,t)
 288 #define ADDIB_N_OD(i,r,t)       ADDIB_N_(ADD_CF_OD,i,r,t)
 289 #define ADDIB_N_TR(i,r,t)       ADDIB_N_(ADD_CF_TR,i,r,t)
 290 #define ADDIB_N_NE(i,r,t)       ADDIB_N_(ADD_CF_NE,i,r,t)
 291 #define ADDIB_N_GE(i,r,t)       ADDIB_N_(ADD_CF_GE,i,r,t)
 292 #define ADDIB_N_GT(i,r,t)       ADDIB_N_(ADD_CF_GT,i,r,t)
 293 #define ADDIB_N_UV(i,r,t)       ADDIB_N_(ADD_CF_UV,i,r,t)
 294 #define ADDIB_N_VNZ(i,r,t)      ADDIB_N_(ADD_CF_VNZ,i,r,t)
 295 #define ADDIB_N_NSV(i,r,t)      ADDIB_N_(ADD_CF_NSV,i,r,t)
 296 #define ADDIB_N_EV(i,r,t)       ADDIB_N_(ADD_CF_EV,0,i,r,t)
 297 #define ADDIL(i,r)              f7(0xa,r,i)
 298 #define LOG_CC_NV               0       /* never */
 299 #define LOG_CC_EQ               1       /* all bits are 0 */
 300 #define LOG_CC_LT               2       /* leftmost bit is 1 */
 301 #define LOG_CC_LE               3       /* leftmost bit is 1 or all bits are 0 */
 302 #define LOG_CC_OD               7       /* rightmost bit is 1 */
 303 #define LOG_CC_TR               8       /* always */
 304 #define LOG_CC_NE               9       /* some bits are 1 */
 305 #define LOG_CC_GE               10      /* leftmost bit is 0 */
 306 #define LOG_CC_GT               11      /* leftmost bit is 0 or some bits are 1 */
 307 #define LOG_CC_EV               15      /* rightmost bit is 0 */
 308 #define AND_(cc,r1,r2,t)        f8(0x2,r2,r1,cc,0,1,0,0,0,t)
 309 #define AND(r1,r2,t)            AND_(LOG_CC_NV,r1,r2,t)
 310 #define ANDCM_(cc,r1,r2,t)      f8(0x2,r2,r1,cc,0,0,0,0,0,t)
 311 #define ANDCM(r1,r2,t)          ANDCM_(LOG_CC_NV,r1,r2,t)
 312 #define B_(n,i,t)               f20(0x3a,t,i,0,n)
 313 #define B(i,t)                  B_(0,i,t)
 314 #define B_N(i,t)                B_(1,i,t)
 315 #define B_L(i)                  B_(0,i,_RP_REGNO)
 316 #define B_L_N(i)                B_(1,i,_RP_REGNO)
 317 #define BB_CC_LT                0       /* leftmost bit in word is 1 */
 318 #define BB_CC_GE                1       /* leftmost bit in word is 0 */
 319 #define BB_(c,r,i)              f18(0x30,0,r,c,i,0)
 320 #define BB_N_(c,r,i)            f18(0x30,0,r,c,i,1)
 321 #define BBI_(c,r,p,i)           f18(0x31,p,r,c,i,0)
 322 #define BBI_N_(c,r,p,i)         f18(0x31,p,r,c,i,1)
 323 #define BB(c,r,i)               BB_(c,r,i)
 324 #define BBI_LT(r,p,i)           BBI_(BB_CC_LT,r,p,i)
 325 #define BBI_GE(r,p,i)           BBI_(BB_CC_GE,r,p,i)
 326 #define BB_N(c,r,i)             BB_(c,r,i)
 327 #define BBI_N_LT(r,p,i)         BBI_N_(BB_CC_LT,r,p,i)
 328 #define BBI_N_GE(r,p,i)         BBI_N_(BB_CC_GE,r,p,i)
 329 #define BE(i,s,b)               f19(0x38,b,s,i,0)
 330 #define BE_L(i,s,b)             f19(0x39,b,s,i,0)
 331 #define BE_L_N(i,s,b)           f19(0x39,b,s,i,1)
 332 #define BLR(x,t)                f21(0x3a,t,x,2,0)
 333 #define BLR_N(x,t)              f21(0x3a,t,x,2,1)
 334 #define BREAK(i,j)              f27(0,j,i)
 335 #define BV(x,b)                 f21(0x3a,b,x,6,0)
 336 #define BV_N(x,b)               f21(0x3a,b,x,6,1)
 337 #define BVE(b)                  f22(0x3a,b,6,0,0,0)
 338 #define BVE_N(b)                f22(0x3a,b,6,0,1,0)
 339 #define BVE_L(b)                f22(0x3a,b,7,0,0,0)
 340 #define BVE_L_N(b)              f22(0x3a,b,7,0,0,1)
 341 #define II_C_NONE               0
 342 #define II_C_M                  (1<<5)
 343 #define II_C_S                  (1<<13)
 344 #define II_C_SM                 (II_C_S|II_C_M)
 345 #define II_AU_NONE              0
 346 #define II_AU_PRE               ((1<<13)|II_C_M)
 347 #define II_AU_POS               II_C_M
 348 #define LD_CC_H_NONE            0       /* No hint */
 349 #define LD_CC_H_SPL             2       /* Spatial Locality */
 350 #define CLRBTS()                f23(0x3a,0,0,2,0,0,1,0,1)
 351 #define CS_CC_NV                0       /* never */
 352 #define CS_CC_EQ                2       /* O1 =  O2 */
 353 #define CS_CC_LT                4       /* O1 <  O2 (signed) */
 354 #define CS_CC_LE                6       /* O1 <= O2 (signed) */
 355 #define CS_CC_ULT               8       /* O1 <  O2 (unsigned) */
 356 #define CS_CC_ULE               10      /* O1 <= O2 (unsigned) */
 357 #define CS_CC_SV                12      /* O1 -  O2 overflows (signed) */
 358 #define CS_CC_OD                14      /* O1 -  O2 is odd */
 359 #define CS_CC_TR                1       /* always */
 360 #define CS_CC_NE                3       /* O1 != O2 */
 361 #define CS_CC_GE                5       /* O1 >= O2 (signed) */
 362 #define CS_CC_GT                7       /* O1 >  O2 (signed) */
 363 #define CS_CC_UGE               9       /* O1 >= O2 (unsigned) */
 364 #define CS_CC_UGT               11      /* O1 >  O2 (unsigned) */
 365 #define CS_CC_NSV               13      /* O1 -  O2 does not overflows (signed) */
 366 #define CS_CC_EV                15      /* O1 -  O2 is even */
 367 #define CMPB_(c,r1,r2,i)        f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,0)
 368 #define CMPB(r1,r2,i)           CMPB_(CS_CC_NV,r1,r2,i)
 369 #define CMPB_EQ(r1,r2,i)        CMPB_(CS_CC_EQ,r1,r2,i)
 370 #define CMPB_LT(r1,r2,i)        CMPB_(CS_CC_LT,r1,r2,i)
 371 #define CMPB_LE(r1,r2,i)        CMPB_(CS_CC_LE,r1,r2,i)
 372 #define CMPB_ULT(r1,r2,i)       CMPB_(CS_CC_ULT,r1,r2,i)
 373 #define CMPB_ULE(r1,r2,i)       CMPB_(CS_CC_ULE,r1,r2,i)
 374 #define CMPB_SV(r1,r2,i)        CMPB_(CS_CC_SV,r1,r2,i)
 375 #define CMPB_OD(r1,r2,i)        CMPB_(CS_CC_OD,r1,r2,i)
 376 #define CMPB_TR(r1,r2,i)        CMPB_(CS_CC_TR,r1,r2,i)
 377 #define CMPB_NE(r1,r2,i)        CMPB_(CS_CC_NE,r1,r2,i)
 378 #define CMPB_GE(r1,r2,i)        CMPB_(CS_CC_GE,r1,r2,i)
 379 #define CMPB_GT(r1,r2,i)        CMPB_(CS_CC_GT,r1,r2,i)
 380 #define CMPB_UGE(r1,r2,i)       CMPB_(CS_CC_UGE,r1,r2,i)
 381 #define CMPB_UGT(r1,r2,i)       CMPB_(CS_CC_UGT,r1,r2,i)
 382 #define CMPB_NSV(r1,r2,i)       CMPB_(CS_CC_NSV,r1,r2,i)
 383 #define CMPB_EV(r1,r2,i)        CMPB_(CS_CC_EV,r1,r2,i)
 384 #define CMPB_N_(c,r1,r2,i)      f17((c)&1?0x22:0x20,r2,r1,(c)>>1,i,1)
 385 #define CMPB_N(r1,r2,i)         CMPB_N_(CS_CC_NV,r1,r2,i)
 386 #define CMPB_EQ_N(r1,r2,i)      CMPB_N_(CS_CC_EQ,r1,r2,i)
 387 #define CMPB_LT_N(r1,r2,i)      CMPB_N_(CS_CC_LT,r1,r2,i)
 388 #define CMPB_LE_N(r1,r2,i)      CMPB_N_(CS_CC_LE,r1,r2,i)
 389 #define CMPB_ULT_N(r1,r2,i)     CMPB_N_(CS_CC_ULT,r1,r2,i)
 390 #define CMPB_ULE_N(r1,r2,i)     CMPB_N_(CS_CC_ULE,r1,r2,i)
 391 #define CMPB_SV_N(r1,r2,i)      CMPB_N_(CS_CC_SV,r1,r2,i)
 392 #define CMPB_OD_N(r1,r2,i)      CMPB_N_(CS_CC_OD,r1,r2,i)
 393 #define CMPB_TR_N(r1,r2,i)      CMPB_N_(CS_CC_TR,r1,r2,i)
 394 #define CMPB_NE_N(r1,r2,i)      CMPB_N_(CS_CC_NE,r1,r2,i)
 395 #define CMPB_GE_N(r1,r2,i)      CMPB_N_(CS_CC_GE,r1,r2,i)
 396 #define CMPB_GT_N(r1,r2,i)      CMPB_N_(CS_CC_GT,r1,r2,i)
 397 #define CMPB_UGE_N(r1,r2,i)     CMPB_N_(CS_CC_UGE,r1,r2,i)
 398 #define CMPB_UGT_N(r1,r2,i)     CMPB_N_(CS_CC_UGT,r1,r2,i)
 399 #define CMPB_NSV_N(r1,r2,i)     CMPB_N_(CS_CC_NSV,r1,r2,i)
 400 #define CMPB_EV_N(r1,r2,i)      CMPB_N_(CS_CC_EV,r1,r2,i)
 401 #define CMPCLR_(c,r1,r2,i)      f8(0x2,r2,r1,c,2,0,0,2,0,i)
 402 #define CMPCLR(r1,r2,i)         CMPCLR_(CS_CC_NV,r1,r2,i)
 403 #define CMPCLR_EQ(r1,r2,i)      CMPCLR_(CS_CC_EQ,r1,r2,i)
 404 #define CMPCLR_LT(r1,r2,i)      CMPCLR_(CS_CC_LT,r1,r2,i)
 405 #define CMPCLR_LE(r1,r2,i)      CMPCLR_(CS_CC_LE,r1,r2,i)
 406 #define CMPCLR_ULT(r1,r2,i)     CMPCLR_(CS_CC_ULT,r1,r2,i)
 407 #define CMPCLR_ULE(r1,r2,i)     CMPCLR_(CS_CC_ULE,r1,r2,i)
 408 #define CMPCLR_SV(r1,r2,i)      CMPCLR_(CS_CC_SV,r1,r2,i)
 409 #define CMPCLR_OD(r1,r2,i)      CMPCLR_(CS_CC_OD,r1,r2,i)
 410 #define CMPCLR_TR(r1,r2,i)      CMPCLR_(CS_CC_TR,r1,r2,i)
 411 #define CMPCLR_NE(r1,r2,i)      CMPCLR_(CS_CC_NE,r1,r2,i)
 412 #define CMPCLR_GE(r1,r2,i)      CMPCLR_(CS_CC_GE,r1,r2,i)
 413 #define CMPCLR_GT(r1,r2,i)      CMPCLR_(CS_CC_GT,r1,r2,i)
 414 #define CMPCLR_UGE(r1,r2,i)     CMPCLR_(CS_CC_UGE,r1,r2,i)
 415 #define CMPCLR_UGT(r1,r2,i)     CMPCLR_(CS_CC_UGT,r1,r2,i)
 416 #define CMPCLR_NSV(r1,r2,i)     CMPCLR_(CS_CC_NSV,r1,r2,i)
 417 #define CMPCLR_EV(r1,r2,i)      CMPCLR_(CS_CC_EV,r1,r2,i)
 418 #define CMPIB_(c,i,r,t)         f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,0)
 419 #define CMPIB_NONE(i,r,t)       CMPIB_(CS_CC_NV,i,r,t)
 420 #define CMPIB_EQ(i,r,t)         CMPIB_(CS_CC_EQ,i,r,t)
 421 #define CMPIB_LT(i,r,t)         CMPIB_(CS_CC_LT,i,r,t)
 422 #define CMPIB_LE(i,r,t)         CMPIB_(CS_CC_LE,i,r,t)
 423 #define CMPIB_ULT(i,r,t)        CMPIB_(CS_CC_ULT,i,r,t)
 424 #define CMPIB_ULE(i,r,t)        CMPIB_(CS_CC_ULE,i,r,t)
 425 #define CMPIB_SV(i,r,t)         CMPIB_(CS_CC_SV,i,r,t)
 426 #define CMPIB_OD(i,r,t)         CMPIB_(CS_CC_OD,i,r,t)
 427 #define CMPIB(i,r,t)            CMPIB_(CS_CC_TR,i,r,t)
 428 #define CMPIB_NE(i,r,t)         CMPIB_(CS_CC_NE,i,r,t)
 429 #define CMPIB_GE(i,r,t)         CMPIB_(CS_CC_GE,i,r,t)
 430 #define CMPIB_GT(i,r,t)         CMPIB_(CS_CC_GT,i,r,t)
 431 #define CMPIB_UGE(i,r,t)        CMPIB_(CS_CC_UGE,i,r,t)
 432 #define CMPIB_UGT(i,r,t)        CMPIB_(CS_CC_UGT,i,r,t)
 433 #define CMPIB_NSV(i,r,t)        CMPIB_(CS_CC_NSV,i,r,t)
 434 #define CMPIB_EV(i,r,t)         CMPIB_(CS_CC_EV,i,r,t)
 435 #define CMPIB_N_(c,i,r,t)       f17x((c)&1?0x23:0x21,r,i,(c)>>1,t,1)
 436 #define CMPIB_NONE_N(i,r,t)     CMPIB_N_(CS_CC_NV,i,r,t)
 437 #define CMPIB_EQ_N(i,r,t)       CMPIB_N_(CS_CC_EQ,i,r,t)
 438 #define CMPIB_LT_N(i,r,t)       CMPIB_N_(CS_CC_LT,i,r,t)
 439 #define CMPIB_LE_N(i,r,t)       CMPIB_N_(CS_CC_LE,i,r,t)
 440 #define CMPIB_ULT_N(i,r,t)      CMPIB_N_(CS_CC_ULT,i,r,t)
 441 #define CMPIB_ULE_N(i,r,t)      CMPIB_N_(CS_CC_ULE,i,r,t)
 442 #define CMPIB_SV_N(i,r,t)       CMPIB_N_(CS_CC_SV,i,r,t)
 443 #define CMPIB_OD_N(i,r,t)       CMPIB_N_(CS_CC_OD,i,r,t)
 444 #define CMPIB_N(i,r,t)          CMPIB_N_(CS_CC_TR,i,r,t)
 445 #define CMPIB_NE_N(i,r,t)       CMPIB_N_(CS_CC_NE,i,r,t)
 446 #define CMPIB_GE_N(i,r,t)       CMPIB_N_(CS_CC_GE,i,r,t)
 447 #define CMPIB_GT_N(i,r,t)       CMPIB_N_(CS_CC_GT,i,r,t)
 448 #define CMPIB_UGE_N(i,r,t)      CMPIB_N_(CS_CC_UGE,i,r,t)
 449 #define CMPIB_UGT_N(i,r,t)      CMPIB_N_(CS_CC_UGT,i,r,t)
 450 #define CMPIB_NSV_N(i,r,t)      CMPIB_N_(CS_CC_NSV,i,r,t)
 451 #define CMPIB_EV_N(i,r,t)       CMPIB_N_(CS_CC_EV,i,r,t)
 452 #define CMPICLR_(c,i,r,t)       f9(0x24,r,t,c,0,i)
 453 #define CMPICLR(i,r,t)          CMPICLR_(CS_CC_NV,i,r,t)
 454 #define CMPICLR_EQ(i,r,t)       CMPICLR_(CS_CC_EQ,i,r,t)
 455 #define CMPICLR_LT(i,r,t)       CMPICLR_(CS_CC_LT,i,r,t)
 456 #define CMPICLR_LE(i,r,t)       CMPICLR_(CS_CC_LE,i,r,t)
 457 #define CMPICLR_ULT(i,r,t)      CMPICLR_(CS_CC_ULT,i,r,t)
 458 #define CMPICLR_ULE(i,r,t)      CMPICLR_(CS_CC_ULE,i,r,t)
 459 #define CMPICLR_SV(i,r,t)       CMPICLR_(CS_CC_SV,i,r,t)
 460 #define CMPICLR_OD(i,r,t)       CMPICLR_(CS_CC_OD,i,r,t)
 461 #define CMPICLR_TR(i,r,t)       CMPICLR_(CS_CC_TR,i,r,t)
 462 #define CMPICLR_NE(i,r,t)       CMPICLR_(CS_CC_NE,i,r,t)
 463 #define CMPICLR_GE(i,r,t)       CMPICLR_(CS_CC_GE,i,r,t)
 464 #define CMPICLR_GT(i,r,t)       CMPICLR_(CS_CC_GT,i,r,t)
 465 #define CMPICLR_UGE(i,r,t)      CMPICLR_(CS_CC_UGE,i,r,t)
 466 #define CMPICLR_UGT(i,r,t)      CMPICLR_(CS_CC_UGT,i,r,t)
 467 #define CMPICLR_NSV(i,r,t)      CMPICLR_(CS_CC_NSV,i,r,t)
 468 #define CMPICLR_EV(i,r,t)       CMPICLR_(CS_CC_EV,i,r,t)
 469 #define COPR(u,s)               f38(0x0c,s,u,0)
 470 #define UI_CF_NONE              0       /* never */
 471 #define UI_CF_SBZ               2       /* some byte zero */
 472 #define UI_CF_SHZ               3       /* some halfword zero */
 473 #define UI_CF_SDC               4       /* some digit carry */
 474 #define UI_CF_SBC               6       /* some byte carry */
 475 #define UI_CF_SHC               7       /* some halfword carry */
 476 #define UI_TR_SHC               8       /* always */
 477 #define UI_CF_NBZ               10      /* no byte zero */
 478 #define UI_CF_NHZ               11      /* no halfword zero */
 479 #define UI_CF_NDC               12      /* no digit carry */
 480 #define UI_CF_NBC               14      /* no byte carry */
 481 #define UI_CF_NHC               15      /* no halfword carry */
 482 #define DCOR_(e1,cf,r,t)        f8(0x2,r,0,cf,2,1,1,e1,0,t)
 483 #define DCOR(r,t)               DCOR_(2,UI_CF_NONE,r,t)
 484 #define DCOR_I(r,t)             DCOR_(3,UI_CF_NONE,r,t)
 485 #define SED_C_NEVER             0       /* never */
 486 #define SED_C_EQ                1       /* all bits 0 */
 487 #define SED_C_LT                2       /* lefmost bits 1 */
 488 #define SED_C_OD                3       /* rightmost bit 1 */
 489 #define SED_C_TR                4       /* always */
 490 #define SED_C_NE                5       /* some bit 1 */
 491 #define SED_C_GE                6       /* lefmost bits 1 */
 492 #define SED_C_EV                7       /* rightmost bit 0 */
 493 #define DEPW(r,len,t)           f13(0x35,t,r,SED_C_NEVER,0,1,0,len)
 494 #define DEPW_Z(r,len,t)         f13(0x35,t,r,SED_C_NEVER,0,0,0,len)
 495 #define DEPWR(r,pos,len,t)      f16(0x35,t,r,SED_C_NEVER,0,1,1,31-(pos),len)
 496 #define DEPWR_Z(r,pos,len,t)    f16(0x35,t,r,SED_C_NEVER,0,1,0,31-(pos),len)
 497 #define SHLWI(r,sa,t)           DEPWR_Z(r,31-(sa),32-(sa),t)
 498 #define DEPWI(i,len,t)          f13x(0x35,t,i,SED_C_NEVER,2,1,0,len)
 499 #define DEPWI_Z(i,len,t)        f13x(0x35,t,i,SED_C_NEVER,2,0,0,len)
 500 #define DEPWRI(i,pos,len,t)     f16x(0x35,t,i,SED_C_NEVER,1,1,1,31-(pos),len)
 501 #define DEPWRI_Z(i,pos,len,t)   f16x(0x35,t,i,SED_C_NEVER,1,1,0,31-(pos),len)
 502 #define DIAG(i)                 f28(0x5,i)
 503 #define DS(r1,r2,t)             f8(0x2,r2,r1,ADD_CF_NV,1,0,0,1,0,t)
 504 #define EXTRW(r,len,t)          f12(0x34,r,t,SED_C_NEVER,2,1,0,0,0,len)
 505 #define EXTRW_U(r,len,t)        f12(0x34,r,t,SED_C_NEVER,2,0,0,0,0,len)
 506 #define EXTRWR(r,pos,len,t)     f15(0x34,r,t,SED_C_NEVER,1,1,1,pos,len)
 507 #define SHRWI(r,sa,t)           EXTRWR(r,31-(sa),32-(sa),t)
 508 #define EXTRWR_U(r,pos,len,t)   f15(0x34,r,t,SED_C_NEVER,1,1,0,pos,len)
 509 #define SHRWI_U(r,sa,t)         EXTRWR_U(r,31-(sa),32-(sa),t)
 510 #define FDC(x,s,b)              f24(0x1,b,x,s,0x4a,0,0)
 511 #define FDC_M(x,s,b)            f24(0x1,b,x,s,0x4a,1,0)
 512 #define FDCI(i,s,b)             f25(0x1,b,i,s,0xca,0,0)
 513 #define FDCE(x,s,b)             f24(0x1,b,x,s,0x4b,0,0)
 514 #define FDCE_M(x,s,b)           f24(0x1,b,x,s,0x4b,1,0)
 515 #define FIC(x,s,b)              f26(0x1,b,x,s,0xa,0,0)
 516 #define FIC_M(x,s,b)            f26(0x1,b,x,s,0xa,1,0)
 517 #define FICI(x,s,b)             f25(0x1,b,x,s,0x4f,0,0)
 518 #define FICI_M(x,s,b)           f25(0x1,b,x,s,0x4f,1,0)
 519 #define FICE(x,s,b)             f26(0x1,b,x,s,0xb,0,0)
 520 #define FICE_M(x,s,b)           f26(0x1,b,x,s,0xb,1,0)
 521 #define HADD_(c,r1,r2,t)        f8(0x2,r2,r1,0,0,1,1,c,0,t)
 522 #define HADD(r1,r2,t)           HADD_(3,r1,r2,t)
 523 #define HADD_SS(r1,r2,t)        HADD_(1,r1,r2,t)
 524 #define HADD_US(r1,r2,t)        HADD_(0,r1,r2,t)
 525 #define HAVG(r1,r2,t)           f8(0x2,r2,r1,0,0,1,0,3,0,t)
 526 #define HSHL(r,sa,t)            f10(0x3e,0,r,1,0,0,2,sa,0,t)
 527 #define HSHLADD(r1,sa,r2,t)     f8(0x2,r2,r1,0,1,1,1,sa,0,t)
 528 #define HSHR(r,sa,t)            f10(0x3e,r,0,1,2,0,3,sa,0,t)
 529 #define HSHR_U(r,sa,t)          f10(0x3e,r,0,1,2,0,2,sa,0,t)
 530 #define HSHRADD(r1,sa,r2,t)     f8(0x2,r2,r1,0,1,0,1,sa,0,t)
 531 #define HSUB_(c,r1,r2,t)        f8(0x2,r2,r1,0,0,0,1,c,0,t)
 532 #define HSUB(r1,r2,t)           HSUB_(3,r1,r2,t)
 533 #define HSUB_SS(r1,r2,t)        HSUB_(1,r1,r2,t)
 534 #define HSUB_US(r1,r2,t)        HSUB_(0,r1,r2,t)
 535 #define IDTLBT(r1,r2)           f26(0x1,r2,r1,0,0x60,0,0)
 536 #define IITLBT(r1,r2)           f26(0x1,r2,r1,0,0x20,0,0)
 537 #define LCI(x,s,b,t)            f24(0x1,b,x,s,0x4c,0,t)
 538 #define LDBL(i,b,t)             f1(0x10,b,t,i)
 539 #define LDB(x,b,t)              f4(0x3,b,x,0,0,0,LD_CC_H_NONE,0,0,t)
 540 #define LDBI(i,b,t)             f5(0x3,b,i,0,0,1,LD_CC_H_NONE,0,0,t)
 541 #define LDCD(x,b,t)             f4(0x3,b,x,0,0,0,LD_CC_H_NONE,5,0,t)
 542 #define LDCDI(i,b,t)            f5(0x3,b,i,0,0,1,LD_CC_H_NONE,5,0,t)
 543 #define LDCW(x,b,t)             f4(0x3,b,x,0,0,0,LD_CC_H_NONE,7,0,t)
 544 #define LDCWI(i,b,t)            f5(0x3,b,i,0,0,1,LD_CC_H_NONE,7,0,t)
 545 #define LDDL(i,b,t)             f3(0x14,b,t,i,0)
 546 #define LDD(x,b,t)              f4(0x3,b,x,0,0,0,LD_CC_H_NONE,3,0,t)
 547 #define LDDI(i,b,t)             f5(0x3,b,i,0,0,1,LD_CC_H_NONE,3,0,t)
 548 #define LDDA(x,b,t)             f4(0x3,b,x,0,0,0,LD_CC_H_NONE,4,0,t)
 549 #define LDDAI(i,b,t)            f5(0x3,b,i,0,0,1,LD_CC_H_NONE,4,0,t)
 550 #define LDHL(i,b,t)             f1(0x11,b,t,i)
 551 #define LDH(x,b,t)              f4(0x3,b,x,0,0,0,LD_CC_H_NONE,1,0,t)
 552 #define LDHI(i,b,t)             f5(0x3,b,i,0,0,1,LD_CC_H_NONE,1,0,t)
 553 #define LDIL(i,t)               f7(0x8,t,i)
 554 #define LDO(i,b,t)              f1(0xd,b,t,i)
 555 #define LDI(i,t)                LDO(i,0,t)
 556 #define LDSID(s,b,t)            f30(0x0,b,0,s,0,0x85,t)
 557 #define LDWL(i,b,t)             f1(0x12,b,t,i)
 558 #define LDWL_MB(i,b,t)          f1(0x13,b,t,i)  /* pre-dec or post-inc */
 559 #define LDWL_MA(i,b,t)          f2(0x17,b,t,i,2)/* post-dec or pre-inc */
 560 #define LDW(x,b,t)              f4(0x3,b,x,0,0,0,LD_CC_H_NONE,2,0,t)
 561 #define LDWI(i,b,t)             f5(0x3,b,i,0,0,1,LD_CC_H_NONE,2,0,t)
 562 #define LDWA(x,b,t)             f4(0x3,b,x,0,0,0,LD_CC_H_NONE,6,0,t)
 563 #define LDWAI(i,b,t)            f5(0x3,b,i,0,0,1,LD_CC_H_NONE,6,0,t)
 564 #define LPA(x,s,b,t)            f24(0x1,b,x,s,0x4d,0,t)
 565 #define MFSP(s,t)               f29(0x0,0,0,s,0x25,t)
 566 #define MIXH_L(r1,r2,t)         f10(0x3e,r2,r1,1,0,0,1,0,0,t)
 567 #define MIXH_R(r1,r2,t)         f10(0x3e,r2,r1,1,2,0,1,0,0,t)
 568 #define MIXW_L(r1,r2,t)         f10(0x3e,r2,r1,1,0,0,0,0,0,t)
 569 #define MIXW_R(r1,r2,t)         f10(0x3e,r2,r1,1,2,0,0,0,0,t)
 570 #define MOVB_(c,r1,r2,i)        f17(0x32,r2,r1,c,i,0)
 571 #define MOVB(r1,r2,i)           MOVB_(SED_C_NEVER,r1,r2,i)
 572 #define MOVB_EQ(r1,r2,i)        MOVB_(SED_C_EQ,r1,r2,i)
 573 #define MOVB_LT(r1,r2,i)        MOVB_(SED_C_LT,r1,r2,i)
 574 #define MOVB_OD(r1,r2,i)        MOVB_(SED_C_OD,r1,r2,i)
 575 #define MOVB_TR(r1,r2,i)        MOVB_(SED_C_TR,r1,r2,i)
 576 #define MOVB_NE(r1,r2,i)        MOVB_(SED_C_NE,r1,r2,i)
 577 #define MOVB_GE(r1,r2,i)        MOVB_(SED_C_GE,r1,r2,i)
 578 #define MOVB_EV(r1,r2,i)        MOVB_(SED_C_EV,r1,r2,i)
 579 #define MOVIB_(c,r,i,t)         f17x(0x33,r,i,c,t,0)
 580 #define MOVIB(i,r,t)            MOVIB_(SED_C_NEVER,i,r,t)
 581 #define MOVIB_EQ(i,r,t)         MOVIB_(SED_C_EQ,i,r,t)
 582 #define MOVIB_LT(i,r,t)         MOVIB_(SED_C_LT,i,r,t)
 583 #define MOVIB_OD(i,r,t)         MOVIB_(SED_C_OD,i,r,t)
 584 #define MOVIB_TR(i,r,t)         MOVIB_(SED_C_TR,i,r,t)
 585 #define MOVIB_NE(i,r,t)         MOVIB_(SED_C_NE,i,r,t)
 586 #define MOVIB_GE(i,r,t)         MOVIB_(SED_C_GE,i,r,t)
 587 #define MOVIB_EV(i,r,t)         MOVIB_(SED_C_EV,i,r,t)
 588 #define MTCTL(r,t)              f31(0x0,t,r,0,0xc2,0)
 589 #define MTSAR(r)                MTCTL(r,_CR11_REGNO)
 590 #define MTSARCM(r)              f31(0x0,0xb,r,0,0xc6,0)
 591 #define MTSM(r)                 f33(0x0,0,r,0,0xc3,0)
 592 #define MTSP(r,s)               f29(0x0,0,r,s,0xc1,0)
 593 #define OR_(c,r1,r2,t)          f8(0x2,r2,r1,c,0,1,0,1,0,t)
 594 #define OR(r1,r2,t)             OR_(LOG_CC_NV,r1,r2,t)
 595 #define NOP()                   OR(_R0_REGNO,_R0_REGNO,_R0_REGNO)
 596 #define COPY(r,t)               OR(r,0,t)
 597 #define PDC(x,s,b)              f24(0x1,b,x,s,0x4e,0,0)
 598 #define PDTLB(x,s,b)            f24(0x1,b,x,s,0x48,0,0)
 599 #define PDTLB_L(x,s,b)          f24(0x1,b,x,s,0x58,0,0)
 600 #define PDTLBE(x,s,b)           f24(0x1,b,x,s,0x49,0,0)
 601 #define PERMH(c,r,t)            f10(0x3e,r,r,0,(c)&3,0,((c)>>2)&3,(((c)>>2)&6)|(((c)>>6)&3),0,t)
 602 #define PITBL(x,s,b)            f26(0x1,b,x,s,0x08,0,0)
 603 #define PITBL_L(x,s,b)          f26(0x1,b,x,s,0x18,0,0)
 604 #define PITBLE(x,s,b)           f26(0x1,b,x,s,0x09,0,0)
 605 #define POPBTS(i)               f23(0x3a,0,0,2,0,i,1,0,1)
 606 #define PROBE_R(s,b,r,t)        f24(0x1,b,r,s,0x46,0,t)
 607 #define PROBE_W(s,b,r,t)        f24(0x1,b,r,s,0x47,0,t)
 608 #define PROBEI_R(s,b,i,t)       f24(0x1,b,i,s,0x46,0,t)
 609 #define PROBEI_W(s,b,i,t)       f24(0x1,b,i,s,0x47,0,t)
 610 #define PUSHBTS(r)              f23(0x3a,0,r,2,0,0,0,0,1)
 611 #define PUSHNOM()               f23(0x3a,0,0,2,0,0,0,0,1)
 612 #define RFI()                   f33(0x0,0,0,0,0x60,0)
 613 #define RFI_R()                 f33(0x0,0,0,0,0x65,0)
 614 #define RSM(i,t)                f33(0x0,((i)&0x3e0)>>5,(i)&0x1f,0,0x73,t)
 615 #define SHLADD_(e,cf,r1,sa,r2,t) f8(0x2,r2,r1,cf,e,1,0,sa,0,t)
 616 #define SHLADD(r1,sa,r2,t)      SHLADD_(1,ADD_CF_NV,r1,sa,r2,t)
 617 #define SHLADD_L(r1,sa,r2,t)    SHLADD_(2,ADD_CF_NV,r1,sa,r2,t)
 618 #define SHLADD_TSV(r1,sa,r2,t)  SHLADD_(3,ADD_CF_NV,r1,sa,r2,t)
 619 #define SHRPD(r1,r2,t)          f11(0x34,r2,r1,SED_C_NEVER,0,0,1,0,t)
 620 #define SHRPDI(r1,r2,sa,t)      f14(0x34,r2,r1,SED_C_NEVER,0,(63-(sa))>>5,1,(63-(sa))&0x1f,t)
 621 #define SHRPW(r1,r2,t)          f11(0x34,r2,r1,SED_C_NEVER,0,0,0,0,t)
 622 #define SHRPWI(r1,r2,sa,t)      f14(0x34,r2,r1,SED_C_NEVER,0,1,0,31-(sa),t)
 623 #define SPOP0(sf,so)            f34(0x4,(so)>>5,0,sf,0,(so)&0x1f)
 624 #define SPOP1(sf,so,t)          f35(0x4,so,1,sf,0,t)
 625 #define SPOP2(sf,so,r)          f36(0x4,r,(so)>>5,2,sf,0,(so)&0x1f)
 626 #define SPOP3(sf,so,r1,r2)      f37(0x4,r2,r1,(so)>>5,3,sf,0,(so)&0x1f)
 627 #define SSM(i,t)                f33(0x00,(i)>>5,(i)&0x1f,0,0x6b,t)
 628 #define STBL(r,i,b)             f1(0x18,b,r,i)
 629 #define STBI(r,i,b)             f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x8,0,i)
 630 #define STDL(r,i,b)             f3(0x1c,b,r,i,0)
 631 #define STDI(r,i,b)             f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xc,0,i)
 632 #define STDA(r,i,b)             f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xf,0,i)
 633 #define STHL(r,i,b)             f1(0x19,b,r,i)
 634 #define STHI(r,i,b)             f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0x9,0,i)
 635 #define STWL(r,i,b)             f1(0x1a,b,r,i)
 636 #define STWL_MA(r,i,b)          f1(0x1b,b,r,i)  /* pre-dec or post-inc */
 637 #define STWL_MB(r,i,b)          f2(0x1f,b,r,i,2)/* post-dec or pre-inc */
 638 #define STWI(r,i,b)             f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xa,0,i)
 639 #define STWA(r,i,b)             f6(0x3,b,r,0,0,1,LD_CC_H_NONE,0xe,0,i)
 640 #define SUB_(e1,e2,cf,r1,r2,t)  f8(0x2,r2,r1,cf,e1,0,e2,0,0,t)
 641 #define SUB(r1,r2,t)            SUB_(1,0,CS_CC_NV,r1,r2,t)
 642 #define SUB_B(r1,r2,t)          SUB_(1,1,CS_CC_NV,r1,r2,t)
 643 #define SUB_SV(r1,r2,t)         SUB_(1,0,CS_CC_SV,r1,r2,t)
 644 #define SUB_NSV(r1,r2,t)        SUB_(1,0,CS_CC_NSV,r1,r2,t)
 645 /* actually, rsbi */
 646 #define SUBI_(e1,cf,i,r,t)      f9(0x25,r,t,cf,e1,i)
 647 #define SUBI(i,r,t)             SUBI_(0,ADD_CF_NV,i,r,t)
 648 #define SYNC()                  f33(0x0,0,0,0,0x20,0)
 649 #define SYNCDMA()               f33(0x0,0,1<<4,0,0x20,0)
 650 #define UADDCM(r1,r2,t)         f8(0x2,r2,r1,ADD_CF_NV,2,0,1,2,0,t)
 651 #define UXOR(r1,r2,t)           f8(0x2,r2,r1,LOG_CC_NV,0,1,1,2,0,t)
 652 #define XOR(r1,r2,t)            f8(0x2,r2,r1,LOG_CC_NV,0,1,0,2,0,t)
 653 #  define nop(c)                        _nop(_jit,c)
 654 static void _nop(jit_state_t*,jit_int32_t);
 655 #define movr(r0,r1)             _movr(_jit,r0,r1)
 656 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
 657 #define movi(r0,i0)             _movi(_jit,r0,i0)
 658 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
 659 #define movi_p(r0,i0)           _movi_p(_jit,r0,i0)
 660 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 661 #  define bswapr_us(r0, r1)             _bswapr_us(_jit, r0, r1)
 662 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
 663 #  define bswapr_ui(r0, r1)             _bswapr_ui(_jit, r0, r1)
 664 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 665 #  define movnr(r0,r1,r2)               _movnr(_jit,r0,r1,r2)
 666 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 667 #  define movzr(r0,r1,r2)               _movzr(_jit,r0,r1,r2)
 668 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 669 #  define casx(r0, r1, r2, r3, i0)      _casx(_jit, r0, r1, r2, r3, i0)
 670 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 671                   jit_int32_t,jit_int32_t,jit_word_t);
 672 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 673 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 674 #define comr(r0,r1)             UADDCM(_R0_REGNO,r1,r0)
 675 #define negr(r0,r1)             SUB(_R0_REGNO,r1,r0)
 676 #define extr(r0,r1,i0,i1)               _extr(_jit,r0,r1,i0,i1)
 677 static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 678 #define extr_u(r0,r1,i0,i1)             _extr_u(_jit,r0,r1,i0,i1)
 679 static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 680 #define depr(r0,r1,i0,i1)               _depr(_jit,r0,r1,i0,i1)
 681 static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
 682 #define extr_c(r0,r1)           EXTRWR(r1,31,8,r0)
 683 #define extr_uc(r0,r1)          EXTRWR_U(r1,31,8,r0)
 684 #define extr_s(r0,r1)           EXTRWR(r1,31,16,r0)
 685 #define extr_us(r0,r1)          EXTRWR_U(r1,31,16,r0)
 686 #define addr(r0,r1,r2)          ADD(r1,r2,r0)
 687 #define addi(r0,r1,i0)          _addi(_jit,r0,r1,i0)
 688 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 689 #define addcr(r0,r1,r2)         addr(r0,r1,r2)
 690 #define addci(r0,r1,i0)         _addci(_jit,r0,r1,i0)
 691 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 692 #define addxr(r0,r1,r2)         ADD_C(r1,r2,r0)
 693 #define addxi(r0,r1,i0)         _addxi(_jit,r0,r1,i0)
 694 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 695 #define subr(r0,r1,r2)          SUB(r1,r2,r0)
 696 #define subi(r0,r1,i0)          _subi(_jit,r0,r1,i0)
 697 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 698 #define subcr(r0,r1,r2)         subr(r0,r1,r2)
 699 #define subci(r0,r1,i0)         _subci(_jit,r0,r1,i0)
 700 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 701 #define subxr(r0,r1,r2)         SUB_B(r1,r2,r0)
 702 #define subxi(r0,r1,i0)         _subxi(_jit,r0,r1,i0)
 703 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 704 #define rsbi(r0, r1, i0)        _rsbi(_jit, r0, r1, i0)
 705 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 706 #define mulr(r0,r1,r2)          _mulr(_jit,r0,r1,r2)
 707 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 708 #define muli(r0,r1,i0)          _muli(_jit,r0,r1,i0)
 709 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 710 #define hmulr(r0, r1, r2)       qmulr(JIT_NOREG, r0, r1, r2)
 711 #define hmuli(r0, r1, i0)       qmuli(JIT_NOREG, r0, r1, i0)
 712 #define hmulr_u(r0, r1, r2)     qmulr_u(JIT_NOREG, r0, r1, r2)
 713 #define hmuli_u(r0, r1, i0)     qmuli_u(JIT_NOREG, r0, r1, i0)
 714 static long long __llmul(int, int);
 715 #define qmulr(r0,r1,r2,r3)      _qmulr(_jit,r0,r1,r2,r3)
 716 static void _qmulr(jit_state_t*,
 717                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 718 #define qmuli(r0,r1,r2,i0)      _qmuli(_jit,r0,r1,r2,i0)
 719 static void _qmuli(jit_state_t*,
 720                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 721 #define qmulr_u(r0,r1,r2,r3)    _qmulr_u(_jit,r0,r1,r2,r3)
 722 static void _qmulr_u(jit_state_t*,
 723                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 724 #define qmuli_u(r0,r1,r2,i0)    _qmuli_u(_jit,r0,r1,r2,i0)
 725 static void _qmuli_u(jit_state_t*,
 726                      jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 727 static int __idiv(int, int);
 728 #define divr(r0,r1,r2)          _divr(_jit,r0,r1,r2)
 729 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 730 #define divi(r0,r1,i0)          _divi(_jit,r0,r1,i0)
 731 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 732 static unsigned int __udiv(unsigned int, unsigned int);
 733 #define divr_u(r0,r1,r2)        _divr_u(_jit,r0,r1,r2)
 734 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 735 #define divi_u(r0,r1,i0)        _divi_u(_jit,r0,r1,i0)
 736 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 737 static int __irem(int, int);
 738 #define remr(r0,r1,r2)          _remr(_jit,r0,r1,r2)
 739 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 740 #define remi(r0,r1,i0)          _remi(_jit,r0,r1,i0)
 741 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 742 static unsigned int __urem(unsigned int, unsigned int);
 743 #define remr_u(r0,r1,r2)        _remr_u(_jit,r0,r1,r2)
 744 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 745 #define remi_u(r0,r1,i0)        _remi_u(_jit,r0,r1,i0)
 746 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 747 static idiv_t __idivrem(int, int);
 748 #define qdivr(r0,r1,r2,r3)      _qdivr(_jit,r0,r1,r2,r3)
 749 static void _qdivr(jit_state_t*,
 750                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 751 #define qdivi(r0,r1,r2,i0)      _qdivi(_jit,r0,r1,r2,i0)
 752 static void _qdivi(jit_state_t*,
 753                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 754 static udiv_t __udivrem(unsigned int, unsigned int);
 755 #define qdivr_u(r0,r1,r2,r3)    _qdivr_u(_jit,r0,r1,r2,r3)
 756 static void _qdivr_u(jit_state_t*,
 757                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 758 #define qdivi_u(r0,r1,r2,i0)    _qdivi_u(_jit,r0,r1,r2,i0)
 759 static void _qdivi_u(jit_state_t*,
 760                      jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 761 #define andr(r0,r1,r2)          AND(r1,r2,r0)
 762 #define andi(r0,r1,i0)          _andi(_jit,r0,r1,i0)
 763 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 764 #define orr(r0,r1,r2)           OR(r1,r2,r0)
 765 #define ori(r0,r1,i0)           _ori(_jit,r0,r1,i0)
 766 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 767 #define xorr(r0,r1,r2)          XOR(r1,r2,r0)
 768 #define xori(r0,r1,i0)          _xori(_jit,r0,r1,i0)
 769 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 770 #define lshr(r0,r1,r2)          _lshr(_jit,r0,r1,r2)
 771 static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 772 #define lshi(r0,r1,i0)          SHLWI(r1,i0,r0)
 773 #define rshr(r0,r1,r2)          _rshr(_jit,r0,r1,r2)
 774 static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 775 #define rshi(r0,r1,i0)          SHRWI(r1,i0,r0)
 776 #define rshr_u(r0,r1,r2)        _rshr_u(_jit,r0,r1,r2)
 777 static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 778 #define rshi_u(r0,r1,i0)        SHRWI_U(r1,i0,r0)
 779 #define lrotr(r0,r1,r2)         _lrotr(_jit,r0,r1,r2)
 780 static void _lrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 781 #define lroti(r0,r1,i0)         rroti(r0,r1,32-i0)
 782 #define rrotr(r0,r1,r2)         _rrotr(_jit,r0,r1,r2)
 783 static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 784 #define rroti(r0,r1,i0)         _rroti(_jit,r0,r1,i0)
 785 static void _rroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 786 #define cmpr(c,r0,r1,r2)        _cmpr(_jit,c,r0,r1,r2)
 787 static void _cmpr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,jit_int32_t);
 788 #define cmpi(c,ci,r0,r1,i0)     _cmpi(_jit,c,ci,r0,r1,i0)
 789 static void _cmpi(jit_state_t*,jit_word_t,jit_word_t,
 790                   jit_int32_t,jit_int32_t,jit_word_t);
 791 #define ltr(r0,r1,r2)           cmpr(CS_CC_GE,r0,r1,r2)
 792 #define lti(r0,r1,i0)           cmpi(CS_CC_GE,CS_CC_LE,r0,r1,i0)
 793 #define ltr_u(r0,r1,r2)         cmpr(CS_CC_UGE,r0,r1,r2)
 794 #define lti_u(r0,r1,i0)         cmpi(CS_CC_UGE,CS_CC_ULE,r0,r1,i0)
 795 #define ler(r0,r1,r2)           cmpr(CS_CC_GT,r0,r1,r2)
 796 #define lei(r0,r1,i0)           cmpi(CS_CC_GT,CS_CC_LT,r0,r1,i0)
 797 #define ler_u(r0,r1,r2)         cmpr(CS_CC_UGT,r0,r1,r2)
 798 #define lei_u(r0,r1,i0)         cmpi(CS_CC_UGT,CS_CC_ULT,r0,r1,i0)
 799 #define eqr(r0,r1,r2)           cmpr(CS_CC_NE,r0,r1,r2)
 800 #define eqi(r0,r1,i0)           cmpi(CS_CC_NE,CS_CC_NE,r0,r1,i0)
 801 #define ger(r0,r1,r2)           cmpr(CS_CC_LT,r0,r1,r2)
 802 #define gei(r0,r1,i0)           cmpi(CS_CC_LT,CS_CC_GT,r0,r1,i0)
 803 #define ger_u(r0,r1,r2)         cmpr(CS_CC_ULT,r0,r1,r2)
 804 #define gei_u(r0,r1,i0)         cmpi(CS_CC_ULT,CS_CC_UGT,r0,r1,i0)
 805 #define gtr(r0,r1,r2)           cmpr(CS_CC_LE,r0,r1,r2)
 806 #define gti(r0,r1,i0)           cmpi(CS_CC_LE,CS_CC_GE,r0,r1,i0)
 807 #define gtr_u(r0,r1,r2)         cmpr(CS_CC_ULE,r0,r1,r2)
 808 #define gti_u(r0,r1,i0)         cmpi(CS_CC_ULE,CS_CC_UGE,r0,r1,i0)
 809 #define ner(r0,r1,r2)           cmpr(CS_CC_EQ,r0,r1,r2)
 810 #define nei(r0,r1,i0)           cmpi(CS_CC_EQ,CS_CC_EQ,r0,r1,i0)
 811 #define ldr_c(r0,r1)            _ldr_c(_jit,r0,r1)
 812 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
 813 #define ldi_c(r0,i0)            _ldi_c(_jit,r0,i0)
 814 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
 815 #define ldxr_c(r0,r1,r2)        _ldxr_c(_jit,r0,r1,r2)
 816 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 817 #define ldxi_c(r0,r1,i0)        _ldxi_c(_jit,r0,r1,i0)
 818 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 819 #define ldr_uc(r0,r1)           LDBI(_R0_REGNO,r1,r0)
 820 #define ldi_uc(r0,i0)           _ldi_uc(_jit,r0,i0)
 821 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
 822 #define ldxr_uc(r0,r1,r2)       LDB(r2,r1,r0)
 823 #define ldxi_uc(r0,r1,i0)       _ldxi_uc(_jit,r0,r1,i0)
 824 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 825 #define ldr_s(r0,r1)            _ldr_s(_jit,r0,r1)
 826 static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
 827 #define ldi_s(r0,i0)            _ldi_s(_jit,r0,i0)
 828 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
 829 #define ldxr_s(r0,r1,r2)        _ldxr_s(_jit,r0,r1,r2)
 830 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 831 #define ldxi_s(r0,r1,i0)        _ldxi_s(_jit,r0,r1,i0)
 832 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 833 #define ldr_us(r0,r1)           LDHI(_R0_REGNO,r1,r0)
 834 #define ldi_us(r0,i0)           _ldi_us(_jit,r0,i0)
 835 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
 836 #define ldxr_us(r0,r1,r2)       LDH(r2,r1,r0)
 837 #define ldxi_us(r0,r1,i0)       _ldxi_us(_jit,r0,r1,i0)
 838 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 839 #define ldr_i(r0,r1)            ldr_ui(r0,r1)
 840 #define ldr_ui(r0,r1)           LDWI(_R0_REGNO,r1,r0)
 841 #define ldi_i(r0,i0)            ldi_ui(r0,i0)
 842 #define ldi_ui(r0,i0)           _ldi_ui(_jit,r0,i0)
 843 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
 844 #define ldxr_i(r0,r1,r2)        ldxr_ui(r0,r1,r2)
 845 #define ldxr_ui(r0,r1,r2)       LDW(r2,r1,r0)
 846 #define ldxi_i(r0,r1,i0)        ldxi_ui(r0,r1,i0)
 847 #define ldxi_ui(r0,r1,i0)       _ldxi_ui(_jit,r0,r1,i0)
 848 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 849 #define str_c(r0,r1)            STBI(r1,_R0_REGNO,r0)
 850 #define sti_c(i0,r0)            _sti_c(_jit,i0,r0)
 851 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
 852 #define stxr_c(r0,r1,r2)        _stxr_c(_jit,r0,r1,r2)
 853 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 854 #define stxi_c(i0,r0,r1)        _stxi_c(_jit,i0,r0,r1)
 855 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 856 #define str_s(r0,r1)            STHI(r1,_R0_REGNO,r0)
 857 #define sti_s(i0,r0)            _sti_s(_jit,i0,r0)
 858 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
 859 #define stxr_s(r0,r1,r2)        _stxr_s(_jit,r0,r1,r2)
 860 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 861 #define stxi_s(i0,r0,r1)        _stxi_s(_jit,i0,r0,r1)
 862 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 863 #define str_i(r0,r1)            STWI(r1,_R0_REGNO,r0)
 864 #define sti_i(i0,r0)            _sti_i(_jit,i0,r0)
 865 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
 866 #define stxr_i(r0,r1,r2)        _stxr_i(_jit,r0,r1,r2)
 867 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 868 #define stxi_i(i0,r0,r1)        _stxi_i(_jit,i0,r0,r1)
 869 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 870 #define bcmpr(c,i0,r0,r1)       _bcmpr(_jit,c,i0,r0,r1)
 871 static jit_word_t _bcmpr(jit_state_t*,jit_word_t,
 872                          jit_word_t,jit_int32_t,jit_int32_t);
 873 #define bcmpi(c,ci,i0,r0,i1)    _bcmpi(_jit,c,ci,i0,r0,i1)
 874 static jit_word_t _bcmpi(jit_state_t*,jit_word_t,jit_word_t,
 875                          jit_word_t,jit_int32_t,jit_word_t);
 876 #define bltr(i0,r0,r1)          bcmpr(CS_CC_LT,i0,r0,r1)
 877 #define blti(i0,r0,r1)          bcmpi(CS_CC_LT,CS_CC_GT,i0,r0,r1)
 878 #define bltr_u(i0,r0,r1)        bcmpr(CS_CC_ULT,i0,r0,r1)
 879 #define blti_u(i0,r0,r1)        bcmpi(CS_CC_ULT,CS_CC_UGT,i0,r0,r1)
 880 #define bler(i0,r0,r1)          bcmpr(CS_CC_LE,i0,r0,r1)
 881 #define blei(i0,r0,r1)          bcmpi(CS_CC_LE,CS_CC_GE,i0,r0,r1)
 882 #define bler_u(i0,r0,r1)        bcmpr(CS_CC_ULE,i0,r0,r1)
 883 #define blei_u(i0,r0,r1)        bcmpi(CS_CC_ULE,CS_CC_UGE,i0,r0,r1)
 884 #define beqr(i0,r0,r1)          bcmpr(CS_CC_EQ,i0,r0,r1)
 885 #define beqi(i0,r0,r1)          bcmpi(CS_CC_EQ,CS_CC_EQ,i0,r0,r1)
 886 #define bger(i0,r0,r1)          bcmpr(CS_CC_GE,i0,r0,r1)
 887 #define bgei(i0,r0,r1)          bcmpi(CS_CC_GE,CS_CC_LE,i0,r0,r1)
 888 #define bger_u(i0,r0,r1)        bcmpr(CS_CC_UGE,i0,r0,r1)
 889 #define bgei_u(i0,r0,r1)        bcmpi(CS_CC_UGE,CS_CC_ULE,i0,r0,r1)
 890 #define bgtr(i0,r0,r1)          bcmpr(CS_CC_GT,i0,r0,r1)
 891 #define bgti(i0,r0,r1)          bcmpi(CS_CC_GT,CS_CC_LT,i0,r0,r1)
 892 #define bgtr_u(i0,r0,r1)        bcmpr(CS_CC_UGT,i0,r0,r1)
 893 #define bgti_u(i0,r0,r1)        bcmpi(CS_CC_UGT,CS_CC_ULT,i0,r0,r1)
 894 #define bner(i0,r0,r1)          bcmpr(CS_CC_NE,i0,r0,r1)
 895 #define bnei(i0,r0,r1)          bcmpi(CS_CC_NE,CS_CC_NE,i0,r0,r1)
 896 #define bmxr(c,i0,r0,r1)        _bmxr(_jit,c,i0,r0,r1)
 897 static jit_word_t _bmxr(jit_state_t*,jit_bool_t,
 898                         jit_word_t,jit_int32_t,jit_int32_t);
 899 #define bmxi(c,i0,r0,i1)        _bmxi(_jit,c,i0,r0,i1)
 900 static jit_word_t _bmxi(jit_state_t*,jit_bool_t,
 901                         jit_word_t,jit_int32_t,jit_word_t);
 902 #define bmcr(r0,r1,r2)          bmxr(0,r0,r1,r2)
 903 #define bmci(r0,r1,r2)          bmxi(0,r0,r1,r2)
 904 #define bmsr(r0,r1,r2)          bmxr(1,r0,r1,r2)
 905 #define bmsi(r0,r1,r2)          bmxi(1,r0,r1,r2)
 906 #define boaddr(i0,r0,r1)        _boaddr(_jit,i0,r0,r1)
 907 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 908 #define boaddi(i0,r0,i1)        _boaddi(_jit,i0,r0,i1)
 909 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 910 #define boaddr_u(i0,r0,r1)      _boaddr_u(_jit,i0,r0,r1)
 911 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 912 #define boaddi_u(i0,r0,i1)      _boaddi_u(_jit,i0,r0,i1)
 913 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 914 #define bxaddr(i0,r0,r1)        _bxaddr(_jit,i0,r0,r1)
 915 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 916 #define bxaddi(i0,r0,i1)        _bxaddi(_jit,i0,r0,i1)
 917 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 918 #define bxaddr_u(i0,r0,r1)      _bxaddr_u(_jit,i0,r0,r1)
 919 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 920 #define bxaddi_u(i0,r0,i1)      _bxaddi_u(_jit,i0,r0,i1)
 921 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 922 #define bosubr(i0,r0,r1)        _bosubr(_jit,i0,r0,r1)
 923 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 924 #define bosubi(i0,r0,i1)        _bosubi(_jit,i0,r0,i1)
 925 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 926 #define bosubr_u(i0,r0,r1)      _bosubr_u(_jit,i0,r0,r1)
 927 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 928 #define bosubi_u(i0,r0,i1)      _bosubi_u(_jit,i0,r0,i1)
 929 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 930 #define bxsubr(i0,r0,r1)        _bxsubr(_jit,i0,r0,r1)
 931 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 932 #define bxsubi(i0,r0,i1)        _bxsubi(_jit,i0,r0,i1)
 933 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 934 #define bxsubr_u(i0,r0,r1)      _bxsubr_u(_jit,i0,r0,r1)
 935 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 936 #define bxsubi_u(i0,r0,i1)      _bxsubi_u(_jit,i0,r0,i1)
 937 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 938 #define jmpr(r0)                _jmpr(_jit,r0)
 939 static void _jmpr(jit_state_t*,jit_int32_t);
 940 #define jmpi(i0)                _jmpi(_jit,i0)
 941 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
 942 #define jmpi_p(i0)              _jmpi_p(_jit,i0)
 943 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
 944 #define callr(r0)               _callr(_jit,r0)
 945 static void _callr(jit_state_t*,jit_int32_t);
 946 #define calli(i0)               _calli(_jit,i0)
 947 static void _calli(jit_state_t*,jit_word_t);
 948 #define calli_p(i0)             _calli_p(_jit,i0)
 949 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 950 #define prolog(node)            _prolog(_jit, node)
 951 static void _prolog(jit_state_t*, jit_node_t*);
 952 #define epilog(node)            _epilog(_jit, node)
 953 static void _epilog(jit_state_t*, jit_node_t*);
 954 #define vastart(r0)             _vastart(_jit, r0)
 955 static void _vastart(jit_state_t*, jit_int32_t);
 956 #define vaarg(r0, r1)           _vaarg(_jit, r0, r1)
 957 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 958 #define patch_at(i,l)           _patch_at(_jit,i,l)
 959 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 960
 961 #  define NEED_FALLBACK_CASX 1
 962 #endif
 963
 964 #if CODE
 965 /* from binutils bfd/libhppa.h */
 966 static inline int
 967 sign_extend (int x, int len)
 968 {
 969   int signbit = (1 << (len - 1));
 970   int mask = (signbit << 1) - 1;
 971   return ((x & mask) ^ signbit) - signbit;
 972 }
 973
 974 static inline int
 975 sign_unext (int x, int len)
 976 {
 977   int len_ones;
 978
 979   len_ones = (1 << len) - 1;
 980
 981   return x & len_ones;
 982 }
 983
 984 static inline int
 985 low_sign_unext (int x, int len)
 986 {
 987   int temp;
 988   int sign;
 989
 990   sign = (x >> (len-1)) & 1;
 991
 992   temp = sign_unext (x, len-1);
 993
 994   return (temp << 1) | sign;
 995 }
 996
 997 static inline int
 998 re_assemble_3 (int as3)
 999 {
1000   return ((  (as3 & 4) << (13-2))
1001           | ((as3 & 3) << (13+1)));
1002 }
1003
1004 static inline int
1005 re_assemble_12 (int as12)
1006 {
1007   return ((  (as12 & 0x800) >> 11)
1008           | ((as12 & 0x400) >> (10 - 2))
1009           | ((as12 & 0x3ff) << (1 + 2)));
1010 }
1011
1012 static inline int
1013 re_assemble_16 (int as16)
1014 {
1015   int s, t;
1016
1017   /* Unusual 16-bit encoding, for wide mode only.  */
1018   t = (as16 << 1) & 0xffff;
1019   s = (as16 & 0x8000);
1020   return (t ^ s ^ (s >> 1)) | (s >> 15);
1021 }
1022
1023 static inline int
1024 re_assemble_17 (int as17)
1025 {
1026   return ((  (as17 & 0x10000) >> 16)
1027           | ((as17 & 0x0f800) << (16 - 11))
1028           | ((as17 & 0x00400) >> (10 - 2))
1029           | ((as17 & 0x003ff) << (1 + 2)));
1030 }
1031
1032 static inline int
1033 re_assemble_21 (int as21)
1034 {
1035   return ((  (as21 & 0x100000) >> 20)
1036           | ((as21 & 0x0ffe00) >> 8)
1037           | ((as21 & 0x000180) << 7)
1038           | ((as21 & 0x00007c) << 14)
1039           | ((as21 & 0x000003) << 12));
1040 }
1041
1042 static inline int
1043 re_assemble_22 (int as22)
1044 {
1045   return ((  (as22 & 0x200000) >> 21)
1046           | ((as22 & 0x1f0000) << (21 - 16))
1047           | ((as22 & 0x00f800) << (16 - 11))
1048           | ((as22 & 0x000400) >> (10 - 2))
1049           | ((as22 & 0x0003ff) << (1 + 2)));
1050 }
1051
1052 static void
1053 _f1(jit_state_t *_jit, jit_int32_t o,
1054     jit_int32_t b, jit_int32_t t, jit_int32_t i)
1055 {
1056     assert(!(o  & ~0x3f));
1057     assert(!(b  & ~0x1f));
1058     assert(!(t  & ~0x1f));
1059     assert(i >= -8192 && i <= 8191);
1060     ii((o<<26)|(b<<21)|(t<<16)|(re_assemble_16(i)));
1061 }
1062
1063 static void
1064 _f2(jit_state_t *_jit, jit_int32_t o,
1065     jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
1066 {
1067     assert(!(o  & ~0x3f));
1068     assert(!(b  & ~0x1f));
1069     assert(!(t  & ~0x1f));
1070     assert(i >= -32768 && i <= 32767);
1071     assert(!(j  &  ~0x3));
1072     ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
1073 }
1074
1075 static void
1076 _f3(jit_state_t *_jit, jit_int32_t o,
1077     jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
1078 {
1079     assert(!(o  & ~0x3f));
1080     assert(!(b  & ~0x1f));
1081     assert(!(t  & ~0x1f));
1082     assert(i >= -32768 && i <= 32767);
1083     assert(!(j  &  ~0x1));
1084     ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
1085 }
1086
1087 static void
1088 _f4(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1089     jit_int32_t x, jit_int32_t s, jit_int32_t u, jit_int32_t y,
1090     jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
1091 {
1092     assert(!(o  & ~0x3f));
1093     assert(!(b  & ~0x1f));
1094     assert(!(x  & ~0x1f));
1095     assert(!(s  &  ~0x3));
1096     assert(!(u  &  ~0x1));
1097     assert(!(y  &  ~0x1));
1098     assert(!(c  &  ~0x3));
1099     assert(!(z  &  ~0xf));
1100     assert(!(m  &  ~0x1));
1101     assert(!(t  & ~0x1f));
1102     ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(u<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
1103 }
1104
1105 static void
1106 _f5(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1107     jit_int32_t i, jit_int32_t s, jit_int32_t a, jit_int32_t y,
1108     jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
1109 {
1110     assert(!(o  & ~0x3f));
1111     assert(!(b  & ~0x1f));
1112     assert(!(s  &  ~0x3));
1113     assert(!(a  &  ~0x1));
1114     assert(!(y  &  ~0x1));
1115     assert(!(c  &  ~0x3));
1116     assert(!(z  &  ~0xf));
1117     assert(!(m  &  ~0x1));
1118     assert(i >= -16 && i <= 15);
1119     ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|
1120        (s<<14)|(a<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
1121 }
1122
1123 static void
1124 _f6(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1125     jit_int32_t r, jit_int32_t s, jit_int32_t a, jit_int32_t x,
1126     jit_int32_t c, jit_int32_t y, jit_int32_t m, jit_int32_t i)
1127 {
1128     assert(!(o  & ~0x3f));
1129     assert(!(b  & ~0x1f));
1130     assert(!(s  &  ~0x3));
1131     assert(!(a  &  ~0x1));
1132     assert(!(x  &  ~0x1));
1133     assert(!(c  &  ~0x3));
1134     assert(!(y  &  ~0xf));
1135     assert(!(m  &  ~0x1));
1136     assert(i >= -16 && i <= 15);
1137     ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(a<<13)|
1138        (x<<12)|(c<<10)|(y<<6)|(m<<5)|low_sign_unext(i,5));
1139 }
1140
1141 static void
1142 _f7(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t i)
1143 {
1144     assert(!(o  & ~0x3f));
1145     assert(!(r  & ~0x1f));
1146     assert(!(i  &  0x7ff));
1147     ii((o<<26)|(r<<21)|re_assemble_21(i>>11));
1148 }
1149
1150 static void
1151 _f8(jit_state_t *_jit, jit_int32_t o,
1152     jit_int32_t r2, jit_int32_t r1, jit_int32_t cf,
1153     jit_int32_t e1, jit_int32_t x, jit_int32_t e2,
1154     jit_int32_t e3, jit_int32_t d, jit_int32_t t)
1155 {
1156     assert(!(o  & ~0x3f));
1157     assert(!(r2 & ~0x1f));
1158     assert(!(r1 & ~0x1f));
1159     assert(!(cf &  ~0xf));
1160     assert(!(e1 &  ~0x3));
1161     assert(!(x  &  ~0x1));
1162     assert(!(e2 &  ~0x3));
1163     assert(!(e3 &  ~0x3));
1164     assert(!(d  &  ~0x1));
1165     assert(!(t  & ~0x1f));
1166     ii((o<<26)|(r2<<21)|(r1<<16)|(cf<<12)|
1167        (e1<<10)|(x<<9)|(e2<<8)|(e3<<6)|(d<<5)|t);
1168 }
1169
1170 static void
1171 _f9(jit_state_t *_jit,
1172     jit_int32_t o, jit_int32_t r, jit_int32_t t,
1173     jit_int32_t cf, jit_int32_t e1, jit_int32_t i)
1174 {
1175     assert(!(o  & ~0x3f));
1176     assert(!(r  & ~0x1f));
1177     assert(!(t  & ~0x1f));
1178     assert(!(cf &  ~0xf));
1179     assert(!(e1 &  ~0x1));
1180     assert(i >= -2048 && i <= 2047);
1181     ii((o<<26)|(r<<21)|(t<<16)|(cf<<12)|(e1<<11)|low_sign_unext(i,11));
1182 }
1183
1184 static void
1185 _f10(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1186      jit_int32_t r1, jit_int32_t u, jit_int32_t v, jit_int32_t w,
1187      jit_int32_t x, jit_int32_t sa, jit_int32_t y, jit_int32_t t)
1188 {
1189     assert(!(o  & ~0x3f));
1190     assert(!(r2 & ~0x1f));
1191     assert(!(r1 & ~0x1f));
1192     assert(!(u  &  ~0x1));
1193     assert(!(v  &  ~0x3));
1194     assert(!(w  &  ~0x1));
1195     assert(!(x  &  ~0x3));
1196     assert(!(sa &  ~0xf));
1197     assert(!(y  &  ~0x1));
1198     assert(!(t  & ~0x1f));
1199     ii((o<<26)|(r2<<21)|(r1<<16)|(u<<15)|
1200        (v<<13)|(w<<12)|(x<<10)|(sa<<6)|(y<<5)|t);
1201 }
1202
1203 static void
1204 _f11(jit_state_t *_jit, jit_int32_t o,
1205      jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
1206      jit_int32_t y, jit_int32_t z, jit_int32_t u, jit_int32_t t)
1207 {
1208     assert(!(o  & ~0x3f));
1209     assert(!(r1 & ~0x1f));
1210     assert(!(r2 & ~0x1f));
1211     assert(!(c  &  ~0x7));
1212     assert(!(x  &  ~0x3));
1213     assert(!(y  &  ~0x1));
1214     assert(!(z  &  ~0x1));
1215     assert(!(u  &  ~0xf));
1216     assert(!(t  & ~0x1f));
1217     ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<11)|(y<<10)|(z<<9)|(u<<5)|t);
1218 }
1219
1220 static void
1221 _f12(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1222      jit_int32_t t, jit_int32_t c, jit_int32_t x, jit_int32_t se,
1223      jit_int32_t y, jit_int32_t c1, jit_int32_t z, jit_int32_t clen)
1224 {
1225     assert(!(o    & ~0x3f));
1226     assert(!(r    & ~0x1f));
1227     assert(!(t    & ~0x1f));
1228     assert(!(c    &  ~0x7));
1229     assert(!(x    &  ~0x3));
1230     assert(!(se   &  ~0x1));
1231     assert(!(y    &  ~0x1));
1232     assert(!(c1   &  ~0x1));
1233     assert(!(z    &  ~0x7));
1234     assert(!((32-clen) & ~0x1f));
1235     ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(x<<11)|
1236        (se<<10)|(y<<9)|(c1<<8)|(z<<5)|(32-clen));
1237 }
1238
1239 static void
1240 _f13(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1241      jit_int32_t r, jit_int32_t c, jit_int32_t x,
1242      jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
1243 {
1244     assert(!(o    & ~0x3f));
1245     assert(!(t    & ~0x1f));
1246     assert(!(r    & ~0x1f));
1247     assert(!(c    &  ~0x7));
1248     assert(!(x    &  ~0x3));
1249     assert(!(nz   &  ~0x1));
1250     assert(!(c1   &  ~0x1));
1251     assert(!((32-clen) & ~0x1f));
1252     ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
1253        (x<<11)|(nz<<10)|(c1<<8)|(32-clen));
1254 }
1255
1256 static void
1257 _f13x(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1258       jit_int32_t i, jit_int32_t c, jit_int32_t x,
1259       jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
1260 {
1261     assert(!(o    & ~0x3f));
1262     assert(!(t    & ~0x1f));
1263     assert(i >= -16 && i <= 15);
1264     assert(!(c    &  ~0x7));
1265     assert(!(x    &  ~0x3));
1266     assert(!(nz   &  ~0x1));
1267     assert(!((32-clen) & ~0x1f));
1268     ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|
1269        (c<<13)|(x<<11)|(nz<<10)|(c1<<8)|(32-clen));
1270 }
1271
1272 static void
1273 _f14(jit_state_t *_jit, jit_int32_t o,
1274      jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
1275      jit_int32_t cp, jit_int32_t y, jit_int32_t cpos, jit_int32_t t)
1276 {
1277     assert(!(o    & ~0x3f));
1278     assert(!(r1   & ~0x1f));
1279     assert(!(r2   & ~0x1f));
1280     assert(!(c    &  ~0x7));
1281     assert(!(x    &  ~0x3));
1282     assert(!(cp   &  ~0x1));
1283     assert(!(y    &  ~0x1));
1284     assert(!(cpos & ~0x1f));
1285     assert(!(t    & ~0x1f));
1286     ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<12)|(cp<<11)|(y<<10)|(cpos<<5)|t);
1287 }
1288
1289 static void
1290 _f15(jit_state_t *_jit, jit_int32_t o,
1291      jit_int32_t r, jit_int32_t t, jit_int32_t c, jit_int32_t c1,
1292      jit_int32_t p, jit_int32_t se, jit_int32_t pos, jit_int32_t clen)
1293 {
1294     assert(!(o    & ~0x3f));
1295     assert(!(r    & ~0x1f));
1296     assert(!(t    & ~0x1f));
1297     assert(!(c    &  ~0x7));
1298     assert(!(c1   &  ~0x1));
1299     assert(!(p    &  ~0x1));
1300     assert(!(se   &  ~0x1));
1301     assert(!(pos  & ~0x1f));
1302     assert(!((32-clen) & ~0x1f));
1303     ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(c1<<12)|
1304        (p<<11)|(se<<10)|(pos<<5)|(32-clen));
1305 }
1306
1307 static void
1308 _f16(jit_state_t *_jit, jit_int32_t o,
1309      jit_int32_t t, jit_int32_t r, jit_int32_t c, jit_int32_t c1,
1310      jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
1311 {
1312     assert(!(o    & ~0x3f));
1313     assert(!(t    & ~0x1f));
1314     assert(!(r    & ~0x1f));
1315     assert(!(c    &  ~0x7));
1316     assert(!(c1   &  ~0x1));
1317     assert(!(cp   &  ~0x1));
1318     assert(!(nz   &  ~0x1));
1319     assert(!(cpos & ~0x1f));
1320     assert(!((32-clen) & ~0x3f));
1321     ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
1322        (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
1323 }
1324
1325 static void
1326 _f16x(jit_state_t *_jit, jit_int32_t o,
1327       jit_int32_t t, jit_int32_t i, jit_int32_t c, jit_int32_t c1,
1328       jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
1329 {
1330     assert(!(o    & ~0x3f));
1331     assert(!(t    & ~0x1f));
1332     assert(i >= -16 && i <= 15);
1333     assert(!(c    &  ~0x7));
1334     assert(!(c1   &  ~0x1));
1335     assert(!(cp   &  ~0x1));
1336     assert(!(nz   &  ~0x1));
1337     assert(!(cpos & ~0x1f));
1338     assert(!((32-clen) & ~0x3f));
1339     ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|(c<<13)|
1340        (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
1341 }
1342
1343 static void
1344 _f17(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1345      jit_int32_t r1, jit_int32_t c, jit_int32_t i, jit_int32_t n)
1346 {
1347     assert(!(o  & ~0x3f));
1348     assert(!(r2 & ~0x1f));
1349     assert(!(r1 & ~0x1f));
1350     assert(!(c  &  ~0x7));
1351     assert(i >= -2048 && i <= 2047);
1352     assert(!(n  &   ~0x1));
1353     ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|re_assemble_12(i)|(n<<1));
1354 }
1355
1356 static void
1357 _f17x(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1358       jit_int32_t i, jit_int32_t c, jit_int32_t t, jit_int32_t n)
1359 {
1360     assert(!(o & ~0x3f));
1361     assert(!(r & ~0x1f));
1362     assert(i >= -16 && i <= 15);
1363     assert(!(c &  ~0x7));
1364     assert(t >= -2048 && t <= 2047);
1365     assert(!(n &  ~0x1));
1366     ii((o<<26)|(r<<21)|
1367        (low_sign_unext(i,5)<<16)|(c<<13)|re_assemble_12(t)|(n<<1));
1368 }
1369
1370 static void
1371 _f18(jit_state_t *_jit, jit_int32_t o, jit_int32_t p,
1372      jit_int32_t r, jit_int32_t c, jit_int32_t i, jit_int32_t n)
1373 {
1374     assert(!(o & ~0x3f));
1375     assert(!(p & ~0x1f));
1376     assert(!(r & ~0x1f));
1377     assert(!(c &  ~0x1));
1378     assert(i >= -2048 && i <= 2047);
1379     assert(!(n &  ~0x1));
1380     ii((o<<26)|(p<<21)|(r<<16)|(c<<15)|(1<<14)|re_assemble_12(i)|(n<<1));
1381 }
1382
1383 static void
1384 _f19(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1385      jit_int32_t s, jit_int32_t i, jit_int32_t n)
1386 {
1387     assert(!(o & ~0x3f));
1388     assert(!(b & ~0x1f));
1389     assert(!(s &  ~0x7));
1390     assert(i >= -65536 && i <= 65535);
1391     assert(!(n &  ~0x1));
1392     ii((o<<26)|(b<<21)|re_assemble_3(s)|re_assemble_17(i)|(n<<1));
1393 }
1394
1395 static void
1396 _f20(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1397      jit_int32_t i, jit_int32_t g, jit_int32_t n)
1398 {
1399     assert(!(o & ~0x3f));
1400     assert(!(t & ~0x1f));
1401     assert(i >= -32768 && i <= 32767);
1402     assert(!(g &  ~0x7));
1403     assert(!(n &  ~0x1));
1404     ii((o<<26)|(t<<21)|(g<<13)|re_assemble_17(i)|(n<<1));
1405 }
1406
1407 static void
1408 _f21(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1409      jit_int32_t x, jit_int32_t y, jit_int32_t n)
1410 {
1411     assert(!(o & ~0x3f));
1412     assert(!(t & ~0x1f));
1413     assert(!(x & ~0x1f));
1414     assert(!(y &  ~0x7));
1415     assert(!(n &  ~0x1));
1416     ii((o<<26)|(t<<21)|(x<<16)|(y<<13)|(n<<1));
1417 }
1418
1419 static void
1420 _f22(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1421      jit_int32_t x, jit_int32_t r, jit_int32_t n, jit_int32_t p)
1422 {
1423     assert(!(o & ~0x3f));
1424     assert(!(b & ~0x1f));
1425     assert(!(x &  ~0x7));
1426     assert(!(r & ~0x3f));
1427     assert(!(n &  ~0x1));
1428     assert(!(p &  ~0x1));
1429     ii((o<<26)|(b<<21)|(x<<13)|(1<<12)|(r<<2)|(n<<1)|p);
1430 }
1431
1432 static void
1433 _f23(jit_state_t *_jit, jit_int32_t o,
1434      jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t d,
1435      jit_int32_t e, jit_int32_t f, jit_int32_t g, jit_int32_t h)
1436 {
1437     assert(!(o &  ~0x3f));
1438     assert(!(a &  ~0x1f));
1439     assert(!(b &  ~0x1f));
1440     assert(!(c &   ~0x7));
1441     assert(!(d &   ~0x1));
1442     assert(!(e & ~0x1ff));
1443     assert(!(f &   ~0x1));
1444     assert(!(g &   ~0x1));
1445     assert(!(h &   ~0x1));
1446     ii((o<<26)|(a<<21)|(b<<16)|(c<<13)|(d<<12)|(e<<3)|(f<<2)|(g<<1)|h);
1447 }
1448
1449 static void
1450 _f24(jit_state_t *_jit, jit_int32_t o,
1451      jit_int32_t b, jit_int32_t x, jit_int32_t s,
1452      jit_int32_t y, jit_int32_t m,jit_int32_t r)
1453 {
1454     assert(!(o &  ~0x3f));
1455     assert(!(b &  ~0x1f));
1456     assert(!(x &  ~0x1f));
1457     assert(!(s &   ~0x3));
1458     assert(!(y &  ~0xff));
1459     assert(!(m &   ~0x1));
1460     assert(!(r &  ~0x1f));
1461     ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(y<<6)|(m<<5)|r);
1462 }
1463
1464 static void
1465 _f25(jit_state_t *_jit, jit_int32_t o,
1466      jit_int32_t b, jit_int32_t i, jit_int32_t s,
1467      jit_int32_t y, jit_int32_t m, jit_int32_t r)
1468 {
1469     assert(!(o &  ~0x3f));
1470     assert(!(b &  ~0x1f));
1471     assert(i >= -16 && i <= 15);
1472     assert(!(s &   ~0x3));
1473     assert(!(y &  ~0xff));
1474     assert(!(m &   ~0x1));
1475     assert(!(r &  ~0x1f));
1476     ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(s<<14)|(y<<6)|(m<<5)|r);
1477 }
1478
1479 static void
1480 _f26(jit_state_t *_jit, jit_int32_t o,
1481      jit_int32_t b, jit_int32_t x, jit_int32_t s,
1482      jit_int32_t y, jit_int32_t m,jit_int32_t r)
1483 {
1484     assert(!(o &  ~0x3f));
1485     assert(!(b &  ~0x1f));
1486     assert(!(x &  ~0x1f));
1487     assert(!(s &   ~0x7));
1488     assert(!(y &  ~0x7f));
1489     assert(!(m &   ~0x1));
1490     assert(!(r &  ~0x1f));
1491     ii((o<<26)|(b<<21)|(x<<16)|(s<<13)|(y<<6)|(m<<5)|r);
1492 }
1493
1494 static void
1495 _f27(jit_state_t *_jit, jit_int32_t o, jit_int32_t i, jit_int32_t j)
1496 {
1497     assert(!(o & ~0x3f));
1498     assert(i >= -4096 && i < 4095);
1499     assert(j >=   -16 && j <   15);
1500     ii((o<<26)|(i<<13)|j);
1501 }
1502
1503 static void
1504 _f28(jit_state_t *_jit, jit_int32_t o, jit_int32_t i)
1505 {
1506     assert(!(o &      ~0x3f));
1507     assert(!(i & ~0x1ffffff));
1508     ii((o<<26)|i);
1509 }
1510
1511 static void
1512 _f29(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1513      jit_int32_t x, jit_int32_t s, jit_int32_t y, jit_int32_t t)
1514 {
1515     assert(!(o & ~0x3f));
1516     assert(!(r & ~0x1f));
1517     assert(!(x & ~0x1f));
1518     assert(!(s &  ~0x7));
1519     assert(!(y & ~0xff));
1520     assert(!(t & ~0x1f));
1521     ii((o<<26)|(r<<21)|(x<<16)|re_assemble_3(s)|(y<<5)|t);
1522 }
1523
1524 static void
1525 _f30(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, jit_int32_t r,
1526      jit_int32_t s, jit_int32_t x, jit_int32_t y, jit_int32_t t)
1527 {
1528     assert(!(o & ~0x3f));
1529     assert(!(b & ~0x1f));
1530     assert(!(r & ~0x1f));
1531     assert(!(s &  ~0x3));
1532     assert(!(x &  ~0x1));
1533     assert(!(y & ~0xff));
1534     assert(!(t & ~0x1f));
1535     ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(x<<13)|(y<<5)|t);
1536 }
1537
1538 static void
1539 _f31(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1540      jit_int32_t r, jit_int32_t v, jit_int32_t x, jit_int32_t y)
1541 {
1542     assert(!(o & ~0x3f));
1543     assert(!(t & ~0x1f));
1544     assert(!(r & ~0x1f));
1545     assert(!(v & ~0x1f));
1546     assert(!(x & ~0xff));
1547     assert(!(y & ~0x1f));
1548     ii((o<<26)|(t<<21)|(r<<16)|(v<<14)|(x<<5)|y);
1549 }
1550
1551 static void
1552 _f33(jit_state_t *_jit, jit_int32_t o, jit_int32_t x,
1553      jit_int32_t r, jit_int32_t y, jit_int32_t z, jit_int32_t u)
1554 {
1555     assert(!(o & ~0x3f));
1556     assert(!(x & ~0x1f));
1557     assert(!(r & ~0x1f));
1558     assert(!(y &  ~0x7));
1559     assert(!(z & ~0xff));
1560     assert(!(u & ~0x1f));
1561     ii((o<<26)|(x<<21)|(r<<16)|(y<<13)|(z<<5)|u);
1562 }
1563
1564 static void
1565 _f34(jit_state_t *_jit, jit_int32_t o, jit_int32_t o1,
1566      jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1567 {
1568     assert(!(o  &   ~0x3f));
1569     assert(!(o1 & ~0x7fff));
1570     assert(!(x  &    ~0x3));
1571     assert(!(sf &    ~0x7));
1572     assert(!(n  &    ~0x1));
1573     assert(!(o2 &   ~0x1f));
1574     ii((o<<26)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1575 }
1576
1577 static void
1578 _f35(jit_state_t *_jit, jit_int32_t o, jit_int32_t op,
1579      jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t t)
1580 {
1581     assert(!(o  &   ~0x3f));
1582     assert(!(op & ~0x7fff));
1583     assert(!(x  &    ~0x3));
1584     assert(!(sf &    ~0x7));
1585     assert(!(n  &    ~0x1));
1586     assert(!(t  &   ~0x1f));
1587     ii((o<<26)|(op<<11)|(x<<9)|(sf<<6)|(n<<5)|t);
1588 }
1589
1590 static void
1591 _f36(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t o1,
1592      jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1593 {
1594     assert(!(o  &  ~0x3f));
1595     assert(!(r  &  ~0x1f));
1596     assert(!(o1 & ~0x3ff));
1597     assert(!(x  &   ~0x3));
1598     assert(!(sf &   ~0x7));
1599     assert(!(n  &   ~0x1));
1600     assert(!(o2 &  ~0x1f));
1601     ii((o<<26)|(r<<21)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1602 }
1603
1604 static void
1605 _f37(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1606      jit_int32_t r1, jit_int32_t o1, jit_int32_t x,
1607      jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1608 {
1609     assert(!(o  & ~0x3f));
1610     assert(!(r2 & ~0x1f));
1611     assert(!(r1 & ~0x1f));
1612     assert(!(o1 & ~0x1f));
1613     assert(!(x  &  ~0x3));
1614     assert(!(sf &  ~0x7));
1615     assert(!(n  &  ~0x1));
1616     assert(!(o2 & ~0x1f));
1617     ii((o<<26)|(r2<<21)|(r1<<16)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1618 }
1619
1620 static void
1621 _f38(jit_state_t *_jit, jit_int32_t o,
1622      jit_int32_t s, jit_int32_t u, jit_int32_t n)
1623 {
1624     assert(!(o &     ~0x3f));
1625     assert(!(s & ~0x3fffff));
1626     assert(!(u &      ~0x7));
1627     assert(!(n &      ~0x1));
1628     ii((o<<26)|((s>>5)<<9)|(u<<6)|(n<<1)|(s&0x1f));
1629 }
1630
1631 static void
1632 _nop(jit_state_t *_jit, jit_int32_t i0)
1633 {
1634     for (; i0 > 0; i0 -= 4)
1635         NOP();
1636     assert(i0 == 0);
1637 }
1638
1639 static void
1640 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1641 {
1642     if (r0 != r1)
1643         COPY(r1, r0);
1644 }
1645
1646 static void
1647 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1648 {
1649     if (i0 >= -8192 && i0 <= 8191)
1650         LDI(i0, r0);
1651     else if (!(i0 & 0x7ff))
1652         LDIL(i0, r0);
1653     else {
1654         LDIL(i0 & ~0x7ff, r0);
1655         LDO(i0 & 0x7ff, r0, r0);
1656     }
1657 }
1658
1659 static jit_word_t
1660 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1661 {
1662     jit_word_t          w;
1663     w = _jit->pc.w;
1664     LDIL(i0 & ~0x7ff, r0);
1665     LDO(i0 & 0x7ff, r0, r0);
1666     return (w);
1667 }
1668
1669 static void
1670 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1671 {
1672     jit_int32_t         reg;
1673     if (r0 == r1) {
1674         reg = jit_get_reg(jit_class_gpr);
1675         movr(rn(reg), r1);
1676         EXTRWR_U(rn(reg), 23, 8, r0);
1677         DEPWR(rn(reg), 23, 8, r0);
1678         jit_unget_reg(reg);
1679     }
1680     else {
1681         EXTRWR_U(r1, 23, 8, r0);
1682         DEPWR(r1, 23, 8, r0);
1683     }
1684 }
1685
1686 static void
1687 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1688 {
1689     jit_int32_t         reg;
1690     if (r0 == r1) {
1691         reg = jit_get_reg(jit_class_gpr);
1692         movr(rn(reg), r1);
1693         SHRPWI(rn(reg), rn(reg), 16, r0);
1694         DEPWR(r0, 15, 8, r0);
1695         SHRPWI(rn(reg), r0, 8, r0);
1696         jit_unget_reg(reg);
1697     }
1698     else {
1699         SHRPWI(r1, r1, 16, r0);
1700         DEPWR(r0, 15, 8, r0);
1701         SHRPWI(r1, r0, 8, r0);
1702     }
1703 }
1704
1705 static void
1706 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1707 {
1708     jit_word_t  w;
1709     w = beqi(_jit->pc.w, r2, 0);
1710     COPY(r1, r0);
1711     patch_at(w, _jit->pc.w);
1712 }
1713
1714 static void
1715 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1716 {
1717     jit_word_t  w;
1718     w = bnei(_jit->pc.w, r2, 0);
1719     COPY(r1, r0);
1720     patch_at(w, _jit->pc.w);
1721 }
1722
1723 static void
1724 _extr(jit_state_t *_jit,
1725       jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1726 {
1727     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1728     if ( i1 == __WORDSIZE)
1729         movr(r0, r1);
1730     else {
1731 #  if __BYTE_ORDER == __BIG_ENDIAN
1732         i0 = __WORDSIZE - (i0 + i1);
1733 #  endif
1734         EXTRWR(r1, 32 - (i0 + 1), i1, r0);
1735     }
1736 }
1737
1738 static void
1739 _extr_u(jit_state_t *_jit,
1740         jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1741 {
1742     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1743     if (i1 == __WORDSIZE)
1744         movr(r0, r1);
1745     else {
1746 #  if __BYTE_ORDER == __BIG_ENDIAN
1747         i0 = __WORDSIZE - (i0 + i1);
1748 #  endif
1749         EXTRWR_U(r1, 32 - (i0 + 1), i1, r0);
1750     }
1751 }
1752
1753 static void
1754 _depr(jit_state_t *_jit,
1755       jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
1756 {
1757     jit_int32_t         t0;
1758     jit_word_t          mask;
1759     assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1760     if (i1 == __WORDSIZE)
1761         movr(r0, r1);
1762     else {
1763 #  if __BYTE_ORDER == __BIG_ENDIAN
1764         i0 = __WORDSIZE - (i0 + i1);
1765 #  endif
1766         DEPWR(r1, 32 - (i0 + 1), i1, r0);
1767     }
1768 }
1769
1770 static void
1771 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1772       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1773 {
1774 #if defined(__linux__) && defined(SYS_atomic_cmpxchg_32) &&  __WORDSIZE == 32
1775     /* Not defined, and unlikely to ever be defined, but could be a way to do it */
1776     movi(_R26_REGNO, SYS_atomic_cmpxchg_32);
1777     if (r1 == _NOREG)
1778         movi(_R25_REGNO, i0);
1779     else
1780         movr(_R25_REGNO, r1);
1781     movr(_R24_REGNO, r2);
1782     movr(_R23_REGNO, r3);
1783     /* Should only fail for an invalid or unaligned address.
1784      * Do not handle this condition. */
1785     calli(syscall);
1786     movr(r0, _R28_REGNO);
1787 #else
1788     /*
1789      * The only atomic operations are LDCW and LDCD, that load a value,
1790      * and store zero at the address atomically. The (semaphore) address
1791      * must be 16 byte aligned.
1792      */
1793     fallback_casx(r0, r1, r2, r3, i0);
1794     /*
1795      * It is important to be aware of the delayed nature of cache flush and
1796      *  purge operations, and to use SYNC instructions to force completion
1797      * where necessary. The following example illustrates this.
1798      * Consider two processes sharing a memory location x which is protected
1799      * by a semaphore s.
1800      *
1801      * process A on Processor 1 |  process B on Processor 2 |  note
1802      * -------------------------+---------------------------+------------
1803      * LDCW s                   |                           | A acquires semaphore
1804      * PDC x                    |                           | A executes purge
1805      * SYNC                     |                           | Force completion of purge
1806      * STW s                    |                           | A releases semaphore
1807      *                          | LDCW s                    | B acquires semaphore
1808      *                          | STW x
1809      *
1810      * In the absence of the SYNC instruction, it would be possible for
1811      *  process B's store to x to complete before the purge of x is completed
1812      * (since the purge may have been delayed). The purge of x could then
1813      * destroy the new value.
1814      */
1815 #endif
1816 }
1817
1818 static void
1819 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1820 {
1821     jit_int32_t         reg;
1822     if (i0 >= -1024 && i0 <= 1023)
1823         ADDI(i0, r1, r0);
1824     else {
1825         reg = jit_get_reg(jit_class_gpr);
1826         movi(rn(reg), i0);
1827         addr(r0, r1, rn(reg));
1828         jit_unget_reg(reg);
1829     }
1830 }
1831
1832 static void
1833 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1834 {
1835     jit_int32_t         reg;
1836     reg = jit_get_reg(jit_class_gpr);
1837     movi(rn(reg), i0);
1838     addcr(r0, r1, rn(reg));
1839     jit_unget_reg(reg);
1840 }
1841
1842 static void
1843 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1844 {
1845     jit_int32_t         reg;
1846     reg = jit_get_reg(jit_class_gpr);
1847     movi(rn(reg), i0);
1848     addxr(r0, r1, rn(reg));
1849     jit_unget_reg(reg);
1850 }
1851
1852 static void
1853 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1854 {
1855     jit_int32_t         reg;
1856     if (i0 >= -1023 && i0 <= 1024)
1857         addi(r0, r1, -i0);
1858     else {
1859         reg = jit_get_reg(jit_class_gpr);
1860         movi(rn(reg), i0);
1861         subr(r0, r1, rn(reg));
1862         jit_unget_reg(reg);
1863     }
1864 }
1865
1866 static void
1867 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1868 {
1869     jit_int32_t         reg;
1870     reg = jit_get_reg(jit_class_gpr);
1871     movi(rn(reg), i0);
1872     subcr(r0, r1, rn(reg));
1873     jit_unget_reg(reg);
1874 }
1875
1876 static void
1877 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1878 {
1879     jit_int32_t         reg;
1880     reg = jit_get_reg(jit_class_gpr);
1881     movi(rn(reg), i0);
1882     subxr(r0, r1, rn(reg));
1883     jit_unget_reg(reg);
1884 }
1885
1886 static void
1887 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1888 {
1889     jit_int32_t         reg;
1890     if (i0 >= -1024 && i0 <= 1023)
1891         SUBI(i0, r1, r0);
1892     else {
1893         reg = jit_get_reg(jit_class_gpr);
1894         movi(rn(reg), i0);
1895         subr(r0, rn(reg), r1);
1896         jit_unget_reg(reg);
1897     }
1898 }
1899
1900 static void
1901 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1902 {
1903     jit_int32_t         t0, t1;
1904     t0 = jit_get_reg(jit_class_fpr);
1905     t1 = jit_get_reg(jit_class_fpr);
1906     stxi(alloca_offset - 8, _FP_REGNO, r1);
1907     ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1908     stxi(alloca_offset - 8, _FP_REGNO, r2);
1909     ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1910     XMPYU(rn(t0), rn(t1), rn(t0));
1911     stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1912     ldxi(r0, _FP_REGNO, alloca_offset - 4);
1913     jit_unget_reg(t1);
1914     jit_unget_reg(t0);
1915 }
1916
1917 static void
1918 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1919 {
1920     jit_int32_t         reg;
1921     if (r0 != r1) {
1922         movi(r0, i0);
1923         mulr(r0, r1, r0);
1924     }
1925     else {
1926         reg = jit_get_reg(jit_class_gpr);
1927         movi(rn(reg), i0);
1928         mulr(r0, r1, rn(reg));
1929         jit_unget_reg(reg);
1930     }
1931 }
1932
1933 static long long
1934 __llmul(int u, int v)
1935 {
1936     return ((long long)u * (long long)v);
1937 }
1938
1939 static void
1940 _qmulr(jit_state_t *_jit,
1941        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1942 {
1943     movr(_R26_REGNO, r2);
1944     movr(_R25_REGNO, r3);
1945     calli((jit_word_t)__llmul);
1946     if (r0 != JIT_NOREG)
1947         movr(r0, _R29_REGNO);
1948     movr(r1, _R28_REGNO);
1949 }
1950
1951 static void
1952 _qmuli(jit_state_t *_jit,
1953        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1954 {
1955     movr(_R26_REGNO, r2);
1956     movi(_R25_REGNO, i0);
1957     calli((jit_word_t)__llmul);
1958     if (r0 != JIT_NOREG)
1959         movr(r0, _R29_REGNO);
1960     movr(r1, _R28_REGNO);
1961 }
1962
1963 static void
1964 _qmulr_u(jit_state_t *_jit,
1965          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1966 {
1967     jit_int32_t         t0, t1;
1968     t0 = jit_get_reg(jit_class_fpr);
1969     t1 = jit_get_reg(jit_class_fpr);
1970     stxi(alloca_offset - 8, _FP_REGNO, r2);
1971     ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1972     stxi(alloca_offset - 8, _FP_REGNO, r3);
1973     ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1974     XMPYU(rn(t0), rn(t1), rn(t0));
1975     stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1976     if (r0 != JIT_NOREG)
1977         ldxi(r0, _FP_REGNO, alloca_offset - 4);
1978     ldxi(r1, _FP_REGNO, alloca_offset - 8);
1979     jit_unget_reg(t1);
1980     jit_unget_reg(t0);
1981 }
1982
1983 static void
1984 _qmuli_u(jit_state_t *_jit,
1985          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1986 {
1987     jit_int32_t         reg;
1988     reg = jit_get_reg(jit_class_gpr);
1989     movi(rn(reg), i0);
1990     qmulr_u(r0, r1, r2, rn(reg));
1991     jit_unget_reg(reg);
1992 }
1993
1994 static int
1995 __idiv(int u, int v)
1996 {
1997     return (u / v);
1998 }
1999
2000 static void
2001 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2002 {
2003     movr(_R26_REGNO, r1);
2004     movr(_R25_REGNO, r2);
2005     calli((jit_word_t)__idiv);
2006     movr(r0, _R28_REGNO);
2007 }
2008
2009 static void
2010 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2011 {
2012     movr(_R26_REGNO, r1);
2013     movi(_R25_REGNO, i0);
2014     calli((jit_word_t)__idiv);
2015     movr(r0, _R28_REGNO);
2016 }
2017
2018 static unsigned int
2019 __udiv(unsigned int u, unsigned int v)
2020 {
2021     return (u / v);
2022 }
2023
2024 static void
2025 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2026 {
2027     movr(_R26_REGNO, r1);
2028     movr(_R25_REGNO, r2);
2029     calli((jit_word_t)__udiv);
2030     movr(r0, _R28_REGNO);
2031 }
2032
2033 static void
2034 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2035 {
2036     movr(_R26_REGNO, r1);
2037     movi(_R25_REGNO, i0);
2038     calli((jit_word_t)__udiv);
2039     movr(r0, _R28_REGNO);
2040 }
2041
2042 static int
2043 __irem(int u, int v)
2044 {
2045     return (u % v);
2046 }
2047
2048 static void
2049 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2050 {
2051     movr(_R26_REGNO, r1);
2052     movr(_R25_REGNO, r2);
2053     calli((jit_word_t)__irem);
2054     movr(r0, _R28_REGNO);
2055 }
2056
2057 static void
2058 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2059 {
2060     movr(_R26_REGNO, r1);
2061     movi(_R25_REGNO, i0);
2062     calli((jit_word_t)__irem);
2063     movr(r0, _R28_REGNO);
2064 }
2065
2066 static unsigned int
2067 __urem(unsigned int u, unsigned int v)
2068 {
2069     return (u % v);
2070 }
2071
2072 static void
2073 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2074 {
2075     movr(_R26_REGNO, r1);
2076     movr(_R25_REGNO, r2);
2077     calli((jit_word_t)__urem);
2078     movr(r0, _R28_REGNO);
2079 }
2080
2081 static void
2082 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2083 {
2084     movr(_R26_REGNO, r1);
2085     movi(_R25_REGNO, i0);
2086     calli((jit_word_t)__urem);
2087     movr(r0, _R28_REGNO);
2088 }
2089
2090 static idiv_t
2091 __idivrem(int u, int v)
2092 {
2093     idiv_t      div;
2094     div.quo = u / v;
2095     div.rem = u % v;
2096     return (div);
2097 }
2098
2099 static void
2100 _qdivr(jit_state_t *_jit,
2101        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2102 {
2103     movr(_R26_REGNO, r2);
2104     movr(_R25_REGNO, r3);
2105     calli((jit_word_t)__idivrem);
2106     movr(r0, _R28_REGNO);
2107     movr(r1, _R29_REGNO);
2108 }
2109
2110 static void
2111 _qdivi(jit_state_t *_jit,
2112        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2113 {
2114     movr(_R26_REGNO, r2);
2115     movi(_R25_REGNO, i0);
2116     calli((jit_word_t)__idivrem);
2117     movr(r0, _R28_REGNO);
2118     movr(r1, _R29_REGNO);
2119 }
2120
2121 static udiv_t
2122 __udivrem(unsigned int u, unsigned int v)
2123 {
2124     udiv_t      div;
2125     div.quo = u / v;
2126     div.rem = u % v;
2127     return (div);
2128 }
2129
2130 static void
2131 _qdivr_u(jit_state_t *_jit,
2132          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2133 {
2134     movr(_R26_REGNO, r2);
2135     movr(_R25_REGNO, r3);
2136     calli((jit_word_t)__udivrem);
2137     movr(r0, _R28_REGNO);
2138     movr(r1, _R29_REGNO);
2139 }
2140
2141 static void
2142 _qdivi_u(jit_state_t *_jit,
2143          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2144 {
2145     movr(_R26_REGNO, r2);
2146     movi(_R25_REGNO, i0);
2147     calli((jit_word_t)__udivrem);
2148     movr(r0, _R28_REGNO);
2149     movr(r1, _R29_REGNO);
2150 }
2151
2152 static void
2153 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2154 {
2155     jit_int32_t         reg;
2156     reg = jit_get_reg(jit_class_gpr);
2157     movi(rn(reg), i0);
2158     andr(r0, r1, rn(reg));
2159     jit_unget_reg(reg);
2160 }
2161
2162 static void
2163 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2164 {
2165     jit_int32_t         reg;
2166     reg = jit_get_reg(jit_class_gpr);
2167     movi(rn(reg), i0);
2168     orr(r0, r1, rn(reg));
2169     jit_unget_reg(reg);
2170 }
2171
2172 static void
2173 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2174 {
2175     jit_int32_t         reg;
2176     reg = jit_get_reg(jit_class_gpr);
2177     movi(rn(reg), i0);
2178     xorr(r0, r1, rn(reg));
2179     jit_unget_reg(reg);
2180 }
2181
2182 static void
2183 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2184 {
2185     SUBI(0x1f, r2, _R1_REGNO);
2186     MTSAR(_R1_REGNO);
2187     DEPW_Z(r1, 32, r0);
2188 }
2189
2190 static void
2191 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2192 {
2193     SUBI(0x1f, r2, _R1_REGNO);
2194     MTSAR(_R1_REGNO);
2195     EXTRW(r1, 32, r0);
2196 }
2197
2198 static void
2199 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2200 {
2201     SUBI(0x1f, r2, _R1_REGNO);
2202     MTSAR(_R1_REGNO);
2203     EXTRW_U(r1, 32, r0);
2204 }
2205
2206 static void
2207 _lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2208 {
2209     fallback_lrotr(r0, r1, r2);
2210 }
2211
2212 static void
2213 _rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2214 {
2215     fallback_rrotr(r0, r1, r2);
2216 }
2217
2218 static void
2219 _rroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_word_t i0)
2220 {
2221     movr(r0, r1);
2222     SHRPWI(r0, r0, i0, r0);
2223 }
2224
2225 static void
2226 _cmpr(jit_state_t *_jit, jit_word_t c,
2227       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2228 {
2229     CMPCLR_(c, r1, r2, r0);
2230     LDI(1, r0);
2231 }
2232
2233 static void
2234 _cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2235       jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2236 {
2237     jit_int32_t         reg;
2238     if (i0 >= -16 && i0 <= 15)
2239         CMPICLR_(ci, i0, r1, r0);
2240     else {
2241         reg = jit_get_reg(jit_class_gpr);
2242         movi(rn(reg), i0);
2243         CMPCLR_(c, r1, rn(reg), r0);
2244         jit_unget_reg(reg);
2245     }
2246     LDI(1, r0);
2247 }
2248
2249 static void
2250 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2251 {
2252     ldr_uc(r0, r1);
2253     extr_c(r0, r0);
2254 }
2255
2256 static void
2257 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2258 {
2259     ldi_uc(r0, i0);
2260     extr_c(r0, r0);
2261 }
2262
2263 static void
2264 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2265 {
2266     ldxr_uc(r0, r1, r2);
2267     extr_c(r0, r0);
2268 }
2269
2270 static void
2271 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2272 {
2273     ldxi_uc(r0, r1, i0);
2274     extr_c(r0, r0);
2275 }
2276
2277 static void
2278 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2279 {
2280     jit_int32_t         reg;
2281     if (jit_imm_idx_p()) {
2282         if (i0 >= -8182 && i0 <= 8191)
2283             LDBL(i0, _R0_REGNO, r0);
2284         else {
2285             reg = jit_get_reg(jit_class_gpr);
2286             LDIL(i0 & ~0x7ff, rn(reg));
2287             LDBL(sign_extend(i0, 11), rn(reg), r0);
2288             jit_unget_reg(reg);
2289         }
2290     }
2291     else {
2292         reg = jit_get_reg(jit_class_gpr);
2293         movi(rn(reg), i0);
2294         ldr_uc(r0, rn(reg));
2295         jit_unget_reg(reg);
2296     }
2297 }
2298
2299 static void
2300 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2301 {
2302     jit_int32_t         reg;
2303     if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
2304         LDBI(i0, r1, r0);
2305     else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
2306         LDBL(i0, r1, r0);
2307     else {
2308         reg = jit_get_reg(jit_class_gpr);
2309         movi(rn(reg), i0);
2310         ldxr_uc(r0, r1, rn(reg));
2311         jit_unget_reg(reg);
2312     }
2313 }
2314
2315 static void
2316 _ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2317 {
2318     ldr_us(r0, r1);
2319     extr_s(r0, r0);
2320 }
2321
2322 static void
2323 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2324 {
2325     ldi_us(r0, i0);
2326     extr_s(r0, r0);
2327 }
2328
2329 static void
2330 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2331 {
2332     ldxr_us(r0, r1, r2);
2333     extr_s(r0, r0);
2334 }
2335
2336 static void
2337 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2338 {
2339     ldxi_us(r0, r1, i0);
2340     extr_s(r0, r0);
2341 }
2342
2343 static void
2344 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2345 {
2346     jit_int32_t         reg;
2347     if (jit_imm_idx_p()) {
2348         if (i0 >= -8182 && i0 <= 8191)
2349             LDHL(i0, _R0_REGNO, r0);
2350         else {
2351             reg = jit_get_reg(jit_class_gpr);
2352             LDIL(i0 & ~0x7ff, rn(reg));
2353             LDHL(sign_extend(i0, 11), rn(reg), r0);
2354             jit_unget_reg(reg);
2355         }
2356     }
2357     else {
2358         reg = jit_get_reg(jit_class_gpr);
2359         movi(rn(reg), i0);
2360         ldr_us(r0, rn(reg));
2361         jit_unget_reg(reg);
2362     }
2363 }
2364
2365 static void
2366 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2367 {
2368     jit_int32_t         reg;
2369     if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
2370         LDHI(i0, r1, r0);
2371     else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
2372         LDHL(i0, r1, r0);
2373     else {
2374         reg = jit_get_reg(jit_class_gpr);
2375         movi(rn(reg), i0);
2376         ldxr_us(r0, r1, rn(reg));
2377         jit_unget_reg(reg);
2378     }
2379 }
2380
2381 static void
2382 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2383 {
2384     jit_int32_t         reg;
2385     if (jit_imm_idx_p()) {
2386         if (i0 >= -8182 && i0 <= 8191)
2387             LDWL(i0, _R0_REGNO, r0);
2388         else {
2389             reg = jit_get_reg(jit_class_gpr);
2390             LDIL(i0 & ~0x7ff, rn(reg));
2391             LDWL(sign_extend(i0, 11), rn(reg), r0);
2392             jit_unget_reg(reg);
2393         }
2394     }
2395     else {
2396         reg = jit_get_reg(jit_class_gpr);
2397         movi(rn(reg), i0);
2398         ldr_ui(r0, rn(reg));
2399         jit_unget_reg(reg);
2400     }
2401 }
2402
2403 static void
2404 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2405 {
2406     jit_int32_t         reg;
2407     if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
2408         LDWI(i0, r1, r0);
2409     else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
2410         LDWL(i0, r1, r0);
2411     else {
2412         reg = jit_get_reg(jit_class_gpr);
2413         movi(rn(reg), i0);
2414         ldxr_ui(r0, r1, rn(reg));
2415         jit_unget_reg(reg);
2416     }
2417 }
2418
2419 static void
2420 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2421 {
2422     jit_int32_t         reg;
2423     if (jit_imm_idx_p()) {
2424         if (i0 >= -8182 && i0 <= 8191)
2425             STBL(r0, i0, _R0_REGNO);
2426         else {
2427             reg = jit_get_reg(jit_class_gpr);
2428             LDIL(i0 & ~0x7ff, rn(reg));
2429             STBL(r0, sign_extend(i0, 11), rn(reg));
2430             jit_unget_reg(reg);
2431         }
2432     }
2433     else {
2434         reg = jit_get_reg(jit_class_gpr);
2435         movi(rn(reg), i0);
2436         str_c(rn(reg), r0);
2437         jit_unget_reg(reg);
2438     }
2439 }
2440
2441 static void
2442 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2443 {
2444     jit_int32_t         reg;
2445     reg = jit_get_reg(jit_class_gpr);
2446     addr(rn(reg), r0, r1);
2447     str_c(rn(reg), r2);
2448     jit_unget_reg(reg);
2449 }
2450
2451 static void
2452 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2453 {
2454     jit_int32_t         reg;
2455     if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
2456         STBI(r1, i0, r0);
2457     else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
2458         STBL(r1, i0, r0);
2459     else {
2460         reg = jit_get_reg(jit_class_gpr);
2461         addi(rn(reg), r0, i0);
2462         str_c(rn(reg), r1);
2463         jit_unget_reg(reg);
2464     }
2465 }
2466
2467 static void
2468 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2469 {
2470     jit_int32_t         reg;
2471     if (jit_imm_idx_p()) {
2472         if (i0 >= -8182 && i0 <= 8191)
2473             STHL(r0, i0, _R0_REGNO);
2474         else {
2475             reg = jit_get_reg(jit_class_gpr);
2476             LDIL(i0 & ~0x7ff, rn(reg));
2477             STHL(r0, sign_extend(i0, 11), rn(reg));
2478             jit_unget_reg(reg);
2479         }
2480     }
2481     else {
2482         reg = jit_get_reg(jit_class_gpr);
2483         movi(rn(reg), i0);
2484         str_s(rn(reg), r0);
2485         jit_unget_reg(reg);
2486     }
2487 }
2488
2489 static void
2490 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2491 {
2492     jit_int32_t         reg;
2493     reg = jit_get_reg(jit_class_gpr);
2494     addr(rn(reg), r0, r1);
2495     str_s(rn(reg), r2);
2496     jit_unget_reg(reg);
2497 }
2498
2499 static void
2500 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2501 {
2502     jit_int32_t         reg;
2503     if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
2504         STHI(r1, i0, r0);
2505     else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
2506         STHL(r1, i0, r0);
2507     else {
2508         reg = jit_get_reg(jit_class_gpr);
2509         addi(rn(reg), r0, i0);
2510         str_s(rn(reg), r1);
2511         jit_unget_reg(reg);
2512     }
2513 }
2514
2515 static void
2516 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2517 {
2518     jit_int32_t         reg;
2519     if (jit_imm_idx_p()) {
2520         if (i0 >= -8182 && i0 <= 8191)
2521             STWL(r0, i0, _R0_REGNO);
2522         else {
2523             reg = jit_get_reg(jit_class_gpr);
2524             LDIL(i0 & ~0x7ff, rn(reg));
2525             STWL(r0, sign_extend(i0, 11), rn(reg));
2526             jit_unget_reg(reg);
2527         }
2528     }
2529     else {
2530         reg = jit_get_reg(jit_class_gpr);
2531         movi(rn(reg), i0);
2532         str_i(rn(reg), r0);
2533         jit_unget_reg(reg);
2534     }
2535 }
2536
2537 static void
2538 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2539 {
2540     jit_int32_t         reg;
2541     reg = jit_get_reg(jit_class_gpr);
2542     addr(rn(reg), r0, r1);
2543     str_i(rn(reg), r2);
2544     jit_unget_reg(reg);
2545 }
2546
2547 static void
2548 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2549 {
2550     jit_int32_t         reg;
2551     if (jit_imm_idx_p() && (i0 >= -16 && i0 <= 15))
2552         STWI(r1, i0, r0);
2553     else if (jit_imm_idx_p() && (i0 >= -8182 && i0 <= 8191))
2554         STWL(r1, i0, r0);
2555     else {
2556         reg = jit_get_reg(jit_class_gpr);
2557         addi(rn(reg), r0, i0);
2558         str_i(rn(reg), r1);
2559         jit_unget_reg(reg);
2560     }
2561 }
2562
2563 static jit_word_t
2564 _bcmpr(jit_state_t *_jit, jit_word_t c,
2565        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2566 {
2567     jit_word_t          w;
2568     w = _jit->pc.w;
2569     CMPB_N_(c, r0, r1, ((i0 - w) >> 2) - 2);
2570     NOP();
2571     return (w);
2572 }
2573
2574 static jit_word_t
2575 _bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2576        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2577 {
2578     jit_word_t          w;
2579     jit_int32_t         reg;
2580     if (i1 >= -16 && i1 <= 15) {
2581         w = _jit->pc.w;
2582         CMPIB_N_(ci, i1, r0, ((i0 - w) >> 2) - 2);
2583     }
2584     else {
2585         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2586         movi(rn(reg), i1);
2587         w = _jit->pc.w;
2588         CMPB_N_(c, r0, rn(reg), ((i0 - w) >> 2) - 2);
2589         jit_unget_reg(reg);
2590     }
2591     NOP();
2592     return (w);
2593 }
2594
2595 static jit_word_t
2596 _bmxr(jit_state_t *_jit, jit_bool_t c,
2597       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2598 {
2599     jit_word_t          w;
2600     jit_int32_t         reg;
2601     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2602     andr(rn(reg), r0, r1);
2603     w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2604     jit_unget_reg(reg);
2605     return (w);
2606 }
2607
2608 static jit_word_t
2609 _bmxi(jit_state_t *_jit, jit_bool_t c,
2610       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2611 {
2612     jit_word_t          w;
2613     jit_int32_t         reg;
2614     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2615     movi(rn(reg), i1);
2616     andr(rn(reg), r0, rn(reg));
2617     w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2618     jit_unget_reg(reg);
2619     return (w);
2620 }
2621
2622 static jit_word_t
2623 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2624 {
2625     jit_word_t          w;
2626     w = _jit->pc.w;
2627     ADDB_N_SV(r1, r0, ((i0 - w) >> 2) - 2);
2628     NOP();
2629     return (w);
2630 }
2631
2632 static jit_word_t
2633 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2634 {
2635     jit_word_t          w;
2636     jit_int32_t         reg;
2637     if (i1 >= -16 && i1 <= 15) {
2638         w = _jit->pc.w;
2639         ADDIB_N_SV(i1, r0, ((i0 - w) >> 2) - 2);
2640         NOP();
2641     }
2642     else {
2643         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2644         movi(rn(reg), i1);
2645         w = boaddr(i0, r0, rn(reg));
2646         jit_unget_reg(reg);
2647     }
2648     return (w);
2649 }
2650
2651 static jit_word_t
2652 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2653 {
2654     jit_word_t          w;
2655     w = _jit->pc.w;
2656     ADDB_N_UV(r1, r0, ((i0 - w) >> 2) - 2);
2657     NOP();
2658     return (w);
2659 }
2660
2661 static jit_word_t
2662 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2663 {
2664     jit_word_t          w;
2665     jit_int32_t         reg;
2666     if (i1 >= -16 && i1 <= 15) {
2667         w = _jit->pc.w;
2668         ADDIB_N_UV(i1, r0, ((i0 - w) >> 2) - 2);
2669         NOP();
2670     }
2671     else {
2672         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2673         movi(rn(reg), i1);
2674         w = boaddr_u(i0, r0, rn(reg));
2675         jit_unget_reg(reg);
2676     }
2677     return (w);
2678 }
2679
2680 static jit_word_t
2681 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2682 {
2683     jit_word_t          w;
2684     w = _jit->pc.w;
2685     ADDB_N_NSV(r1, r0, ((i0 - w) >> 2) - 2);
2686     NOP();
2687     return (w);
2688 }
2689
2690 static jit_word_t
2691 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2692 {
2693     jit_word_t          w;
2694     jit_int32_t         reg;
2695     if (i1 >= -16 && i1 <= 15) {
2696         w = _jit->pc.w;
2697         ADDIB_N_NSV(i1, r0, ((i0 - w) >> 2) - 2);
2698         NOP();
2699     }
2700     else {
2701         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2702         movi(rn(reg), i1);
2703         w = bxaddr(i0, r0, rn(reg));
2704         jit_unget_reg(reg);
2705     }
2706     return (w);
2707 }
2708
2709 static jit_word_t
2710 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2711 {
2712     jit_word_t          w;
2713     w = _jit->pc.w;
2714     ADDB_N_NUV(r1, r0, ((i0 - w) >> 2) - 2);
2715     NOP();
2716     return (w);
2717 }
2718
2719 static jit_word_t
2720 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2721 {
2722     jit_word_t          w;
2723     jit_int32_t         reg;
2724     if (i1 >= -16 && i1 <= 15) {
2725         w = _jit->pc.w;
2726         ADDIB_N_NUV(i1, r0, ((i0 - w) >> 2) - 2);
2727         NOP();
2728     }
2729     else {
2730         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2731         movi(rn(reg), i1);
2732         w = bxaddr_u(i0, r0, rn(reg));
2733         jit_unget_reg(reg);
2734     }
2735     return (w);
2736 }
2737
2738 static jit_word_t
2739 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2740 {
2741     jit_word_t          w;
2742     SUB_NSV(r0, r1, r0);
2743     w = _jit->pc.w;
2744     /* null'ed if no signed overflow */
2745     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2746     NOP();
2747     return (w);
2748 }
2749
2750 static jit_word_t
2751 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2752 {
2753     movi(_R1_REGNO, i1);
2754     return (bosubr(i0, r0, _R1_REGNO));
2755 }
2756
2757 static jit_word_t
2758 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2759 {
2760     SUB(r0, r1, r0);
2761     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2762     return (bnei(i0, _R1_REGNO, 0));
2763 }
2764
2765 static jit_word_t
2766 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2767 {
2768     movi(_R1_REGNO, i1);
2769     SUB(r0, _R1_REGNO, r0);
2770     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2771     return (bnei(i0, _R1_REGNO, 0));
2772 }
2773
2774 static jit_word_t
2775 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2776 {
2777     jit_word_t          w;
2778     SUB_SV(r0, r1, r0);
2779     w = _jit->pc.w;
2780     /* null'ed if signed overflow */
2781     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2782     NOP();
2783     return (w);
2784 }
2785
2786 static jit_word_t
2787 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2788 {
2789     movi(_R1_REGNO, i1);
2790     return (bxsubr(i0, r0, _R1_REGNO));
2791 }
2792
2793 static jit_word_t
2794 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2795 {
2796     SUB(r0, r1, r0);
2797     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2798     return (beqi(i0, _R1_REGNO, 0));
2799 }
2800
2801 static jit_word_t
2802 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2803 {
2804     movi(_R1_REGNO, i1);
2805     SUB(r0, _R1_REGNO, r0);
2806     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2807     return (beqi(i0, _R1_REGNO, 0));
2808 }
2809
2810 static void
2811 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2812 {
2813     BV_N(_R0_REGNO, r0);
2814 }
2815
2816 static jit_word_t
2817 _jmpi(jit_state_t *_jit, jit_word_t i0)
2818 {
2819     jit_word_t          d, w;
2820     w = _jit->pc.w;
2821     d = ((i0 - w) >> 2) - 2;
2822     if (d >= -32768 && d <= 32767)
2823         B_N(d, _R0_REGNO);
2824     else {
2825         movi(_R1_REGNO, d);
2826         BV_N(_R0_REGNO, _R1_REGNO);
2827     }
2828     return (w);
2829 }
2830
2831 static jit_word_t
2832 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2833 {
2834     jit_word_t          w;
2835     w = movi_p(_R1_REGNO, i0);
2836     jmpr(_R1_REGNO);
2837     return (w);
2838 }
2839
2840 static void
2841 _callr(jit_state_t *_jit, jit_int32_t r0)
2842 {
2843     jit_word_t          dyn;
2844     jit_word_t          imm;
2845     if (r0 != _R1_REGNO)
2846         COPY(r0, _R1_REGNO);
2847     /* inline $$dyncall */
2848     imm = _jit->pc.w;
2849     BBI_N_GE(_R1_REGNO, 30, 0);         /*   if (r1 & 2) {              */
2850     DEPWRI(0, 31, 2, _R1_REGNO);        /*      r1 &= ~2;               */
2851     LDWI(4, _R1_REGNO, _R19_REGNO);     /*      r19 = r1[1];            */
2852     LDWI(0, _R1_REGNO, _R1_REGNO);      /*      r1  = r1[0];            */
2853                                         /*   }                          */
2854     BVE_L(_R1_REGNO);
2855     STWL(_RP_REGNO, -24, _SP_REGNO);
2856     dyn = _jit->pc.w;
2857     jmpi(_jit->pc.w);
2858     patch_at(imm, _jit->pc.w);
2859     BVE_L_N(_R1_REGNO);
2860     NOP();
2861     patch_at(dyn, _jit->pc.w);
2862 }
2863
2864 static void
2865 _calli(jit_state_t *_jit, jit_word_t i0)
2866 {
2867     jit_word_t          w;
2868     if (i0 & 2) {
2869         i0 &= -4;
2870         movi(_R1_REGNO, i0);
2871         LDWI(4, _R1_REGNO, _R19_REGNO);
2872         LDWI(0, _R1_REGNO, _R1_REGNO);
2873         BVE_L(_R1_REGNO);
2874         STWL(_RP_REGNO, -24, _SP_REGNO);
2875     }
2876     else {
2877         w = ((i0 - _jit->pc.w) >> 2) - 2;
2878         if (w >= -32768 && w <= 32767)
2879             B_L_N(w);
2880         else {
2881             movi(_R1_REGNO, i0);
2882             BVE_L_N(_R1_REGNO);
2883         }
2884         NOP();
2885     }
2886 }
2887
2888 static jit_word_t
2889 _calli_p(jit_state_t *_jit, jit_word_t i0)
2890 {
2891     jit_word_t          w;
2892     w = movi_p(_R1_REGNO, i0);
2893     callr(_R1_REGNO);
2894     return (w);
2895 }
2896
2897 static jit_int32_t gr[] = {
2898      _R4,  _R5,  _R6,  _R7,  _R8,
2899      _R9, _R10, _R11, _R12, _R13,
2900     _R14, _R15, _R16, _R17, _R18
2901 };
2902
2903 static jit_int32_t fr[] = {
2904     _F12, _F13, _F14, _F15, _F16,
2905     _F17, _F18, _F19, _F20, _F21
2906 };
2907
2908 static void
2909 _prolog(jit_state_t *_jit, jit_node_t *node)
2910 {
2911     jit_int32_t         regno;
2912     jit_word_t          offset;
2913
2914     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2915         /* hppa stack grows up */
2916         assert(_jitc->function->self.aoff <= _jitc->function->frame);
2917         if (_jitc->function->assume_frame)
2918             return;
2919         _jitc->function->self.aoff = _jitc->function->frame;
2920     }
2921     if (_jitc->function->allocar) {
2922         _jitc->function->self.aoff += 63;
2923         _jitc->function->self.aoff &= -64;
2924     }
2925     _jitc->function->stack = ((_jitc->function->self.aoff -
2926                                _jitc->function->self.alen -
2927                                _jitc->function->self.size) + 63) & -64;
2928
2929     /* Save stack frame (FIXME Only required if non leaf) */
2930     STWL(_RP_REGNO, -20, _SP_REGNO);
2931
2932     /* Create stack frame */
2933     COPY(_FP_REGNO, _R1_REGNO);
2934     COPY(_SP_REGNO, _FP_REGNO);
2935     STWL_MA(_R1_REGNO, _jitc->function->stack, _SP_REGNO);
2936
2937     /* Save any modified callee save registers */
2938     offset = alloca_offset - 140;
2939     for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2940         if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2941             stxi(offset, _FP_REGNO, rn(gr[regno]));
2942     }
2943     for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2944         if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2945             stxi_d(offset, _FP_REGNO, rn(fr[regno]));
2946     }
2947
2948     if (_jitc->function->allocar) {
2949         regno = jit_get_reg(jit_class_gpr);
2950         movi(rn(regno), _jitc->function->self.aoff);
2951         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
2952         jit_unget_reg(regno);
2953     }
2954
2955     if (_jitc->function->self.call & jit_call_varargs) {
2956         for (regno = 3; regno >= _jitc->function->vagp; --regno)
2957             stxi(params_offset - regno * 4 - 4, _FP_REGNO, rn(_R26 - regno));
2958     }
2959 }
2960
2961 static void
2962 _epilog(jit_state_t *_jit, jit_node_t *node)
2963 {
2964     jit_int32_t         regno;
2965     jit_word_t          offset;
2966
2967     if (_jitc->function->assume_frame)
2968         return;
2969     /* Restore any modified callee save registers */
2970     offset = alloca_offset - 140;
2971     for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2972         if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2973             ldxi(rn(gr[regno]), _FP_REGNO, offset);
2974     }
2975     for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2976         if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2977             ldxi_d(rn(fr[regno]), _FP_REGNO, offset);
2978     }
2979
2980     /* Restore stack frame (FIXME Only required if non leaf) */
2981     LDWL(-20, _FP_REGNO, _RP_REGNO);
2982     LDO(_jitc->function->stack, _FP_REGNO, _SP_REGNO);
2983     LDWL_MB(-_jitc->function->stack, _SP_REGNO, _FP_REGNO);
2984 #if defined(__hpux)
2985     BVE_N(_RP_REGNO);
2986 #else
2987     BV_N(_R0_REGNO, _RP_REGNO);
2988 #endif
2989 }
2990
2991 static void
2992 _vastart(jit_state_t *_jit, jit_int32_t r0)
2993 {
2994     /* Initialize stack pointer to the first stack argument. */
2995     if (jit_arg_reg_p(_jitc->function->vagp))
2996         addi(r0, _FP_REGNO, params_offset - _jitc->function->vagp * 4);
2997     else
2998         addi(r0, _FP_REGNO, _jitc->function->self.size);
2999 }
3000
3001 static void
3002 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3003 {
3004     assert(_jitc->function->self.call & jit_call_varargs);
3005
3006     /* Update vararg stack pointer. */
3007     subi(r1, r1, 4);
3008
3009     /* Load argument. */
3010     ldr(r0, r1);
3011 }
3012
3013 static void
3014 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3015 {
3016     jit_word_t           w;
3017     union {
3018         jit_uint32_t    *i;
3019         jit_word_t       w;
3020     } u;
3021     u.w = instr;
3022     switch (u.i[0] >> 26) {
3023         case 0x8:                               /* LDIL */
3024             u.i[0] &= ~0x1fffff;
3025             u.i[0] |= re_assemble_21((label & ~0x7ff) >> 11);
3026             assert((u.i[1] >> 26) == 0xd);      /* LDO */
3027             u.i[1] &= ~0xffff;
3028             u.i[1] |= re_assemble_16(label & 0x7ff);
3029             break;
3030         case 0x20:      case 0x22:              /* CMPB */
3031         case 0x21:      case 0x23:              /* CMPIB */
3032         case 0x28:      case 0x2a:              /* ADDB */
3033         case 0x29:      case 0x2b:              /* ADDIB */
3034         case 0x31:                              /* BBI */
3035             w = ((label - instr) >> 2) - 2;
3036             assert(w >= -2048 && w <= 2047);
3037             u.i[0] &= ~0x1ffd;
3038             u.i[0] |= re_assemble_12(w);
3039             break;
3040         case 0x3a:                              /* B */
3041             w = ((label - instr) >> 2) - 2;
3042             assert(w >= -32768 && w <= 32767);
3043             u.i[0] &= ~0x1f1ffd;
3044             u.i[0] |= re_assemble_17(w);
3045             break;
3046         default:
3047             abort();
3048     }
3049 }
3050 #endif