deps/lightning/lib/jit_hppa-cpu.c

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