deps/lightning/lib/jit_hppa-cpu.c

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