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 comr(r0,r1)             UADDCM(_R0_REGNO,r1,r0)
 652 #define negr(r0,r1)             SUB(_R0_REGNO,r1,r0)
 653 #define extr_c(r0,r1)           EXTRWR(r1,31,8,r0)
 654 #define extr_uc(r0,r1)          EXTRWR_U(r1,31,8,r0)
 655 #define extr_s(r0,r1)           EXTRWR(r1,31,16,r0)
 656 #define extr_us(r0,r1)          EXTRWR_U(r1,31,16,r0)
 657 #if __BYTE_ORDER == __BIG_ENDIAN
 658 #  define htonr_us(r0,r1)       extr_us(r0,r1)
 659 #  define htonr_ui(r0,r1)       movr(r0,r1)
 660 #else
 661 #  error need htonr implementation
 662 #endif
 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 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1638 {
1639     jit_int32_t         reg;
1640     if (i0 >= -1024 && i0 <= 1023)
1641         ADDI(i0, r1, r0);
1642     else {
1643         reg = jit_get_reg(jit_class_gpr);
1644         movi(rn(reg), i0);
1645         addr(r0, r1, rn(reg));
1646         jit_unget_reg(reg);
1647     }
1648 }
1649
1650 static void
1651 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1652 {
1653     jit_int32_t         reg;
1654     reg = jit_get_reg(jit_class_gpr);
1655     movi(rn(reg), i0);
1656     addcr(r0, r1, rn(reg));
1657     jit_unget_reg(reg);
1658 }
1659
1660 static void
1661 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1662 {
1663     jit_int32_t         reg;
1664     reg = jit_get_reg(jit_class_gpr);
1665     movi(rn(reg), i0);
1666     addxr(r0, r1, rn(reg));
1667     jit_unget_reg(reg);
1668 }
1669
1670 static void
1671 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1672 {
1673     jit_int32_t         reg;
1674     if (i0 >= -1023 && i0 <= 1024)
1675         addi(r0, r1, -i0);
1676     else {
1677         reg = jit_get_reg(jit_class_gpr);
1678         movi(rn(reg), i0);
1679         subr(r0, r1, rn(reg));
1680         jit_unget_reg(reg);
1681     }
1682 }
1683
1684 static void
1685 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1686 {
1687     jit_int32_t         reg;
1688     reg = jit_get_reg(jit_class_gpr);
1689     movi(rn(reg), i0);
1690     subcr(r0, r1, rn(reg));
1691     jit_unget_reg(reg);
1692 }
1693
1694 static void
1695 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1696 {
1697     jit_int32_t         reg;
1698     reg = jit_get_reg(jit_class_gpr);
1699     movi(rn(reg), i0);
1700     subxr(r0, r1, rn(reg));
1701     jit_unget_reg(reg);
1702 }
1703
1704 static void
1705 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1706 {
1707     jit_int32_t         reg;
1708     if (i0 >= -1024 && i0 <= 1023)
1709         SUBI(i0, r1, r0);
1710     else {
1711         reg = jit_get_reg(jit_class_gpr);
1712         movi(rn(reg), i0);
1713         subr(r0, rn(reg), r1);
1714         jit_unget_reg(reg);
1715     }
1716 }
1717
1718 static void
1719 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1720 {
1721     jit_int32_t         t0, t1;
1722     t0 = jit_get_reg(jit_class_fpr);
1723     t1 = jit_get_reg(jit_class_fpr);
1724     stxi(alloca_offset - 8, _FP_REGNO, r1);
1725     ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1726     stxi(alloca_offset - 8, _FP_REGNO, r2);
1727     ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1728     XMPYU(rn(t0), rn(t1), rn(t0));
1729     stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1730     ldxi(r0, _FP_REGNO, alloca_offset - 4);
1731     jit_unget_reg(t1);
1732     jit_unget_reg(t0);
1733 }
1734
1735 static void
1736 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1737 {
1738     jit_int32_t         reg;
1739     if (r0 != r1) {
1740         movi(r0, i0);
1741         mulr(r0, r1, r0);
1742     }
1743     else {
1744         reg = jit_get_reg(jit_class_gpr);
1745         movi(rn(reg), i0);
1746         mulr(r0, r1, rn(reg));
1747         jit_unget_reg(reg);
1748     }
1749 }
1750
1751 static long long
1752 __llmul(int u, int v)
1753 {
1754     return ((long long)u * (long long)v);
1755 }
1756
1757 static void
1758 _qmulr(jit_state_t *_jit,
1759        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1760 {
1761     movr(_R26_REGNO, r2);
1762     movr(_R25_REGNO, r3);
1763     calli((jit_word_t)__llmul);
1764     movr(r0, _R29_REGNO);
1765     movr(r1, _R28_REGNO);
1766 }
1767
1768 static void
1769 _qmuli(jit_state_t *_jit,
1770        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1771 {
1772     movr(_R26_REGNO, r2);
1773     movi(_R25_REGNO, i0);
1774     calli((jit_word_t)__llmul);
1775     movr(r0, _R29_REGNO);
1776     movr(r1, _R28_REGNO);
1777 }
1778
1779 static void
1780 _qmulr_u(jit_state_t *_jit,
1781          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1782 {
1783     jit_int32_t         t0, t1;
1784     t0 = jit_get_reg(jit_class_fpr);
1785     t1 = jit_get_reg(jit_class_fpr);
1786     stxi(alloca_offset - 8, _FP_REGNO, r2);
1787     ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1788     stxi(alloca_offset - 8, _FP_REGNO, r3);
1789     ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1790     XMPYU(rn(t0), rn(t1), rn(t0));
1791     stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1792     ldxi(r0, _FP_REGNO, alloca_offset - 4);
1793     ldxi(r1, _FP_REGNO, alloca_offset - 8);
1794     jit_unget_reg(t1);
1795     jit_unget_reg(t0);
1796 }
1797
1798 static void
1799 _qmuli_u(jit_state_t *_jit,
1800          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1801 {
1802     jit_int32_t         reg;
1803     reg = jit_get_reg(jit_class_gpr);
1804     movi(rn(reg), i0);
1805     qmulr_u(r0, r1, r2, rn(reg));
1806     jit_unget_reg(reg);
1807 }
1808
1809 static int
1810 __idiv(int u, int v)
1811 {
1812     return (u / v);
1813 }
1814
1815 static void
1816 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1817 {
1818     movr(_R26_REGNO, r1);
1819     movr(_R25_REGNO, r2);
1820     calli((jit_word_t)__idiv);
1821     movr(r0, _R28_REGNO);
1822 }
1823
1824 static void
1825 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1826 {
1827     movr(_R26_REGNO, r1);
1828     movi(_R25_REGNO, i0);
1829     calli((jit_word_t)__idiv);
1830     movr(r0, _R28_REGNO);
1831 }
1832
1833 static unsigned int
1834 __udiv(unsigned int u, unsigned int v)
1835 {
1836     return (u / v);
1837 }
1838
1839 static void
1840 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1841 {
1842     movr(_R26_REGNO, r1);
1843     movr(_R25_REGNO, r2);
1844     calli((jit_word_t)__udiv);
1845     movr(r0, _R28_REGNO);
1846 }
1847
1848 static void
1849 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1850 {
1851     movr(_R26_REGNO, r1);
1852     movi(_R25_REGNO, i0);
1853     calli((jit_word_t)__udiv);
1854     movr(r0, _R28_REGNO);
1855 }
1856
1857 static int
1858 __irem(int u, int v)
1859 {
1860     return (u % v);
1861 }
1862
1863 static void
1864 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1865 {
1866     movr(_R26_REGNO, r1);
1867     movr(_R25_REGNO, r2);
1868     calli((jit_word_t)__irem);
1869     movr(r0, _R28_REGNO);
1870 }
1871
1872 static void
1873 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1874 {
1875     movr(_R26_REGNO, r1);
1876     movi(_R25_REGNO, i0);
1877     calli((jit_word_t)__irem);
1878     movr(r0, _R28_REGNO);
1879 }
1880
1881 static unsigned int
1882 __urem(unsigned int u, unsigned int v)
1883 {
1884     return (u % v);
1885 }
1886
1887 static void
1888 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1889 {
1890     movr(_R26_REGNO, r1);
1891     movr(_R25_REGNO, r2);
1892     calli((jit_word_t)__urem);
1893     movr(r0, _R28_REGNO);
1894 }
1895
1896 static void
1897 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1898 {
1899     movr(_R26_REGNO, r1);
1900     movi(_R25_REGNO, i0);
1901     calli((jit_word_t)__urem);
1902     movr(r0, _R28_REGNO);
1903 }
1904
1905 static idiv_t
1906 __idivrem(int u, int v)
1907 {
1908     idiv_t      div;
1909     div.quo = u / v;
1910     div.rem = u % v;
1911     return (div);
1912 }
1913
1914 static void
1915 _qdivr(jit_state_t *_jit,
1916        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1917 {
1918     movr(_R26_REGNO, r2);
1919     movr(_R25_REGNO, r3);
1920     calli((jit_word_t)__idivrem);
1921     movr(r0, _R28_REGNO);
1922     movr(r1, _R29_REGNO);
1923 }
1924
1925 static void
1926 _qdivi(jit_state_t *_jit,
1927        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1928 {
1929     movr(_R26_REGNO, r2);
1930     movi(_R25_REGNO, i0);
1931     calli((jit_word_t)__idivrem);
1932     movr(r0, _R28_REGNO);
1933     movr(r1, _R29_REGNO);
1934 }
1935
1936 static udiv_t
1937 __udivrem(unsigned int u, unsigned int v)
1938 {
1939     udiv_t      div;
1940     div.quo = u / v;
1941     div.rem = u % v;
1942     return (div);
1943 }
1944
1945 static void
1946 _qdivr_u(jit_state_t *_jit,
1947          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1948 {
1949     movr(_R26_REGNO, r2);
1950     movr(_R25_REGNO, r3);
1951     calli((jit_word_t)__udivrem);
1952     movr(r0, _R28_REGNO);
1953     movr(r1, _R29_REGNO);
1954 }
1955
1956 static void
1957 _qdivi_u(jit_state_t *_jit,
1958          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1959 {
1960     movr(_R26_REGNO, r2);
1961     movi(_R25_REGNO, i0);
1962     calli((jit_word_t)__udivrem);
1963     movr(r0, _R28_REGNO);
1964     movr(r1, _R29_REGNO);
1965 }
1966
1967 static void
1968 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1969 {
1970     jit_int32_t         reg;
1971     reg = jit_get_reg(jit_class_gpr);
1972     movi(rn(reg), i0);
1973     andr(r0, r1, rn(reg));
1974     jit_unget_reg(reg);
1975 }
1976
1977 static void
1978 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1979 {
1980     jit_int32_t         reg;
1981     reg = jit_get_reg(jit_class_gpr);
1982     movi(rn(reg), i0);
1983     orr(r0, r1, rn(reg));
1984     jit_unget_reg(reg);
1985 }
1986
1987 static void
1988 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1989 {
1990     jit_int32_t         reg;
1991     reg = jit_get_reg(jit_class_gpr);
1992     movi(rn(reg), i0);
1993     xorr(r0, r1, rn(reg));
1994     jit_unget_reg(reg);
1995 }
1996
1997 static void
1998 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1999 {
2000     SUBI(0x1f, r2, _R1_REGNO);
2001     MTSAR(_R1_REGNO);
2002     DEPW_Z(r1, 32, r0);
2003 }
2004
2005 static void
2006 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2007 {
2008     SUBI(0x1f, r2, _R1_REGNO);
2009     MTSAR(_R1_REGNO);
2010     EXTRW(r1, 32, r0);
2011 }
2012
2013 static void
2014 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2015 {
2016     SUBI(0x1f, r2, _R1_REGNO);
2017     MTSAR(_R1_REGNO);
2018     EXTRW_U(r1, 32, r0);
2019 }
2020
2021 static void
2022 _cmpr(jit_state_t *_jit, jit_word_t c,
2023       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2024 {
2025     CMPCLR_(c, r1, r2, r0);
2026     LDI(1, r0);
2027 }
2028
2029 static void
2030 _cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2031       jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2032 {
2033     jit_int32_t         reg;
2034     if (i0 >= -16 && i0 <= 15)
2035         CMPICLR_(ci, i0, r1, r0);
2036     else {
2037         reg = jit_get_reg(jit_class_gpr);
2038         movi(rn(reg), i0);
2039         CMPCLR_(c, r1, rn(reg), r0);
2040         jit_unget_reg(reg);
2041     }
2042     LDI(1, r0);
2043 }
2044
2045 static void
2046 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2047 {
2048     ldr_uc(r0, r1);
2049     extr_c(r0, r0);
2050 }
2051
2052 static void
2053 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2054 {
2055     ldi_uc(r0, i0);
2056     extr_c(r0, r0);
2057 }
2058
2059 static void
2060 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2061 {
2062     ldxr_uc(r0, r1, r2);
2063     extr_c(r0, r0);
2064 }
2065
2066 static void
2067 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2068 {
2069     ldxi_uc(r0, r1, i0);
2070     extr_c(r0, r0);
2071 }
2072
2073 static void
2074 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2075 {
2076     jit_int32_t         reg;
2077     if (i0 >= -8182 && i0 <= 8191)
2078         LDBL(i0, _R0_REGNO, r0);
2079     else {
2080         reg = jit_get_reg(jit_class_gpr);
2081         LDIL(i0 & ~0x7ff, rn(reg));
2082         LDBL(sign_extend(i0, 11), rn(reg), r0);
2083         jit_unget_reg(reg);
2084     }
2085 }
2086
2087 static void
2088 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2089 {
2090     jit_int32_t         reg;
2091     if (i0 >= -16 && i0 <= 15)
2092         LDBI(i0, r1, r0);
2093     else if (i0 >= -8182 && i0 <= 8191)
2094         LDBL(i0, r1, r0);
2095     else {
2096         reg = jit_get_reg(jit_class_gpr);
2097         movi(rn(reg), i0);
2098         ldxr_uc(r0, r1, rn(reg));
2099         jit_unget_reg(reg);
2100     }
2101 }
2102
2103 static void
2104 _ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2105 {
2106     ldr_us(r0, r1);
2107     extr_s(r0, r0);
2108 }
2109
2110 static void
2111 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2112 {
2113     ldi_us(r0, i0);
2114     extr_s(r0, r0);
2115 }
2116
2117 static void
2118 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2119 {
2120     ldxr_us(r0, r1, r2);
2121     extr_s(r0, r0);
2122 }
2123
2124 static void
2125 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2126 {
2127     ldxi_us(r0, r1, i0);
2128     extr_s(r0, r0);
2129 }
2130
2131 static void
2132 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2133 {
2134     jit_int32_t         reg;
2135     if (i0 >= -8182 && i0 <= 8191)
2136         LDHL(i0, _R0_REGNO, r0);
2137     else {
2138         reg = jit_get_reg(jit_class_gpr);
2139         LDIL(i0 & ~0x7ff, rn(reg));
2140         LDHL(sign_extend(i0, 11), rn(reg), r0);
2141         jit_unget_reg(reg);
2142     }
2143 }
2144
2145 static void
2146 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2147 {
2148     jit_int32_t         reg;
2149     if (i0 >= -16 && i0 <= 15)
2150         LDHI(i0, r1, r0);
2151     else if (i0 >= -8182 && i0 <= 8191)
2152         LDHL(i0, r1, r0);
2153     else {
2154         reg = jit_get_reg(jit_class_gpr);
2155         movi(rn(reg), i0);
2156         ldxr_us(r0, r1, rn(reg));
2157         jit_unget_reg(reg);
2158     }
2159 }
2160
2161 static void
2162 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2163 {
2164     jit_int32_t         reg;
2165     if (i0 >= -8182 && i0 <= 8191)
2166         LDWL(i0, _R0_REGNO, r0);
2167     else {
2168         reg = jit_get_reg(jit_class_gpr);
2169         LDIL(i0 & ~0x7ff, rn(reg));
2170         LDWL(sign_extend(i0, 11), rn(reg), r0);
2171         jit_unget_reg(reg);
2172     }
2173 }
2174
2175 static void
2176 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2177 {
2178     jit_int32_t         reg;
2179     if (i0 >= -16 && i0 <= 15)
2180         LDWI(i0, r1, r0);
2181     else if (i0 >= -8182 && i0 <= 8191)
2182         LDWL(i0, r1, r0);
2183     else {
2184         reg = jit_get_reg(jit_class_gpr);
2185         movi(rn(reg), i0);
2186         ldxr_ui(r0, r1, rn(reg));
2187         jit_unget_reg(reg);
2188     }
2189 }
2190
2191 static void
2192 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2193 {
2194     jit_int32_t         reg;
2195     if (i0 >= -8182 && i0 <= 8191)
2196         STBL(r0, i0, _R0_REGNO);
2197     else {
2198         reg = jit_get_reg(jit_class_gpr);
2199         LDIL(i0 & ~0x7ff, rn(reg));
2200         STBL(r0, sign_extend(i0, 11), rn(reg));
2201         jit_unget_reg(reg);
2202     }
2203 }
2204
2205 static void
2206 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2207 {
2208     jit_int32_t         reg;
2209     reg = jit_get_reg(jit_class_gpr);
2210     addr(rn(reg), r0, r1);
2211     str_c(rn(reg), r2);
2212     jit_unget_reg(reg);
2213 }
2214
2215 static void
2216 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2217 {
2218     jit_int32_t         reg;
2219     if (i0 >= -16 && i0 <= 15)
2220         STBI(r1, i0, r0);
2221     else if (i0 >= -8182 && i0 <= 8191)
2222         STBL(r1, i0, r0);
2223     else {
2224         reg = jit_get_reg(jit_class_gpr);
2225         addi(rn(reg), r0, i0);
2226         str_c(rn(reg), r1);
2227         jit_unget_reg(reg);
2228     }
2229 }
2230
2231 static void
2232 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2233 {
2234     jit_int32_t         reg;
2235     if (i0 >= -8182 && i0 <= 8191)
2236         STHL(r0, i0, _R0_REGNO);
2237     else {
2238         reg = jit_get_reg(jit_class_gpr);
2239         LDIL(i0 & ~0x7ff, rn(reg));
2240         STHL(r0, sign_extend(i0, 11), rn(reg));
2241         jit_unget_reg(reg);
2242     }
2243 }
2244
2245 static void
2246 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2247 {
2248     jit_int32_t         reg;
2249     reg = jit_get_reg(jit_class_gpr);
2250     addr(rn(reg), r0, r1);
2251     str_s(rn(reg), r2);
2252     jit_unget_reg(reg);
2253 }
2254
2255 static void
2256 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2257 {
2258     jit_int32_t         reg;
2259     if (i0 >= -16 && i0 <= 15)
2260         STHI(r1, i0, r0);
2261     else if (i0 >= -8182 && i0 <= 8191)
2262         STHL(r1, i0, r0);
2263     else {
2264         reg = jit_get_reg(jit_class_gpr);
2265         addi(rn(reg), r0, i0);
2266         str_s(rn(reg), r1);
2267         jit_unget_reg(reg);
2268     }
2269 }
2270
2271 static void
2272 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2273 {
2274     jit_int32_t         reg;
2275     if (i0 >= -8182 && i0 <= 8191)
2276         STWL(r0, i0, _R0_REGNO);
2277     else {
2278         reg = jit_get_reg(jit_class_gpr);
2279         LDIL(i0 & ~0x7ff, rn(reg));
2280         STWL(r0, sign_extend(i0, 11), rn(reg));
2281         jit_unget_reg(reg);
2282     }
2283 }
2284
2285 static void
2286 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2287 {
2288     jit_int32_t         reg;
2289     reg = jit_get_reg(jit_class_gpr);
2290     addr(rn(reg), r0, r1);
2291     str_i(rn(reg), r2);
2292     jit_unget_reg(reg);
2293 }
2294
2295 static void
2296 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2297 {
2298     jit_int32_t         reg;
2299     if (i0 >= -16 && i0 <= 15)
2300         STWI(r1, i0, r0);
2301     else if (i0 >= -8182 && i0 <= 8191)
2302         STWL(r1, i0, r0);
2303     else {
2304         reg = jit_get_reg(jit_class_gpr);
2305         addi(rn(reg), r0, i0);
2306         str_i(rn(reg), r1);
2307         jit_unget_reg(reg);
2308     }
2309 }
2310
2311 static jit_word_t
2312 _bcmpr(jit_state_t *_jit, jit_word_t c,
2313        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2314 {
2315     jit_word_t          w;
2316     w = _jit->pc.w;
2317     CMPB_N_(c, r0, r1, ((i0 - w) >> 2) - 2);
2318     NOP();
2319     return (w);
2320 }
2321
2322 static jit_word_t
2323 _bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2324        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2325 {
2326     jit_word_t          w;
2327     jit_int32_t         reg;
2328     if (i1 >= -16 && i1 <= 15) {
2329         w = _jit->pc.w;
2330         CMPIB_N_(ci, i1, r0, ((i0 - w) >> 2) - 2);
2331     }
2332     else {
2333         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2334         movi(rn(reg), i1);
2335         w = _jit->pc.w;
2336         CMPB_N_(c, r0, rn(reg), ((i0 - w) >> 2) - 2);
2337         jit_unget_reg(reg);
2338     }
2339     NOP();
2340     return (w);
2341 }
2342
2343 static jit_word_t
2344 _bmxr(jit_state_t *_jit, jit_bool_t c,
2345       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2346 {
2347     jit_word_t          w;
2348     jit_int32_t         reg;
2349     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2350     andr(rn(reg), r0, r1);
2351     w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2352     jit_unget_reg(reg);
2353     return (w);
2354 }
2355
2356 static jit_word_t
2357 _bmxi(jit_state_t *_jit, jit_bool_t c,
2358       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2359 {
2360     jit_word_t          w;
2361     jit_int32_t         reg;
2362     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2363     movi(rn(reg), i1);
2364     andr(rn(reg), r0, rn(reg));
2365     w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2366     jit_unget_reg(reg);
2367     return (w);
2368 }
2369
2370 static jit_word_t
2371 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2372 {
2373     jit_word_t          w;
2374     w = _jit->pc.w;
2375     ADDB_N_SV(r1, r0, ((i0 - w) >> 2) - 2);
2376     NOP();
2377     return (w);
2378 }
2379
2380 static jit_word_t
2381 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2382 {
2383     jit_word_t          w;
2384     jit_int32_t         reg;
2385     if (i1 >= -16 && i1 <= 15) {
2386         w = _jit->pc.w;
2387         ADDIB_N_SV(i1, r0, ((i0 - w) >> 2) - 2);
2388         NOP();
2389     }
2390     else {
2391         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2392         movi(rn(reg), i1);
2393         w = boaddr(i0, r0, rn(reg));
2394         jit_unget_reg(reg);
2395     }
2396     return (w);
2397 }
2398
2399 static jit_word_t
2400 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2401 {
2402     jit_word_t          w;
2403     w = _jit->pc.w;
2404     ADDB_N_UV(r1, r0, ((i0 - w) >> 2) - 2);
2405     NOP();
2406     return (w);
2407 }
2408
2409 static jit_word_t
2410 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2411 {
2412     jit_word_t          w;
2413     jit_int32_t         reg;
2414     if (i1 >= -16 && i1 <= 15) {
2415         w = _jit->pc.w;
2416         ADDIB_N_UV(i1, r0, ((i0 - w) >> 2) - 2);
2417         NOP();
2418     }
2419     else {
2420         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2421         movi(rn(reg), i1);
2422         w = boaddr_u(i0, r0, rn(reg));
2423         jit_unget_reg(reg);
2424     }
2425     return (w);
2426 }
2427
2428 static jit_word_t
2429 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2430 {
2431     jit_word_t          w;
2432     w = _jit->pc.w;
2433     ADDB_N_NSV(r1, r0, ((i0 - w) >> 2) - 2);
2434     NOP();
2435     return (w);
2436 }
2437
2438 static jit_word_t
2439 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2440 {
2441     jit_word_t          w;
2442     jit_int32_t         reg;
2443     if (i1 >= -16 && i1 <= 15) {
2444         w = _jit->pc.w;
2445         ADDIB_N_NSV(i1, r0, ((i0 - w) >> 2) - 2);
2446         NOP();
2447     }
2448     else {
2449         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2450         movi(rn(reg), i1);
2451         w = bxaddr(i0, r0, rn(reg));
2452         jit_unget_reg(reg);
2453     }
2454     return (w);
2455 }
2456
2457 static jit_word_t
2458 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2459 {
2460     jit_word_t          w;
2461     w = _jit->pc.w;
2462     ADDB_N_NUV(r1, r0, ((i0 - w) >> 2) - 2);
2463     NOP();
2464     return (w);
2465 }
2466
2467 static jit_word_t
2468 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2469 {
2470     jit_word_t          w;
2471     jit_int32_t         reg;
2472     if (i1 >= -16 && i1 <= 15) {
2473         w = _jit->pc.w;
2474         ADDIB_N_NUV(i1, r0, ((i0 - w) >> 2) - 2);
2475         NOP();
2476     }
2477     else {
2478         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2479         movi(rn(reg), i1);
2480         w = bxaddr_u(i0, r0, rn(reg));
2481         jit_unget_reg(reg);
2482     }
2483     return (w);
2484 }
2485
2486 static jit_word_t
2487 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2488 {
2489     jit_word_t          w;
2490     SUB_NSV(r0, r1, r0);
2491     w = _jit->pc.w;
2492     /* null'ed if no signed overflow */
2493     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2494     NOP();
2495     return (w);
2496 }
2497
2498 static jit_word_t
2499 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2500 {
2501     movi(_R1_REGNO, i1);
2502     return (bosubr(i0, r0, _R1_REGNO));
2503 }
2504
2505 static jit_word_t
2506 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2507 {
2508     SUB(r0, r1, r0);
2509     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2510     return (bnei(i0, _R1_REGNO, 0));
2511 }
2512
2513 static jit_word_t
2514 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2515 {
2516     movi(_R1_REGNO, i1);
2517     SUB(r0, _R1_REGNO, r0);
2518     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2519     return (bnei(i0, _R1_REGNO, 0));
2520 }
2521
2522 static jit_word_t
2523 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2524 {
2525     jit_word_t          w;
2526     SUB_SV(r0, r1, r0);
2527     w = _jit->pc.w;
2528     /* null'ed if signed overflow */
2529     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2530     NOP();
2531     return (w);
2532 }
2533
2534 static jit_word_t
2535 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2536 {
2537     movi(_R1_REGNO, i1);
2538     return (bxsubr(i0, r0, _R1_REGNO));
2539 }
2540
2541 static jit_word_t
2542 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2543 {
2544     SUB(r0, r1, r0);
2545     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2546     return (beqi(i0, _R1_REGNO, 0));
2547 }
2548
2549 static jit_word_t
2550 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2551 {
2552     movi(_R1_REGNO, i1);
2553     SUB(r0, _R1_REGNO, r0);
2554     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2555     return (beqi(i0, _R1_REGNO, 0));
2556 }
2557
2558 static void
2559 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2560 {
2561     BV_N(_R0_REGNO, r0);
2562 }
2563
2564 static void
2565 _jmpi(jit_state_t *_jit, jit_word_t i0)
2566 {
2567     jit_word_t          w;
2568     w = ((i0 - _jit->pc.w) >> 2) - 2;
2569     if (w >= -32768 && w <= 32767)
2570         B_N(w, _R0_REGNO);
2571     else {
2572         movi(_R1_REGNO, w);
2573         BV_N(_R0_REGNO, _R1_REGNO);
2574     }
2575 }
2576
2577 static jit_word_t
2578 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2579 {
2580     jit_word_t          w;
2581     w = movi_p(_R1_REGNO, i0);
2582     jmpr(_R1_REGNO);
2583     return (w);
2584 }
2585
2586 static void
2587 _callr(jit_state_t *_jit, jit_int32_t r0)
2588 {
2589     jit_word_t          dyn;
2590     jit_word_t          imm;
2591     if (r0 != _R1_REGNO)
2592         COPY(r0, _R1_REGNO);
2593     /* inline $$dyncall */
2594     imm = _jit->pc.w;
2595     BBI_N_GE(_R1_REGNO, 30, 0);         /*   if (r1 & 2) {              */
2596     DEPWRI(0, 31, 2, _R1_REGNO);        /*      r1 &= ~2;               */
2597     LDWI(4, _R1_REGNO, _R19_REGNO);     /*      r19 = r1[1];            */
2598     LDWI(0, _R1_REGNO, _R1_REGNO);      /*      r1  = r1[0];            */
2599                                         /*   }                          */
2600     BVE_L(_R1_REGNO);
2601     STWL(_RP_REGNO, -24, _SP_REGNO);
2602     dyn = _jit->pc.w;
2603     jmpi(_jit->pc.w);
2604     patch_at(imm, _jit->pc.w);
2605     BVE_L_N(_R1_REGNO);
2606     NOP();
2607     patch_at(dyn, _jit->pc.w);
2608 }
2609
2610 static void
2611 _calli(jit_state_t *_jit, jit_word_t i0)
2612 {
2613     jit_word_t          w;
2614     if (i0 & 2) {
2615         i0 &= -4;
2616         movi(_R1_REGNO, i0);
2617         LDWI(4, _R1_REGNO, _R19_REGNO);
2618         LDWI(0, _R1_REGNO, _R1_REGNO);
2619         BVE_L(_R1_REGNO);
2620         STWL(_RP_REGNO, -24, _SP_REGNO);
2621     }
2622     else {
2623         w = ((i0 - _jit->pc.w) >> 2) - 2;
2624         if (w >= -32768 && w <= 32767)
2625             B_L_N(w);
2626         else {
2627             movi(_R1_REGNO, i0);
2628             BVE_L_N(_R1_REGNO);
2629         }
2630         NOP();
2631     }
2632 }
2633
2634 static jit_word_t
2635 _calli_p(jit_state_t *_jit, jit_word_t i0)
2636 {
2637     jit_word_t          w;
2638     w = movi_p(_R1_REGNO, i0);
2639     callr(_R1_REGNO);
2640     return (w);
2641 }
2642
2643 static jit_int32_t gr[] = {
2644      _R4,  _R5,  _R6,  _R7,  _R8,
2645      _R9, _R10, _R11, _R12, _R13,
2646     _R14, _R15, _R16, _R17, _R18
2647 };
2648
2649 static jit_int32_t fr[] = {
2650     _F12, _F13, _F14, _F15, _F16,
2651     _F17, _F18, _F19, _F20, _F21
2652 };
2653
2654 static void
2655 _prolog(jit_state_t *_jit, jit_node_t *node)
2656 {
2657     jit_int32_t         regno;
2658     jit_word_t          offset;
2659
2660     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2661         /* hppa stack grows up */
2662         assert(_jitc->function->self.aoff <= _jitc->function->frame);
2663         if (_jitc->function->assume_frame)
2664             return;
2665         _jitc->function->self.aoff = _jitc->function->frame;
2666     }
2667     if (_jitc->function->allocar) {
2668         _jitc->function->self.aoff += 63;
2669         _jitc->function->self.aoff &= -64;
2670     }
2671     _jitc->function->stack = ((_jitc->function->self.aoff -
2672                                _jitc->function->self.alen -
2673                                _jitc->function->self.size) + 63) & -64;
2674
2675     /* Save stack frame (FIXME Only required if non leaf) */
2676     STWL(_RP_REGNO, -20, _SP_REGNO);
2677
2678     /* Create stack frame */
2679     COPY(_FP_REGNO, _R1_REGNO);
2680     COPY(_SP_REGNO, _FP_REGNO);
2681     STWL_MA(_R1_REGNO, _jitc->function->stack, _SP_REGNO);
2682
2683     /* Save any modified callee save registers */
2684     offset = alloca_offset - 140;
2685     for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2686         if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2687             stxi(offset, _FP_REGNO, rn(gr[regno]));
2688     }
2689     for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2690         if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2691             stxi_d(offset, _FP_REGNO, rn(fr[regno]));
2692     }
2693
2694     if (_jitc->function->allocar) {
2695         regno = jit_get_reg(jit_class_gpr);
2696         movi(rn(regno), _jitc->function->self.aoff);
2697         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
2698         jit_unget_reg(regno);
2699     }
2700
2701     if (_jitc->function->self.call & jit_call_varargs) {
2702         for (regno = 3; regno >= _jitc->function->vagp; --regno)
2703             stxi(params_offset - regno * 4 - 4, _FP_REGNO, rn(_R26 - regno));
2704     }
2705 }
2706
2707 static void
2708 _epilog(jit_state_t *_jit, jit_node_t *node)
2709 {
2710     jit_int32_t         regno;
2711     jit_word_t          offset;
2712
2713     if (_jitc->function->assume_frame)
2714         return;
2715     /* Restore any modified callee save registers */
2716     offset = alloca_offset - 140;
2717     for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2718         if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2719             ldxi(rn(gr[regno]), _FP_REGNO, offset);
2720     }
2721     for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2722         if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2723             ldxi_d(rn(fr[regno]), _FP_REGNO, offset);
2724     }
2725
2726     /* Restore stack frame (FIXME Only required if non leaf) */
2727     LDWL(-20, _FP_REGNO, _RP_REGNO);
2728     LDO(_jitc->function->stack, _FP_REGNO, _SP_REGNO);
2729     LDWL_MB(-_jitc->function->stack, _SP_REGNO, _FP_REGNO);
2730 #if defined(__hpux)
2731     BVE_N(_RP_REGNO);
2732 #else
2733     BV_N(_R0_REGNO, _RP_REGNO);
2734 #endif
2735 }
2736
2737 static void
2738 _vastart(jit_state_t *_jit, jit_int32_t r0)
2739 {
2740     /* Initialize stack pointer to the first stack argument. */
2741     if (jit_arg_reg_p(_jitc->function->vagp))
2742         addi(r0, _FP_REGNO, params_offset - _jitc->function->vagp * 4);
2743     else
2744         addi(r0, _FP_REGNO, _jitc->function->self.size);
2745 }
2746
2747 static void
2748 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2749 {
2750     assert(_jitc->function->self.call & jit_call_varargs);
2751
2752     /* Update vararg stack pointer. */
2753     subi(r1, r1, 4);
2754
2755     /* Load argument. */
2756     ldr(r0, r1);
2757 }
2758
2759 static void
2760 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2761 {
2762     jit_word_t           w;
2763     union {
2764         jit_uint32_t    *i;
2765         jit_word_t       w;
2766     } u;
2767     u.w = instr;
2768     switch (u.i[0] >> 26) {
2769         case 0x8:                               /* LDIL */
2770             u.i[0] &= ~0x1fffff;
2771             u.i[0] |= re_assemble_21((label & ~0x7ff) >> 11);
2772             assert((u.i[1] >> 26) == 0xd);      /* LDO */
2773             u.i[1] &= ~0xffff;
2774             u.i[1] |= re_assemble_16(label & 0x7ff);
2775             break;
2776         case 0x20:      case 0x22:              /* CMPB */
2777         case 0x21:      case 0x23:              /* CMPIB */
2778         case 0x28:      case 0x2a:              /* ADDB */
2779         case 0x29:      case 0x2b:              /* ADDIB */
2780         case 0x31:                              /* BBI */
2781             w = ((label - instr) >> 2) - 2;
2782             assert(w >= -2048 && w <= 2047);
2783             u.i[0] &= ~0x1ffd;
2784             u.i[0] |= re_assemble_12(w);
2785             break;
2786         case 0x3a:                              /* B */
2787             w = ((label - instr) >> 2) - 2;
2788             assert(w >= -32768 && w <= 32767);
2789             u.i[0] &= ~0x1f1ffd;
2790             u.i[0] |= re_assemble_17(w);
2791             break;
2792         default:
2793             abort();
2794     }
2795 }
2796 #endif