deps/lightning/lib/jit_hppa-cpu.c

   1 /*
   2  * Copyright (C) 2013-2023  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 typedef struct idiv {
  22     int                 quo;
  23     int                 rem;
  24 } idiv_t;
  25
  26 typedef struct udiv {
  27     unsigned int        quo;
  28     unsigned int        rem;
  29 } udiv_t;
  30
  31 /* 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 bswapr_us(r0, r1)             _bswapr_us(_jit, r0, r1)
 652 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
 653 #  define bswapr_ui(r0, r1)             _bswapr_ui(_jit, r0, r1)
 654 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 655 #  define movnr(r0,r1,r2)               _movnr(_jit,r0,r1,r2)
 656 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 657 #  define movzr(r0,r1,r2)               _movzr(_jit,r0,r1,r2)
 658 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 659 #  define casx(r0, r1, r2, r3, i0)      _casx(_jit, r0, r1, r2, r3, i0)
 660 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 661                   jit_int32_t,jit_int32_t,jit_word_t);
 662 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 663 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 664 #define comr(r0,r1)             UADDCM(_R0_REGNO,r1,r0)
 665 #define negr(r0,r1)             SUB(_R0_REGNO,r1,r0)
 666 #define extr_c(r0,r1)           EXTRWR(r1,31,8,r0)
 667 #define extr_uc(r0,r1)          EXTRWR_U(r1,31,8,r0)
 668 #define extr_s(r0,r1)           EXTRWR(r1,31,16,r0)
 669 #define extr_us(r0,r1)          EXTRWR_U(r1,31,16,r0)
 670 #define addr(r0,r1,r2)          ADD(r1,r2,r0)
 671 #define addi(r0,r1,i0)          _addi(_jit,r0,r1,i0)
 672 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 673 #define addcr(r0,r1,r2)         addr(r0,r1,r2)
 674 #define addci(r0,r1,i0)         _addci(_jit,r0,r1,i0)
 675 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 676 #define addxr(r0,r1,r2)         ADD_C(r1,r2,r0)
 677 #define addxi(r0,r1,i0)         _addxi(_jit,r0,r1,i0)
 678 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 679 #define subr(r0,r1,r2)          SUB(r1,r2,r0)
 680 #define subi(r0,r1,i0)          _subi(_jit,r0,r1,i0)
 681 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 682 #define subcr(r0,r1,r2)         subr(r0,r1,r2)
 683 #define subci(r0,r1,i0)         _subci(_jit,r0,r1,i0)
 684 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 685 #define subxr(r0,r1,r2)         SUB_B(r1,r2,r0)
 686 #define subxi(r0,r1,i0)         _subxi(_jit,r0,r1,i0)
 687 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 688 #define rsbi(r0, r1, i0)        _rsbi(_jit, r0, r1, i0)
 689 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 690 #define mulr(r0,r1,r2)          _mulr(_jit,r0,r1,r2)
 691 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 692 #define muli(r0,r1,i0)          _muli(_jit,r0,r1,i0)
 693 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 694 static long long __llmul(int, int);
 695 #define qmulr(r0,r1,r2,r3)      _qmulr(_jit,r0,r1,r2,r3)
 696 static void _qmulr(jit_state_t*,
 697                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 698 #define qmuli(r0,r1,r2,i0)      _qmuli(_jit,r0,r1,r2,i0)
 699 static void _qmuli(jit_state_t*,
 700                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 701 #define qmulr_u(r0,r1,r2,r3)    _qmulr_u(_jit,r0,r1,r2,r3)
 702 static void _qmulr_u(jit_state_t*,
 703                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 704 #define qmuli_u(r0,r1,r2,i0)    _qmuli_u(_jit,r0,r1,r2,i0)
 705 static void _qmuli_u(jit_state_t*,
 706                      jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 707 static int __idiv(int, int);
 708 #define divr(r0,r1,r2)          _divr(_jit,r0,r1,r2)
 709 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 710 #define divi(r0,r1,i0)          _divi(_jit,r0,r1,i0)
 711 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 712 static unsigned int __udiv(unsigned int, unsigned int);
 713 #define divr_u(r0,r1,r2)        _divr_u(_jit,r0,r1,r2)
 714 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 715 #define divi_u(r0,r1,i0)        _divi_u(_jit,r0,r1,i0)
 716 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 717 static int __irem(int, int);
 718 #define remr(r0,r1,r2)          _remr(_jit,r0,r1,r2)
 719 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 720 #define remi(r0,r1,i0)          _remi(_jit,r0,r1,i0)
 721 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 722 static unsigned int __urem(unsigned int, unsigned int);
 723 #define remr_u(r0,r1,r2)        _remr_u(_jit,r0,r1,r2)
 724 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 725 #define remi_u(r0,r1,i0)        _remi_u(_jit,r0,r1,i0)
 726 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 727 static idiv_t __idivrem(int, int);
 728 #define qdivr(r0,r1,r2,r3)      _qdivr(_jit,r0,r1,r2,r3)
 729 static void _qdivr(jit_state_t*,
 730                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 731 #define qdivi(r0,r1,r2,i0)      _qdivi(_jit,r0,r1,r2,i0)
 732 static void _qdivi(jit_state_t*,
 733                    jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 734 static udiv_t __udivrem(unsigned int, unsigned int);
 735 #define qdivr_u(r0,r1,r2,r3)    _qdivr_u(_jit,r0,r1,r2,r3)
 736 static void _qdivr_u(jit_state_t*,
 737                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 738 #define qdivi_u(r0,r1,r2,i0)    _qdivi_u(_jit,r0,r1,r2,i0)
 739 static void _qdivi_u(jit_state_t*,
 740                      jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 741 #define andr(r0,r1,r2)          AND(r1,r2,r0)
 742 #define andi(r0,r1,i0)          _andi(_jit,r0,r1,i0)
 743 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 744 #define orr(r0,r1,r2)           OR(r1,r2,r0)
 745 #define ori(r0,r1,i0)           _ori(_jit,r0,r1,i0)
 746 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 747 #define xorr(r0,r1,r2)          XOR(r1,r2,r0)
 748 #define xori(r0,r1,i0)          _xori(_jit,r0,r1,i0)
 749 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 750 #define lshr(r0,r1,r2)          _lshr(_jit,r0,r1,r2)
 751 static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 752 #define lshi(r0,r1,i0)          SHLWI(r1,i0,r0)
 753 #define rshr(r0,r1,r2)          _rshr(_jit,r0,r1,r2)
 754 static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 755 #define rshi(r0,r1,i0)          SHRWI(r1,i0,r0)
 756 #define rshr_u(r0,r1,r2)        _rshr_u(_jit,r0,r1,r2)
 757 static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 758 #define rshi_u(r0,r1,i0)        SHRWI_U(r1,i0,r0)
 759 #define cmpr(c,r0,r1,r2)        _cmpr(_jit,c,r0,r1,r2)
 760 static void _cmpr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,jit_int32_t);
 761 #define cmpi(c,ci,r0,r1,i0)     _cmpi(_jit,c,ci,r0,r1,i0)
 762 static void _cmpi(jit_state_t*,jit_word_t,jit_word_t,
 763                   jit_int32_t,jit_int32_t,jit_word_t);
 764 #define ltr(r0,r1,r2)           cmpr(CS_CC_GE,r0,r1,r2)
 765 #define lti(r0,r1,i0)           cmpi(CS_CC_GE,CS_CC_LE,r0,r1,i0)
 766 #define ltr_u(r0,r1,r2)         cmpr(CS_CC_UGE,r0,r1,r2)
 767 #define lti_u(r0,r1,i0)         cmpi(CS_CC_UGE,CS_CC_ULE,r0,r1,i0)
 768 #define ler(r0,r1,r2)           cmpr(CS_CC_GT,r0,r1,r2)
 769 #define lei(r0,r1,i0)           cmpi(CS_CC_GT,CS_CC_LT,r0,r1,i0)
 770 #define ler_u(r0,r1,r2)         cmpr(CS_CC_UGT,r0,r1,r2)
 771 #define lei_u(r0,r1,i0)         cmpi(CS_CC_UGT,CS_CC_ULT,r0,r1,i0)
 772 #define eqr(r0,r1,r2)           cmpr(CS_CC_NE,r0,r1,r2)
 773 #define eqi(r0,r1,i0)           cmpi(CS_CC_NE,CS_CC_NE,r0,r1,i0)
 774 #define ger(r0,r1,r2)           cmpr(CS_CC_LT,r0,r1,r2)
 775 #define gei(r0,r1,i0)           cmpi(CS_CC_LT,CS_CC_GT,r0,r1,i0)
 776 #define ger_u(r0,r1,r2)         cmpr(CS_CC_ULT,r0,r1,r2)
 777 #define gei_u(r0,r1,i0)         cmpi(CS_CC_ULT,CS_CC_UGT,r0,r1,i0)
 778 #define gtr(r0,r1,r2)           cmpr(CS_CC_LE,r0,r1,r2)
 779 #define gti(r0,r1,i0)           cmpi(CS_CC_LE,CS_CC_GE,r0,r1,i0)
 780 #define gtr_u(r0,r1,r2)         cmpr(CS_CC_ULE,r0,r1,r2)
 781 #define gti_u(r0,r1,i0)         cmpi(CS_CC_ULE,CS_CC_UGE,r0,r1,i0)
 782 #define ner(r0,r1,r2)           cmpr(CS_CC_EQ,r0,r1,r2)
 783 #define nei(r0,r1,i0)           cmpi(CS_CC_EQ,CS_CC_EQ,r0,r1,i0)
 784 #define ldr_c(r0,r1)            _ldr_c(_jit,r0,r1)
 785 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
 786 #define ldi_c(r0,i0)            _ldi_c(_jit,r0,i0)
 787 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
 788 #define ldxr_c(r0,r1,r2)        _ldxr_c(_jit,r0,r1,r2)
 789 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 790 #define ldxi_c(r0,r1,i0)        _ldxi_c(_jit,r0,r1,i0)
 791 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 792 #define ldr_uc(r0,r1)           LDBI(_R0_REGNO,r1,r0)
 793 #define ldi_uc(r0,i0)           _ldi_uc(_jit,r0,i0)
 794 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
 795 #define ldxr_uc(r0,r1,r2)       LDB(r2,r1,r0)
 796 #define ldxi_uc(r0,r1,i0)       _ldxi_uc(_jit,r0,r1,i0)
 797 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 798 #define ldr_s(r0,r1)            _ldr_s(_jit,r0,r1)
 799 static void _ldr_s(jit_state_t*,jit_int32_t,jit_int32_t);
 800 #define ldi_s(r0,i0)            _ldi_s(_jit,r0,i0)
 801 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
 802 #define ldxr_s(r0,r1,r2)        _ldxr_s(_jit,r0,r1,r2)
 803 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 804 #define ldxi_s(r0,r1,i0)        _ldxi_s(_jit,r0,r1,i0)
 805 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 806 #define ldr_us(r0,r1)           LDHI(_R0_REGNO,r1,r0)
 807 #define ldi_us(r0,i0)           _ldi_us(_jit,r0,i0)
 808 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
 809 #define ldxr_us(r0,r1,r2)       LDH(r2,r1,r0)
 810 #define ldxi_us(r0,r1,i0)       _ldxi_us(_jit,r0,r1,i0)
 811 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 812 #define ldr(r0,r1)              ldr_ui(r0,r1)
 813 #define ldr_i(r0,r1)            ldr_ui(r0,r1)
 814 #define ldr_ui(r0,r1)           LDWI(_R0_REGNO,r1,r0)
 815 #define ldi_i(r0,i0)            ldi_ui(r0,i0)
 816 #define ldi_ui(r0,i0)           _ldi_ui(_jit,r0,i0)
 817 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
 818 #define ldxr_i(r0,r1,r2)        ldxr_ui(r0,r1,r2)
 819 #define ldxr_ui(r0,r1,r2)       LDW(r2,r1,r0)
 820 #define ldxi(r0,r1,i0)          ldxi_ui(r0,r1,i0)
 821 #define ldxi_i(r0,r1,i0)        ldxi_ui(r0,r1,i0)
 822 #define ldxi_ui(r0,r1,i0)       _ldxi_ui(_jit,r0,r1,i0)
 823 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 824 #define str_c(r0,r1)            STBI(r1,_R0_REGNO,r0)
 825 #define sti_c(i0,r0)            _sti_c(_jit,i0,r0)
 826 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
 827 #define stxr_c(r0,r1,r2)        _stxr_c(_jit,r0,r1,r2)
 828 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 829 #define stxi_c(i0,r0,r1)        _stxi_c(_jit,i0,r0,r1)
 830 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 831 #define str_s(r0,r1)            STHI(r1,_R0_REGNO,r0)
 832 #define sti_s(i0,r0)            _sti_s(_jit,i0,r0)
 833 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
 834 #define stxr_s(r0,r1,r2)        _stxr_s(_jit,r0,r1,r2)
 835 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 836 #define stxi_s(i0,r0,r1)        _stxi_s(_jit,i0,r0,r1)
 837 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 838 #define str_i(r0,r1)            STWI(r1,_R0_REGNO,r0)
 839 #define sti_i(i0,r0)            _sti_i(_jit,i0,r0)
 840 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
 841 #define stxr_i(r0,r1,r2)        _stxr_i(_jit,r0,r1,r2)
 842 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 843 #define stxi(i0,r0,r1)          stxi_i(i0,r0,r1)
 844 #define stxi_i(i0,r0,r1)        _stxi_i(_jit,i0,r0,r1)
 845 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 846 #define bcmpr(c,i0,r0,r1)       _bcmpr(_jit,c,i0,r0,r1)
 847 static jit_word_t _bcmpr(jit_state_t*,jit_word_t,
 848                          jit_word_t,jit_int32_t,jit_int32_t);
 849 #define bcmpi(c,ci,i0,r0,i1)    _bcmpi(_jit,c,ci,i0,r0,i1)
 850 static jit_word_t _bcmpi(jit_state_t*,jit_word_t,jit_word_t,
 851                          jit_word_t,jit_int32_t,jit_word_t);
 852 #define bltr(i0,r0,r1)          bcmpr(CS_CC_LT,i0,r0,r1)
 853 #define blti(i0,r0,r1)          bcmpi(CS_CC_LT,CS_CC_GT,i0,r0,r1)
 854 #define bltr_u(i0,r0,r1)        bcmpr(CS_CC_ULT,i0,r0,r1)
 855 #define blti_u(i0,r0,r1)        bcmpi(CS_CC_ULT,CS_CC_UGT,i0,r0,r1)
 856 #define bler(i0,r0,r1)          bcmpr(CS_CC_LE,i0,r0,r1)
 857 #define blei(i0,r0,r1)          bcmpi(CS_CC_LE,CS_CC_GE,i0,r0,r1)
 858 #define bler_u(i0,r0,r1)        bcmpr(CS_CC_ULE,i0,r0,r1)
 859 #define blei_u(i0,r0,r1)        bcmpi(CS_CC_ULE,CS_CC_UGE,i0,r0,r1)
 860 #define beqr(i0,r0,r1)          bcmpr(CS_CC_EQ,i0,r0,r1)
 861 #define beqi(i0,r0,r1)          bcmpi(CS_CC_EQ,CS_CC_EQ,i0,r0,r1)
 862 #define bger(i0,r0,r1)          bcmpr(CS_CC_GE,i0,r0,r1)
 863 #define bgei(i0,r0,r1)          bcmpi(CS_CC_GE,CS_CC_LE,i0,r0,r1)
 864 #define bger_u(i0,r0,r1)        bcmpr(CS_CC_UGE,i0,r0,r1)
 865 #define bgei_u(i0,r0,r1)        bcmpi(CS_CC_UGE,CS_CC_ULE,i0,r0,r1)
 866 #define bgtr(i0,r0,r1)          bcmpr(CS_CC_GT,i0,r0,r1)
 867 #define bgti(i0,r0,r1)          bcmpi(CS_CC_GT,CS_CC_LT,i0,r0,r1)
 868 #define bgtr_u(i0,r0,r1)        bcmpr(CS_CC_UGT,i0,r0,r1)
 869 #define bgti_u(i0,r0,r1)        bcmpi(CS_CC_UGT,CS_CC_ULT,i0,r0,r1)
 870 #define bner(i0,r0,r1)          bcmpr(CS_CC_NE,i0,r0,r1)
 871 #define bnei(i0,r0,r1)          bcmpi(CS_CC_NE,CS_CC_NE,i0,r0,r1)
 872 #define bmxr(c,i0,r0,r1)        _bmxr(_jit,c,i0,r0,r1)
 873 static jit_word_t _bmxr(jit_state_t*,jit_bool_t,
 874                         jit_word_t,jit_int32_t,jit_int32_t);
 875 #define bmxi(c,i0,r0,i1)        _bmxi(_jit,c,i0,r0,i1)
 876 static jit_word_t _bmxi(jit_state_t*,jit_bool_t,
 877                         jit_word_t,jit_int32_t,jit_word_t);
 878 #define bmcr(r0,r1,r2)          bmxr(0,r0,r1,r2)
 879 #define bmci(r0,r1,r2)          bmxi(0,r0,r1,r2)
 880 #define bmsr(r0,r1,r2)          bmxr(1,r0,r1,r2)
 881 #define bmsi(r0,r1,r2)          bmxi(1,r0,r1,r2)
 882 #define boaddr(i0,r0,r1)        _boaddr(_jit,i0,r0,r1)
 883 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 884 #define boaddi(i0,r0,i1)        _boaddi(_jit,i0,r0,i1)
 885 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 886 #define boaddr_u(i0,r0,r1)      _boaddr_u(_jit,i0,r0,r1)
 887 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 888 #define boaddi_u(i0,r0,i1)      _boaddi_u(_jit,i0,r0,i1)
 889 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 890 #define bxaddr(i0,r0,r1)        _bxaddr(_jit,i0,r0,r1)
 891 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 892 #define bxaddi(i0,r0,i1)        _bxaddi(_jit,i0,r0,i1)
 893 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 894 #define bxaddr_u(i0,r0,r1)      _bxaddr_u(_jit,i0,r0,r1)
 895 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 896 #define bxaddi_u(i0,r0,i1)      _bxaddi_u(_jit,i0,r0,i1)
 897 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 898 #define bosubr(i0,r0,r1)        _bosubr(_jit,i0,r0,r1)
 899 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 900 #define bosubi(i0,r0,i1)        _bosubi(_jit,i0,r0,i1)
 901 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 902 #define bosubr_u(i0,r0,r1)      _bosubr_u(_jit,i0,r0,r1)
 903 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 904 #define bosubi_u(i0,r0,i1)      _bosubi_u(_jit,i0,r0,i1)
 905 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 906 #define bxsubr(i0,r0,r1)        _bxsubr(_jit,i0,r0,r1)
 907 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 908 #define bxsubi(i0,r0,i1)        _bxsubi(_jit,i0,r0,i1)
 909 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 910 #define bxsubr_u(i0,r0,r1)      _bxsubr_u(_jit,i0,r0,r1)
 911 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 912 #define bxsubi_u(i0,r0,i1)      _bxsubi_u(_jit,i0,r0,i1)
 913 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 914 #define jmpr(r0)                _jmpr(_jit,r0)
 915 static void _jmpr(jit_state_t*,jit_int32_t);
 916 #define jmpi(i0)                _jmpi(_jit,i0)
 917 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
 918 #define jmpi_p(i0)              _jmpi_p(_jit,i0)
 919 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
 920 #define callr(r0)               _callr(_jit,r0)
 921 static void _callr(jit_state_t*,jit_int32_t);
 922 #define calli(i0)               _calli(_jit,i0)
 923 static void _calli(jit_state_t*,jit_word_t);
 924 #define calli_p(i0)             _calli_p(_jit,i0)
 925 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 926 #define prolog(node)            _prolog(_jit, node)
 927 static void _prolog(jit_state_t*, jit_node_t*);
 928 #define epilog(node)            _epilog(_jit, node)
 929 static void _epilog(jit_state_t*, jit_node_t*);
 930 #define vastart(r0)             _vastart(_jit, r0)
 931 static void _vastart(jit_state_t*, jit_int32_t);
 932 #define vaarg(r0, r1)           _vaarg(_jit, r0, r1)
 933 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 934 #define patch_at(i,l)           _patch_at(_jit,i,l)
 935 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 936 #endif
 937
 938 #if CODE
 939 /* from binutils bfd/libhppa.h */
 940 static inline int
 941 sign_extend (int x, int len)
 942 {
 943   int signbit = (1 << (len - 1));
 944   int mask = (signbit << 1) - 1;
 945   return ((x & mask) ^ signbit) - signbit;
 946 }
 947
 948 static inline int
 949 sign_unext (int x, int len)
 950 {
 951   int len_ones;
 952
 953   len_ones = (1 << len) - 1;
 954
 955   return x & len_ones;
 956 }
 957
 958 static inline int
 959 low_sign_unext (int x, int len)
 960 {
 961   int temp;
 962   int sign;
 963
 964   sign = (x >> (len-1)) & 1;
 965
 966   temp = sign_unext (x, len-1);
 967
 968   return (temp << 1) | sign;
 969 }
 970
 971 static inline int
 972 re_assemble_3 (int as3)
 973 {
 974   return ((  (as3 & 4) << (13-2))
 975           | ((as3 & 3) << (13+1)));
 976 }
 977
 978 static inline int
 979 re_assemble_12 (int as12)
 980 {
 981   return ((  (as12 & 0x800) >> 11)
 982           | ((as12 & 0x400) >> (10 - 2))
 983           | ((as12 & 0x3ff) << (1 + 2)));
 984 }
 985
 986 static inline int
 987 re_assemble_16 (int as16)
 988 {
 989   int s, t;
 990
 991   /* Unusual 16-bit encoding, for wide mode only.  */
 992   t = (as16 << 1) & 0xffff;
 993   s = (as16 & 0x8000);
 994   return (t ^ s ^ (s >> 1)) | (s >> 15);
 995 }
 996
 997 static inline int
 998 re_assemble_17 (int as17)
 999 {
1000   return ((  (as17 & 0x10000) >> 16)
1001           | ((as17 & 0x0f800) << (16 - 11))
1002           | ((as17 & 0x00400) >> (10 - 2))
1003           | ((as17 & 0x003ff) << (1 + 2)));
1004 }
1005
1006 static inline int
1007 re_assemble_21 (int as21)
1008 {
1009   return ((  (as21 & 0x100000) >> 20)
1010           | ((as21 & 0x0ffe00) >> 8)
1011           | ((as21 & 0x000180) << 7)
1012           | ((as21 & 0x00007c) << 14)
1013           | ((as21 & 0x000003) << 12));
1014 }
1015
1016 static inline int
1017 re_assemble_22 (int as22)
1018 {
1019   return ((  (as22 & 0x200000) >> 21)
1020           | ((as22 & 0x1f0000) << (21 - 16))
1021           | ((as22 & 0x00f800) << (16 - 11))
1022           | ((as22 & 0x000400) >> (10 - 2))
1023           | ((as22 & 0x0003ff) << (1 + 2)));
1024 }
1025
1026 static void
1027 _f1(jit_state_t *_jit, jit_int32_t o,
1028     jit_int32_t b, jit_int32_t t, jit_int32_t i)
1029 {
1030     assert(!(o  & ~0x3f));
1031     assert(!(b  & ~0x1f));
1032     assert(!(t  & ~0x1f));
1033     assert(i >= -8192 && i <= 8191);
1034     ii((o<<26)|(b<<21)|(t<<16)|(re_assemble_16(i)));
1035 }
1036
1037 static void
1038 _f2(jit_state_t *_jit, jit_int32_t o,
1039     jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
1040 {
1041     assert(!(o  & ~0x3f));
1042     assert(!(b  & ~0x1f));
1043     assert(!(t  & ~0x1f));
1044     assert(i >= -32768 && i <= 32767);
1045     assert(!(j  &  ~0x3));
1046     ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
1047 }
1048
1049 static void
1050 _f3(jit_state_t *_jit, jit_int32_t o,
1051     jit_int32_t b, jit_int32_t t, jit_int32_t i, jit_int32_t j)
1052 {
1053     assert(!(o  & ~0x3f));
1054     assert(!(b  & ~0x1f));
1055     assert(!(t  & ~0x1f));
1056     assert(i >= -32768 && i <= 32767);
1057     assert(!(j  &  ~0x1));
1058     ii((o<<26)|(b<<21)|(t<<16)|(j<<1)|(re_assemble_16(i)));
1059 }
1060
1061 static void
1062 _f4(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1063     jit_int32_t x, jit_int32_t s, jit_int32_t u, jit_int32_t y,
1064     jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
1065 {
1066     assert(!(o  & ~0x3f));
1067     assert(!(b  & ~0x1f));
1068     assert(!(x  & ~0x1f));
1069     assert(!(s  &  ~0x3));
1070     assert(!(u  &  ~0x1));
1071     assert(!(y  &  ~0x1));
1072     assert(!(c  &  ~0x3));
1073     assert(!(z  &  ~0xf));
1074     assert(!(m  &  ~0x1));
1075     assert(!(t  & ~0x1f));
1076     ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(u<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
1077 }
1078
1079 static void
1080 _f5(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1081     jit_int32_t i, jit_int32_t s, jit_int32_t a, jit_int32_t y,
1082     jit_int32_t c, jit_int32_t z, jit_int32_t m, jit_int32_t t)
1083 {
1084     assert(!(o  & ~0x3f));
1085     assert(!(b  & ~0x1f));
1086     assert(!(s  &  ~0x3));
1087     assert(!(a  &  ~0x1));
1088     assert(!(y  &  ~0x1));
1089     assert(!(c  &  ~0x3));
1090     assert(!(z  &  ~0xf));
1091     assert(!(m  &  ~0x1));
1092     assert(i >= -16 && i <= 15);
1093     ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|
1094        (s<<14)|(a<<13)|(y<<12)|(c<<10)|(z<<6)|(m<<5)|t);
1095 }
1096
1097 static void
1098 _f6(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1099     jit_int32_t r, jit_int32_t s, jit_int32_t a, jit_int32_t x,
1100     jit_int32_t c, jit_int32_t y, jit_int32_t m, jit_int32_t i)
1101 {
1102     assert(!(o  & ~0x3f));
1103     assert(!(b  & ~0x1f));
1104     assert(!(s  &  ~0x3));
1105     assert(!(a  &  ~0x1));
1106     assert(!(x  &  ~0x1));
1107     assert(!(c  &  ~0x3));
1108     assert(!(y  &  ~0xf));
1109     assert(!(m  &  ~0x1));
1110     assert(i >= -16 && i <= 15);
1111     ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(a<<13)|
1112        (x<<12)|(c<<10)|(y<<6)|(m<<5)|low_sign_unext(i,5));
1113 }
1114
1115 static void
1116 _f7(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t i)
1117 {
1118     assert(!(o  & ~0x3f));
1119     assert(!(r  & ~0x1f));
1120     assert(!(i  &  0x7ff));
1121     ii((o<<26)|(r<<21)|re_assemble_21(i>>11));
1122 }
1123
1124 static void
1125 _f8(jit_state_t *_jit, jit_int32_t o,
1126     jit_int32_t r2, jit_int32_t r1, jit_int32_t cf,
1127     jit_int32_t e1, jit_int32_t x, jit_int32_t e2,
1128     jit_int32_t e3, jit_int32_t d, jit_int32_t t)
1129 {
1130     assert(!(o  & ~0x3f));
1131     assert(!(r2 & ~0x1f));
1132     assert(!(r1 & ~0x1f));
1133     assert(!(cf &  ~0xf));
1134     assert(!(e1 &  ~0x3));
1135     assert(!(x  &  ~0x1));
1136     assert(!(e2 &  ~0x3));
1137     assert(!(e3 &  ~0x3));
1138     assert(!(d  &  ~0x1));
1139     assert(!(t  & ~0x1f));
1140     ii((o<<26)|(r2<<21)|(r1<<16)|(cf<<12)|
1141        (e1<<10)|(x<<9)|(e2<<8)|(e3<<6)|(d<<5)|t);
1142 }
1143
1144 static void
1145 _f9(jit_state_t *_jit,
1146     jit_int32_t o, jit_int32_t r, jit_int32_t t,
1147     jit_int32_t cf, jit_int32_t e1, jit_int32_t i)
1148 {
1149     assert(!(o  & ~0x3f));
1150     assert(!(r  & ~0x1f));
1151     assert(!(t  & ~0x1f));
1152     assert(!(cf &  ~0xf));
1153     assert(!(e1 &  ~0x1));
1154     assert(i >= -2048 && i <= 2047);
1155     ii((o<<26)|(r<<21)|(t<<16)|(cf<<12)|(e1<<11)|low_sign_unext(i,11));
1156 }
1157
1158 static void
1159 _f10(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1160      jit_int32_t r1, jit_int32_t u, jit_int32_t v, jit_int32_t w,
1161      jit_int32_t x, jit_int32_t sa, jit_int32_t y, jit_int32_t t)
1162 {
1163     assert(!(o  & ~0x3f));
1164     assert(!(r2 & ~0x1f));
1165     assert(!(r1 & ~0x1f));
1166     assert(!(u  &  ~0x1));
1167     assert(!(v  &  ~0x3));
1168     assert(!(w  &  ~0x1));
1169     assert(!(x  &  ~0x3));
1170     assert(!(sa &  ~0xf));
1171     assert(!(y  &  ~0x1));
1172     assert(!(t  & ~0x1f));
1173     ii((o<<26)|(r2<<21)|(r1<<16)|(u<<15)|
1174        (v<<13)|(w<<12)|(x<<10)|(sa<<6)|(y<<5)|t);
1175 }
1176
1177 static void
1178 _f11(jit_state_t *_jit, jit_int32_t o,
1179      jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
1180      jit_int32_t y, jit_int32_t z, jit_int32_t u, jit_int32_t t)
1181 {
1182     assert(!(o  & ~0x3f));
1183     assert(!(r1 & ~0x1f));
1184     assert(!(r2 & ~0x1f));
1185     assert(!(c  &  ~0x7));
1186     assert(!(x  &  ~0x3));
1187     assert(!(y  &  ~0x1));
1188     assert(!(z  &  ~0x1));
1189     assert(!(u  &  ~0xf));
1190     assert(!(t  & ~0x1f));
1191     ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<11)|(y<<10)|(z<<9)|(u<<5)|t);
1192 }
1193
1194 static void
1195 _f12(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1196      jit_int32_t t, jit_int32_t c, jit_int32_t x, jit_int32_t se,
1197      jit_int32_t y, jit_int32_t c1, jit_int32_t z, jit_int32_t clen)
1198 {
1199     assert(!(o    & ~0x3f));
1200     assert(!(r    & ~0x1f));
1201     assert(!(t    & ~0x1f));
1202     assert(!(c    &  ~0x7));
1203     assert(!(x    &  ~0x3));
1204     assert(!(se   &  ~0x1));
1205     assert(!(y    &  ~0x1));
1206     assert(!(c1   &  ~0x1));
1207     assert(!(z    &  ~0x7));
1208     assert(!((32-clen) & ~0x1f));
1209     ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(x<<11)|
1210        (se<<10)|(y<<9)|(c1<<8)|(z<<5)|(32-clen));
1211 }
1212
1213 static void
1214 _f13(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1215      jit_int32_t r, jit_int32_t c, jit_int32_t x,
1216      jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
1217 {
1218     assert(!(o    & ~0x3f));
1219     assert(!(t    & ~0x1f));
1220     assert(!(r    & ~0x1f));
1221     assert(!(c    &  ~0x7));
1222     assert(!(x    &  ~0x3));
1223     assert(!(nz   &  ~0x1));
1224     assert(!(c1   &  ~0x1));
1225     assert(!((32-clen) & ~0x1f));
1226     ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
1227        (x<<11)|(nz<<10)|(c1<<8)|(32-clen));
1228 }
1229
1230 static void
1231 _f13x(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1232       jit_int32_t i, jit_int32_t c, jit_int32_t x,
1233       jit_int32_t nz, jit_int32_t c1, jit_int32_t clen)
1234 {
1235     assert(!(o    & ~0x3f));
1236     assert(!(t    & ~0x1f));
1237     assert(i >= -16 && i <= 15);
1238     assert(!(c    &  ~0x7));
1239     assert(!(x    &  ~0x3));
1240     assert(!(nz   &  ~0x1));
1241     assert(!((32-clen) & ~0x1f));
1242     ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|
1243        (c<<13)|(x<<11)|(nz<<10)|(c1<<8)|(32-clen));
1244 }
1245
1246 static void
1247 _f14(jit_state_t *_jit, jit_int32_t o,
1248      jit_int32_t r2, jit_int32_t r1, jit_int32_t c, jit_int32_t x,
1249      jit_int32_t cp, jit_int32_t y, jit_int32_t cpos, jit_int32_t t)
1250 {
1251     assert(!(o    & ~0x3f));
1252     assert(!(r1   & ~0x1f));
1253     assert(!(r2   & ~0x1f));
1254     assert(!(c    &  ~0x7));
1255     assert(!(x    &  ~0x3));
1256     assert(!(cp   &  ~0x1));
1257     assert(!(y    &  ~0x1));
1258     assert(!(cpos & ~0x1f));
1259     assert(!(t    & ~0x1f));
1260     ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|(x<<12)|(cp<<11)|(y<<10)|(cpos<<5)|t);
1261 }
1262
1263 static void
1264 _f15(jit_state_t *_jit, jit_int32_t o,
1265      jit_int32_t r, jit_int32_t t, jit_int32_t c, jit_int32_t c1,
1266      jit_int32_t p, jit_int32_t se, jit_int32_t pos, jit_int32_t clen)
1267 {
1268     assert(!(o    & ~0x3f));
1269     assert(!(r    & ~0x1f));
1270     assert(!(t    & ~0x1f));
1271     assert(!(c    &  ~0x7));
1272     assert(!(c1   &  ~0x1));
1273     assert(!(p    &  ~0x1));
1274     assert(!(se   &  ~0x1));
1275     assert(!(pos  & ~0x1f));
1276     assert(!((32-clen) & ~0x1f));
1277     ii((o<<26)|(r<<21)|(t<<16)|(c<<13)|(c1<<12)|
1278        (p<<11)|(se<<10)|(pos<<5)|(32-clen));
1279 }
1280
1281 static void
1282 _f16(jit_state_t *_jit, jit_int32_t o,
1283      jit_int32_t t, jit_int32_t r, jit_int32_t c, jit_int32_t c1,
1284      jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
1285 {
1286     assert(!(o    & ~0x3f));
1287     assert(!(t    & ~0x1f));
1288     assert(!(r    & ~0x1f));
1289     assert(!(c    &  ~0x7));
1290     assert(!(c1   &  ~0x1));
1291     assert(!(cp   &  ~0x1));
1292     assert(!(nz   &  ~0x1));
1293     assert(!(cpos & ~0x1f));
1294     assert(!((32-clen) & ~0x3f));
1295     ii((o<<26)|(t<<21)|(r<<16)|(c<<13)|
1296        (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
1297 }
1298
1299 static void
1300 _f16x(jit_state_t *_jit, jit_int32_t o,
1301       jit_int32_t t, jit_int32_t i, jit_int32_t c, jit_int32_t c1,
1302       jit_int32_t cp, jit_int32_t nz, jit_int32_t cpos, jit_int32_t clen)
1303 {
1304     assert(!(o    & ~0x3f));
1305     assert(!(t    & ~0x1f));
1306     assert(i >= -16 && i <= 15);
1307     assert(!(c    &  ~0x7));
1308     assert(!(c1   &  ~0x1));
1309     assert(!(cp   &  ~0x1));
1310     assert(!(nz   &  ~0x1));
1311     assert(!(cpos & ~0x1f));
1312     assert(!((32-clen) & ~0x3f));
1313     ii((o<<26)|(t<<21)|(low_sign_unext(i,5)<<16)|(c<<13)|
1314        (c1<<12)|(cp<<11)|(nz<<10)|(cpos<<5)|(32-clen));
1315 }
1316
1317 static void
1318 _f17(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1319      jit_int32_t r1, jit_int32_t c, jit_int32_t i, jit_int32_t n)
1320 {
1321     assert(!(o  & ~0x3f));
1322     assert(!(r2 & ~0x1f));
1323     assert(!(r1 & ~0x1f));
1324     assert(!(c  &  ~0x7));
1325     assert(i >= -2048 && i <= 2047);
1326     assert(!(n  &   ~0x1));
1327     ii((o<<26)|(r2<<21)|(r1<<16)|(c<<13)|re_assemble_12(i)|(n<<1));
1328 }
1329
1330 static void
1331 _f17x(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1332       jit_int32_t i, jit_int32_t c, jit_int32_t t, jit_int32_t n)
1333 {
1334     assert(!(o & ~0x3f));
1335     assert(!(r & ~0x1f));
1336     assert(i >= -16 && i <= 15);
1337     assert(!(c &  ~0x7));
1338     assert(t >= -2048 && t <= 2047);
1339     assert(!(n &  ~0x1));
1340     ii((o<<26)|(r<<21)|
1341        (low_sign_unext(i,5)<<16)|(c<<13)|re_assemble_12(t)|(n<<1));
1342 }
1343
1344 static void
1345 _f18(jit_state_t *_jit, jit_int32_t o, jit_int32_t p,
1346      jit_int32_t r, jit_int32_t c, jit_int32_t i, jit_int32_t n)
1347 {
1348     assert(!(o & ~0x3f));
1349     assert(!(p & ~0x1f));
1350     assert(!(r & ~0x1f));
1351     assert(!(c &  ~0x1));
1352     assert(i >= -2048 && i <= 2047);
1353     assert(!(n &  ~0x1));
1354     ii((o<<26)|(p<<21)|(r<<16)|(c<<15)|(1<<14)|re_assemble_12(i)|(n<<1));
1355 }
1356
1357 static void
1358 _f19(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1359      jit_int32_t s, jit_int32_t i, jit_int32_t n)
1360 {
1361     assert(!(o & ~0x3f));
1362     assert(!(b & ~0x1f));
1363     assert(!(s &  ~0x7));
1364     assert(i >= -65536 && i <= 65535);
1365     assert(!(n &  ~0x1));
1366     ii((o<<26)|(b<<21)|re_assemble_3(s)|re_assemble_17(i)|(n<<1));
1367 }
1368
1369 static void
1370 _f20(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1371      jit_int32_t i, jit_int32_t g, jit_int32_t n)
1372 {
1373     assert(!(o & ~0x3f));
1374     assert(!(t & ~0x1f));
1375     assert(i >= -32768 && i <= 32767);
1376     assert(!(g &  ~0x7));
1377     assert(!(n &  ~0x1));
1378     ii((o<<26)|(t<<21)|(g<<13)|re_assemble_17(i)|(n<<1));
1379 }
1380
1381 static void
1382 _f21(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1383      jit_int32_t x, jit_int32_t y, jit_int32_t n)
1384 {
1385     assert(!(o & ~0x3f));
1386     assert(!(t & ~0x1f));
1387     assert(!(x & ~0x1f));
1388     assert(!(y &  ~0x7));
1389     assert(!(n &  ~0x1));
1390     ii((o<<26)|(t<<21)|(x<<16)|(y<<13)|(n<<1));
1391 }
1392
1393 static void
1394 _f22(jit_state_t *_jit, jit_int32_t o, jit_int32_t b,
1395      jit_int32_t x, jit_int32_t r, jit_int32_t n, jit_int32_t p)
1396 {
1397     assert(!(o & ~0x3f));
1398     assert(!(b & ~0x1f));
1399     assert(!(x &  ~0x7));
1400     assert(!(r & ~0x3f));
1401     assert(!(n &  ~0x1));
1402     assert(!(p &  ~0x1));
1403     ii((o<<26)|(b<<21)|(x<<13)|(1<<12)|(r<<2)|(n<<1)|p);
1404 }
1405
1406 static void
1407 _f23(jit_state_t *_jit, jit_int32_t o,
1408      jit_int32_t a, jit_int32_t b, jit_int32_t c, jit_int32_t d,
1409      jit_int32_t e, jit_int32_t f, jit_int32_t g, jit_int32_t h)
1410 {
1411     assert(!(o &  ~0x3f));
1412     assert(!(a &  ~0x1f));
1413     assert(!(b &  ~0x1f));
1414     assert(!(c &   ~0x7));
1415     assert(!(d &   ~0x1));
1416     assert(!(e & ~0x1ff));
1417     assert(!(f &   ~0x1));
1418     assert(!(g &   ~0x1));
1419     assert(!(h &   ~0x1));
1420     ii((o<<26)|(a<<21)|(b<<16)|(c<<13)|(d<<12)|(e<<3)|(f<<2)|(g<<1)|h);
1421 }
1422
1423 static void
1424 _f24(jit_state_t *_jit, jit_int32_t o,
1425      jit_int32_t b, jit_int32_t x, jit_int32_t s,
1426      jit_int32_t y, jit_int32_t m,jit_int32_t r)
1427 {
1428     assert(!(o &  ~0x3f));
1429     assert(!(b &  ~0x1f));
1430     assert(!(x &  ~0x1f));
1431     assert(!(s &   ~0x3));
1432     assert(!(y &  ~0xff));
1433     assert(!(m &   ~0x1));
1434     assert(!(r &  ~0x1f));
1435     ii((o<<26)|(b<<21)|(x<<16)|(s<<14)|(y<<6)|(m<<5)|r);
1436 }
1437
1438 static void
1439 _f25(jit_state_t *_jit, jit_int32_t o,
1440      jit_int32_t b, jit_int32_t i, jit_int32_t s,
1441      jit_int32_t y, jit_int32_t m, jit_int32_t r)
1442 {
1443     assert(!(o &  ~0x3f));
1444     assert(!(b &  ~0x1f));
1445     assert(i >= -16 && i <= 15);
1446     assert(!(s &   ~0x3));
1447     assert(!(y &  ~0xff));
1448     assert(!(m &   ~0x1));
1449     assert(!(r &  ~0x1f));
1450     ii((o<<26)|(b<<21)|(low_sign_unext(i,5)<<16)|(s<<14)|(y<<6)|(m<<5)|r);
1451 }
1452
1453 static void
1454 _f26(jit_state_t *_jit, jit_int32_t o,
1455      jit_int32_t b, jit_int32_t x, jit_int32_t s,
1456      jit_int32_t y, jit_int32_t m,jit_int32_t r)
1457 {
1458     assert(!(o &  ~0x3f));
1459     assert(!(b &  ~0x1f));
1460     assert(!(x &  ~0x1f));
1461     assert(!(s &   ~0x7));
1462     assert(!(y &  ~0x7f));
1463     assert(!(m &   ~0x1));
1464     assert(!(r &  ~0x1f));
1465     ii((o<<26)|(b<<21)|(x<<16)|(s<<13)|(y<<6)|(m<<5)|r);
1466 }
1467
1468 static void
1469 _f27(jit_state_t *_jit, jit_int32_t o, jit_int32_t i, jit_int32_t j)
1470 {
1471     assert(!(o & ~0x3f));
1472     assert(i >= -4096 && i < 4095);
1473     assert(j >=   -16 && j <   15);
1474     ii((o<<26)|(i<<13)|j);
1475 }
1476
1477 static void
1478 _f28(jit_state_t *_jit, jit_int32_t o, jit_int32_t i)
1479 {
1480     assert(!(o &      ~0x3f));
1481     assert(!(i & ~0x1ffffff));
1482     ii((o<<26)|i);
1483 }
1484
1485 static void
1486 _f29(jit_state_t *_jit, jit_int32_t o, jit_int32_t r,
1487      jit_int32_t x, jit_int32_t s, jit_int32_t y, jit_int32_t t)
1488 {
1489     assert(!(o & ~0x3f));
1490     assert(!(r & ~0x1f));
1491     assert(!(x & ~0x1f));
1492     assert(!(s &  ~0x7));
1493     assert(!(y & ~0xff));
1494     assert(!(t & ~0x1f));
1495     ii((o<<26)|(r<<21)|(x<<16)|re_assemble_3(s)|(y<<5)|t);
1496 }
1497
1498 static void
1499 _f30(jit_state_t *_jit, jit_int32_t o, jit_int32_t b, jit_int32_t r,
1500      jit_int32_t s, jit_int32_t x, jit_int32_t y, jit_int32_t t)
1501 {
1502     assert(!(o & ~0x3f));
1503     assert(!(b & ~0x1f));
1504     assert(!(r & ~0x1f));
1505     assert(!(s &  ~0x3));
1506     assert(!(x &  ~0x1));
1507     assert(!(y & ~0xff));
1508     assert(!(t & ~0x1f));
1509     ii((o<<26)|(b<<21)|(r<<16)|(s<<14)|(x<<13)|(y<<5)|t);
1510 }
1511
1512 static void
1513 _f31(jit_state_t *_jit, jit_int32_t o, jit_int32_t t,
1514      jit_int32_t r, jit_int32_t v, jit_int32_t x, jit_int32_t y)
1515 {
1516     assert(!(o & ~0x3f));
1517     assert(!(t & ~0x1f));
1518     assert(!(r & ~0x1f));
1519     assert(!(v & ~0x1f));
1520     assert(!(x & ~0xff));
1521     assert(!(y & ~0x1f));
1522     ii((o<<26)|(t<<21)|(r<<16)|(v<<14)|(x<<5)|y);
1523 }
1524
1525 static void
1526 _f33(jit_state_t *_jit, jit_int32_t o, jit_int32_t x,
1527      jit_int32_t r, jit_int32_t y, jit_int32_t z, jit_int32_t u)
1528 {
1529     assert(!(o & ~0x3f));
1530     assert(!(x & ~0x1f));
1531     assert(!(r & ~0x1f));
1532     assert(!(y &  ~0x7));
1533     assert(!(z & ~0xff));
1534     assert(!(u & ~0x1f));
1535     ii((o<<26)|(x<<21)|(r<<16)|(y<<13)|(z<<5)|u);
1536 }
1537
1538 static void
1539 _f34(jit_state_t *_jit, jit_int32_t o, jit_int32_t o1,
1540      jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1541 {
1542     assert(!(o  &   ~0x3f));
1543     assert(!(o1 & ~0x7fff));
1544     assert(!(x  &    ~0x3));
1545     assert(!(sf &    ~0x7));
1546     assert(!(n  &    ~0x1));
1547     assert(!(o2 &   ~0x1f));
1548     ii((o<<26)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1549 }
1550
1551 static void
1552 _f35(jit_state_t *_jit, jit_int32_t o, jit_int32_t op,
1553      jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t t)
1554 {
1555     assert(!(o  &   ~0x3f));
1556     assert(!(op & ~0x7fff));
1557     assert(!(x  &    ~0x3));
1558     assert(!(sf &    ~0x7));
1559     assert(!(n  &    ~0x1));
1560     assert(!(t  &   ~0x1f));
1561     ii((o<<26)|(op<<11)|(x<<9)|(sf<<6)|(n<<5)|t);
1562 }
1563
1564 static void
1565 _f36(jit_state_t *_jit, jit_int32_t o, jit_int32_t r, jit_int32_t o1,
1566      jit_int32_t x, jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1567 {
1568     assert(!(o  &  ~0x3f));
1569     assert(!(r  &  ~0x1f));
1570     assert(!(o1 & ~0x3ff));
1571     assert(!(x  &   ~0x3));
1572     assert(!(sf &   ~0x7));
1573     assert(!(n  &   ~0x1));
1574     assert(!(o2 &  ~0x1f));
1575     ii((o<<26)|(r<<21)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1576 }
1577
1578 static void
1579 _f37(jit_state_t *_jit, jit_int32_t o, jit_int32_t r2,
1580      jit_int32_t r1, jit_int32_t o1, jit_int32_t x,
1581      jit_int32_t sf, jit_int32_t n, jit_int32_t o2)
1582 {
1583     assert(!(o  & ~0x3f));
1584     assert(!(r2 & ~0x1f));
1585     assert(!(r1 & ~0x1f));
1586     assert(!(o1 & ~0x1f));
1587     assert(!(x  &  ~0x3));
1588     assert(!(sf &  ~0x7));
1589     assert(!(n  &  ~0x1));
1590     assert(!(o2 & ~0x1f));
1591     ii((o<<26)|(r2<<21)|(r1<<16)|(o1<<11)|(x<<9)|(sf<<6)|(n<<5)|o2);
1592 }
1593
1594 static void
1595 _f38(jit_state_t *_jit, jit_int32_t o,
1596      jit_int32_t s, jit_int32_t u, jit_int32_t n)
1597 {
1598     assert(!(o &     ~0x3f));
1599     assert(!(s & ~0x3fffff));
1600     assert(!(u &      ~0x7));
1601     assert(!(n &      ~0x1));
1602     ii((o<<26)|((s>>5)<<9)|(u<<6)|(n<<1)|(s&0x1f));
1603 }
1604
1605 static void
1606 _nop(jit_state_t *_jit, jit_int32_t i0)
1607 {
1608     for (; i0 > 0; i0 -= 4)
1609         NOP();
1610     assert(i0 == 0);
1611 }
1612
1613 static void
1614 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1615 {
1616     if (r0 != r1)
1617         COPY(r1, r0);
1618 }
1619
1620 static void
1621 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1622 {
1623     if (i0 >= -8192 && i0 <= 8191)
1624         LDI(i0, r0);
1625     else if (!(i0 & 0x7ff))
1626         LDIL(i0, r0);
1627     else {
1628         LDIL(i0 & ~0x7ff, r0);
1629         LDO(i0 & 0x7ff, r0, r0);
1630     }
1631 }
1632
1633 static jit_word_t
1634 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1635 {
1636     jit_word_t          w;
1637     w = _jit->pc.w;
1638     LDIL(i0 & ~0x7ff, r0);
1639     LDO(i0 & 0x7ff, r0, r0);
1640     return (w);
1641 }
1642
1643 static void
1644 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1645 {
1646     jit_int32_t         reg;
1647     if (r0 == r1) {
1648         reg = jit_get_reg(jit_class_gpr);
1649         movr(rn(reg), r1);
1650         EXTRWR_U(rn(reg), 23, 8, r0);
1651         DEPWR(rn(reg), 23, 8, r0);
1652         jit_unget_reg(reg);
1653     }
1654     else {
1655         EXTRWR_U(r1, 23, 8, r0);
1656         DEPWR(r1, 23, 8, r0);
1657     }
1658 }
1659
1660 static void
1661 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1662 {
1663     jit_int32_t         reg;
1664     if (r0 == r1) {
1665         reg = jit_get_reg(jit_class_gpr);
1666         movr(rn(reg), r1);
1667         SHRPWI(rn(reg), rn(reg), 16, r0);
1668         DEPWR(r0, 15, 8, r0);
1669         SHRPWI(rn(reg), r0, 8, r0);
1670         jit_unget_reg(reg);
1671     }
1672     else {
1673         SHRPWI(r1, r1, 16, r0);
1674         DEPWR(r0, 15, 8, r0);
1675         SHRPWI(r1, r0, 8, r0);
1676     }
1677 }
1678
1679 static void
1680 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1681 {
1682     jit_word_t  w;
1683     w = beqi(_jit->pc.w, r2, 0);
1684     COPY(r1, r0);
1685     patch_at(w, _jit->pc.w);
1686 }
1687
1688 static void
1689 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1690 {
1691     jit_word_t  w;
1692     w = bnei(_jit->pc.w, r2, 0);
1693     COPY(r1, r0);
1694     patch_at(w, _jit->pc.w);
1695 }
1696
1697 static void
1698 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1699       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1700 {
1701 #if defined(__linux__) && defined(SYS_atomic_cmpxchg_32) &&  __WORDSIZE == 32
1702     /* Not defined, and unlikely to ever be defined, but could be a way to do it */
1703     movi(_R26_REGNO, SYS_atomic_cmpxchg_32);
1704     if (r1 == _NOREG)
1705         movi(_R25_REGNO, i0);
1706     else
1707         movr(_R25_REGNO, r1);
1708     movr(_R24_REGNO, r2);
1709     movr(_R23_REGNO, r3);
1710     /* Should only fail for an invalid or unaligned address.
1711      * Do not handle this condition. */
1712     calli(syscall);
1713     movr(r0, _R28_REGNO);
1714 #else
1715     /*
1716      * The only atomic operations are LDCW and LDCD, that load a value,
1717      * and store zero at the address atomically. The (semaphore) address
1718      * must be 16 byte aligned.
1719      */
1720     fallback_casx(r0, r1, r2, r3, i0);
1721     /*
1722      * It is important to be aware of the delayed nature of cache flush and
1723      *  purge operations, and to use SYNC instructions to force completion
1724      * where necessary. The following example illustrates this.
1725      * Consider two processes sharing a memory location x which is protected
1726      * by a semaphore s.
1727      *
1728      * process A on Processor 1 |  process B on Processor 2 |  note
1729      * -------------------------+---------------------------+------------
1730      * LDCW s                   |                           | A acquires semaphore
1731      * PDC x                    |                           | A executes purge
1732      * SYNC                     |                           | Force completion of purge
1733      * STW s                    |                           | A releases semaphore
1734      *                          | LDCW s                    | B acquires semaphore
1735      *                          | STW x
1736      *
1737      * In the absence of the SYNC instruction, it would be possible for
1738      *  process B's store to x to complete before the purge of x is completed
1739      * (since the purge may have been delayed). The purge of x could then
1740      * destroy the new value.
1741      */
1742 #endif
1743 }
1744
1745 static void
1746 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1747 {
1748     jit_int32_t         reg;
1749     if (i0 >= -1024 && i0 <= 1023)
1750         ADDI(i0, r1, r0);
1751     else {
1752         reg = jit_get_reg(jit_class_gpr);
1753         movi(rn(reg), i0);
1754         addr(r0, r1, rn(reg));
1755         jit_unget_reg(reg);
1756     }
1757 }
1758
1759 static void
1760 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1761 {
1762     jit_int32_t         reg;
1763     reg = jit_get_reg(jit_class_gpr);
1764     movi(rn(reg), i0);
1765     addcr(r0, r1, rn(reg));
1766     jit_unget_reg(reg);
1767 }
1768
1769 static void
1770 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1771 {
1772     jit_int32_t         reg;
1773     reg = jit_get_reg(jit_class_gpr);
1774     movi(rn(reg), i0);
1775     addxr(r0, r1, rn(reg));
1776     jit_unget_reg(reg);
1777 }
1778
1779 static void
1780 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1781 {
1782     jit_int32_t         reg;
1783     if (i0 >= -1023 && i0 <= 1024)
1784         addi(r0, r1, -i0);
1785     else {
1786         reg = jit_get_reg(jit_class_gpr);
1787         movi(rn(reg), i0);
1788         subr(r0, r1, rn(reg));
1789         jit_unget_reg(reg);
1790     }
1791 }
1792
1793 static void
1794 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1795 {
1796     jit_int32_t         reg;
1797     reg = jit_get_reg(jit_class_gpr);
1798     movi(rn(reg), i0);
1799     subcr(r0, r1, rn(reg));
1800     jit_unget_reg(reg);
1801 }
1802
1803 static void
1804 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1805 {
1806     jit_int32_t         reg;
1807     reg = jit_get_reg(jit_class_gpr);
1808     movi(rn(reg), i0);
1809     subxr(r0, r1, rn(reg));
1810     jit_unget_reg(reg);
1811 }
1812
1813 static void
1814 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1815 {
1816     jit_int32_t         reg;
1817     if (i0 >= -1024 && i0 <= 1023)
1818         SUBI(i0, r1, r0);
1819     else {
1820         reg = jit_get_reg(jit_class_gpr);
1821         movi(rn(reg), i0);
1822         subr(r0, rn(reg), r1);
1823         jit_unget_reg(reg);
1824     }
1825 }
1826
1827 static void
1828 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1829 {
1830     jit_int32_t         t0, t1;
1831     t0 = jit_get_reg(jit_class_fpr);
1832     t1 = jit_get_reg(jit_class_fpr);
1833     stxi(alloca_offset - 8, _FP_REGNO, r1);
1834     ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1835     stxi(alloca_offset - 8, _FP_REGNO, r2);
1836     ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1837     XMPYU(rn(t0), rn(t1), rn(t0));
1838     stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1839     ldxi(r0, _FP_REGNO, alloca_offset - 4);
1840     jit_unget_reg(t1);
1841     jit_unget_reg(t0);
1842 }
1843
1844 static void
1845 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1846 {
1847     jit_int32_t         reg;
1848     if (r0 != r1) {
1849         movi(r0, i0);
1850         mulr(r0, r1, r0);
1851     }
1852     else {
1853         reg = jit_get_reg(jit_class_gpr);
1854         movi(rn(reg), i0);
1855         mulr(r0, r1, rn(reg));
1856         jit_unget_reg(reg);
1857     }
1858 }
1859
1860 static long long
1861 __llmul(int u, int v)
1862 {
1863     return ((long long)u * (long long)v);
1864 }
1865
1866 static void
1867 _qmulr(jit_state_t *_jit,
1868        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1869 {
1870     movr(_R26_REGNO, r2);
1871     movr(_R25_REGNO, r3);
1872     calli((jit_word_t)__llmul);
1873     movr(r0, _R29_REGNO);
1874     movr(r1, _R28_REGNO);
1875 }
1876
1877 static void
1878 _qmuli(jit_state_t *_jit,
1879        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1880 {
1881     movr(_R26_REGNO, r2);
1882     movi(_R25_REGNO, i0);
1883     calli((jit_word_t)__llmul);
1884     movr(r0, _R29_REGNO);
1885     movr(r1, _R28_REGNO);
1886 }
1887
1888 static void
1889 _qmulr_u(jit_state_t *_jit,
1890          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1891 {
1892     jit_int32_t         t0, t1;
1893     t0 = jit_get_reg(jit_class_fpr);
1894     t1 = jit_get_reg(jit_class_fpr);
1895     stxi(alloca_offset - 8, _FP_REGNO, r2);
1896     ldxi_f(rn(t0), _FP_REGNO, alloca_offset - 8);
1897     stxi(alloca_offset - 8, _FP_REGNO, r3);
1898     ldxi_f(rn(t1), _FP_REGNO, alloca_offset - 8);
1899     XMPYU(rn(t0), rn(t1), rn(t0));
1900     stxi_d(alloca_offset - 8, _FP_REGNO, rn(t0));
1901     ldxi(r0, _FP_REGNO, alloca_offset - 4);
1902     ldxi(r1, _FP_REGNO, alloca_offset - 8);
1903     jit_unget_reg(t1);
1904     jit_unget_reg(t0);
1905 }
1906
1907 static void
1908 _qmuli_u(jit_state_t *_jit,
1909          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1910 {
1911     jit_int32_t         reg;
1912     reg = jit_get_reg(jit_class_gpr);
1913     movi(rn(reg), i0);
1914     qmulr_u(r0, r1, r2, rn(reg));
1915     jit_unget_reg(reg);
1916 }
1917
1918 static int
1919 __idiv(int u, int v)
1920 {
1921     return (u / v);
1922 }
1923
1924 static void
1925 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1926 {
1927     movr(_R26_REGNO, r1);
1928     movr(_R25_REGNO, r2);
1929     calli((jit_word_t)__idiv);
1930     movr(r0, _R28_REGNO);
1931 }
1932
1933 static void
1934 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1935 {
1936     movr(_R26_REGNO, r1);
1937     movi(_R25_REGNO, i0);
1938     calli((jit_word_t)__idiv);
1939     movr(r0, _R28_REGNO);
1940 }
1941
1942 static unsigned int
1943 __udiv(unsigned int u, unsigned int v)
1944 {
1945     return (u / v);
1946 }
1947
1948 static void
1949 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1950 {
1951     movr(_R26_REGNO, r1);
1952     movr(_R25_REGNO, r2);
1953     calli((jit_word_t)__udiv);
1954     movr(r0, _R28_REGNO);
1955 }
1956
1957 static void
1958 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1959 {
1960     movr(_R26_REGNO, r1);
1961     movi(_R25_REGNO, i0);
1962     calli((jit_word_t)__udiv);
1963     movr(r0, _R28_REGNO);
1964 }
1965
1966 static int
1967 __irem(int u, int v)
1968 {
1969     return (u % v);
1970 }
1971
1972 static void
1973 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1974 {
1975     movr(_R26_REGNO, r1);
1976     movr(_R25_REGNO, r2);
1977     calli((jit_word_t)__irem);
1978     movr(r0, _R28_REGNO);
1979 }
1980
1981 static void
1982 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1983 {
1984     movr(_R26_REGNO, r1);
1985     movi(_R25_REGNO, i0);
1986     calli((jit_word_t)__irem);
1987     movr(r0, _R28_REGNO);
1988 }
1989
1990 static unsigned int
1991 __urem(unsigned int u, unsigned int v)
1992 {
1993     return (u % v);
1994 }
1995
1996 static void
1997 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1998 {
1999     movr(_R26_REGNO, r1);
2000     movr(_R25_REGNO, r2);
2001     calli((jit_word_t)__urem);
2002     movr(r0, _R28_REGNO);
2003 }
2004
2005 static void
2006 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2007 {
2008     movr(_R26_REGNO, r1);
2009     movi(_R25_REGNO, i0);
2010     calli((jit_word_t)__urem);
2011     movr(r0, _R28_REGNO);
2012 }
2013
2014 static idiv_t
2015 __idivrem(int u, int v)
2016 {
2017     idiv_t      div;
2018     div.quo = u / v;
2019     div.rem = u % v;
2020     return (div);
2021 }
2022
2023 static void
2024 _qdivr(jit_state_t *_jit,
2025        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2026 {
2027     movr(_R26_REGNO, r2);
2028     movr(_R25_REGNO, r3);
2029     calli((jit_word_t)__idivrem);
2030     movr(r0, _R28_REGNO);
2031     movr(r1, _R29_REGNO);
2032 }
2033
2034 static void
2035 _qdivi(jit_state_t *_jit,
2036        jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2037 {
2038     movr(_R26_REGNO, r2);
2039     movi(_R25_REGNO, i0);
2040     calli((jit_word_t)__idivrem);
2041     movr(r0, _R28_REGNO);
2042     movr(r1, _R29_REGNO);
2043 }
2044
2045 static udiv_t
2046 __udivrem(unsigned int u, unsigned int v)
2047 {
2048     udiv_t      div;
2049     div.quo = u / v;
2050     div.rem = u % v;
2051     return (div);
2052 }
2053
2054 static void
2055 _qdivr_u(jit_state_t *_jit,
2056          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2057 {
2058     movr(_R26_REGNO, r2);
2059     movr(_R25_REGNO, r3);
2060     calli((jit_word_t)__udivrem);
2061     movr(r0, _R28_REGNO);
2062     movr(r1, _R29_REGNO);
2063 }
2064
2065 static void
2066 _qdivi_u(jit_state_t *_jit,
2067          jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2068 {
2069     movr(_R26_REGNO, r2);
2070     movi(_R25_REGNO, i0);
2071     calli((jit_word_t)__udivrem);
2072     movr(r0, _R28_REGNO);
2073     movr(r1, _R29_REGNO);
2074 }
2075
2076 static void
2077 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2078 {
2079     jit_int32_t         reg;
2080     reg = jit_get_reg(jit_class_gpr);
2081     movi(rn(reg), i0);
2082     andr(r0, r1, rn(reg));
2083     jit_unget_reg(reg);
2084 }
2085
2086 static void
2087 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2088 {
2089     jit_int32_t         reg;
2090     reg = jit_get_reg(jit_class_gpr);
2091     movi(rn(reg), i0);
2092     orr(r0, r1, rn(reg));
2093     jit_unget_reg(reg);
2094 }
2095
2096 static void
2097 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2098 {
2099     jit_int32_t         reg;
2100     reg = jit_get_reg(jit_class_gpr);
2101     movi(rn(reg), i0);
2102     xorr(r0, r1, rn(reg));
2103     jit_unget_reg(reg);
2104 }
2105
2106 static void
2107 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2108 {
2109     SUBI(0x1f, r2, _R1_REGNO);
2110     MTSAR(_R1_REGNO);
2111     DEPW_Z(r1, 32, r0);
2112 }
2113
2114 static void
2115 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2116 {
2117     SUBI(0x1f, r2, _R1_REGNO);
2118     MTSAR(_R1_REGNO);
2119     EXTRW(r1, 32, r0);
2120 }
2121
2122 static void
2123 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2124 {
2125     SUBI(0x1f, r2, _R1_REGNO);
2126     MTSAR(_R1_REGNO);
2127     EXTRW_U(r1, 32, r0);
2128 }
2129
2130 static void
2131 _cmpr(jit_state_t *_jit, jit_word_t c,
2132       jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2133 {
2134     CMPCLR_(c, r1, r2, r0);
2135     LDI(1, r0);
2136 }
2137
2138 static void
2139 _cmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2140       jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2141 {
2142     jit_int32_t         reg;
2143     if (i0 >= -16 && i0 <= 15)
2144         CMPICLR_(ci, i0, r1, r0);
2145     else {
2146         reg = jit_get_reg(jit_class_gpr);
2147         movi(rn(reg), i0);
2148         CMPCLR_(c, r1, rn(reg), r0);
2149         jit_unget_reg(reg);
2150     }
2151     LDI(1, r0);
2152 }
2153
2154 static void
2155 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2156 {
2157     ldr_uc(r0, r1);
2158     extr_c(r0, r0);
2159 }
2160
2161 static void
2162 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2163 {
2164     ldi_uc(r0, i0);
2165     extr_c(r0, r0);
2166 }
2167
2168 static void
2169 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2170 {
2171     ldxr_uc(r0, r1, r2);
2172     extr_c(r0, r0);
2173 }
2174
2175 static void
2176 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2177 {
2178     ldxi_uc(r0, r1, i0);
2179     extr_c(r0, r0);
2180 }
2181
2182 static void
2183 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2184 {
2185     jit_int32_t         reg;
2186     if (i0 >= -8182 && i0 <= 8191)
2187         LDBL(i0, _R0_REGNO, r0);
2188     else {
2189         reg = jit_get_reg(jit_class_gpr);
2190         LDIL(i0 & ~0x7ff, rn(reg));
2191         LDBL(sign_extend(i0, 11), rn(reg), r0);
2192         jit_unget_reg(reg);
2193     }
2194 }
2195
2196 static void
2197 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2198 {
2199     jit_int32_t         reg;
2200     if (i0 >= -16 && i0 <= 15)
2201         LDBI(i0, r1, r0);
2202     else if (i0 >= -8182 && i0 <= 8191)
2203         LDBL(i0, r1, r0);
2204     else {
2205         reg = jit_get_reg(jit_class_gpr);
2206         movi(rn(reg), i0);
2207         ldxr_uc(r0, r1, rn(reg));
2208         jit_unget_reg(reg);
2209     }
2210 }
2211
2212 static void
2213 _ldr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2214 {
2215     ldr_us(r0, r1);
2216     extr_s(r0, r0);
2217 }
2218
2219 static void
2220 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2221 {
2222     ldi_us(r0, i0);
2223     extr_s(r0, r0);
2224 }
2225
2226 static void
2227 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2228 {
2229     ldxr_us(r0, r1, r2);
2230     extr_s(r0, r0);
2231 }
2232
2233 static void
2234 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2235 {
2236     ldxi_us(r0, r1, i0);
2237     extr_s(r0, r0);
2238 }
2239
2240 static void
2241 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2242 {
2243     jit_int32_t         reg;
2244     if (i0 >= -8182 && i0 <= 8191)
2245         LDHL(i0, _R0_REGNO, r0);
2246     else {
2247         reg = jit_get_reg(jit_class_gpr);
2248         LDIL(i0 & ~0x7ff, rn(reg));
2249         LDHL(sign_extend(i0, 11), rn(reg), r0);
2250         jit_unget_reg(reg);
2251     }
2252 }
2253
2254 static void
2255 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2256 {
2257     jit_int32_t         reg;
2258     if (i0 >= -16 && i0 <= 15)
2259         LDHI(i0, r1, r0);
2260     else if (i0 >= -8182 && i0 <= 8191)
2261         LDHL(i0, r1, r0);
2262     else {
2263         reg = jit_get_reg(jit_class_gpr);
2264         movi(rn(reg), i0);
2265         ldxr_us(r0, r1, rn(reg));
2266         jit_unget_reg(reg);
2267     }
2268 }
2269
2270 static void
2271 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2272 {
2273     jit_int32_t         reg;
2274     if (i0 >= -8182 && i0 <= 8191)
2275         LDWL(i0, _R0_REGNO, r0);
2276     else {
2277         reg = jit_get_reg(jit_class_gpr);
2278         LDIL(i0 & ~0x7ff, rn(reg));
2279         LDWL(sign_extend(i0, 11), rn(reg), r0);
2280         jit_unget_reg(reg);
2281     }
2282 }
2283
2284 static void
2285 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2286 {
2287     jit_int32_t         reg;
2288     if (i0 >= -16 && i0 <= 15)
2289         LDWI(i0, r1, r0);
2290     else if (i0 >= -8182 && i0 <= 8191)
2291         LDWL(i0, r1, r0);
2292     else {
2293         reg = jit_get_reg(jit_class_gpr);
2294         movi(rn(reg), i0);
2295         ldxr_ui(r0, r1, rn(reg));
2296         jit_unget_reg(reg);
2297     }
2298 }
2299
2300 static void
2301 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2302 {
2303     jit_int32_t         reg;
2304     if (i0 >= -8182 && i0 <= 8191)
2305         STBL(r0, i0, _R0_REGNO);
2306     else {
2307         reg = jit_get_reg(jit_class_gpr);
2308         LDIL(i0 & ~0x7ff, rn(reg));
2309         STBL(r0, sign_extend(i0, 11), rn(reg));
2310         jit_unget_reg(reg);
2311     }
2312 }
2313
2314 static void
2315 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2316 {
2317     jit_int32_t         reg;
2318     reg = jit_get_reg(jit_class_gpr);
2319     addr(rn(reg), r0, r1);
2320     str_c(rn(reg), r2);
2321     jit_unget_reg(reg);
2322 }
2323
2324 static void
2325 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2326 {
2327     jit_int32_t         reg;
2328     if (i0 >= -16 && i0 <= 15)
2329         STBI(r1, i0, r0);
2330     else if (i0 >= -8182 && i0 <= 8191)
2331         STBL(r1, i0, r0);
2332     else {
2333         reg = jit_get_reg(jit_class_gpr);
2334         addi(rn(reg), r0, i0);
2335         str_c(rn(reg), r1);
2336         jit_unget_reg(reg);
2337     }
2338 }
2339
2340 static void
2341 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2342 {
2343     jit_int32_t         reg;
2344     if (i0 >= -8182 && i0 <= 8191)
2345         STHL(r0, i0, _R0_REGNO);
2346     else {
2347         reg = jit_get_reg(jit_class_gpr);
2348         LDIL(i0 & ~0x7ff, rn(reg));
2349         STHL(r0, sign_extend(i0, 11), rn(reg));
2350         jit_unget_reg(reg);
2351     }
2352 }
2353
2354 static void
2355 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2356 {
2357     jit_int32_t         reg;
2358     reg = jit_get_reg(jit_class_gpr);
2359     addr(rn(reg), r0, r1);
2360     str_s(rn(reg), r2);
2361     jit_unget_reg(reg);
2362 }
2363
2364 static void
2365 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2366 {
2367     jit_int32_t         reg;
2368     if (i0 >= -16 && i0 <= 15)
2369         STHI(r1, i0, r0);
2370     else if (i0 >= -8182 && i0 <= 8191)
2371         STHL(r1, i0, r0);
2372     else {
2373         reg = jit_get_reg(jit_class_gpr);
2374         addi(rn(reg), r0, i0);
2375         str_s(rn(reg), r1);
2376         jit_unget_reg(reg);
2377     }
2378 }
2379
2380 static void
2381 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2382 {
2383     jit_int32_t         reg;
2384     if (i0 >= -8182 && i0 <= 8191)
2385         STWL(r0, i0, _R0_REGNO);
2386     else {
2387         reg = jit_get_reg(jit_class_gpr);
2388         LDIL(i0 & ~0x7ff, rn(reg));
2389         STWL(r0, sign_extend(i0, 11), rn(reg));
2390         jit_unget_reg(reg);
2391     }
2392 }
2393
2394 static void
2395 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2396 {
2397     jit_int32_t         reg;
2398     reg = jit_get_reg(jit_class_gpr);
2399     addr(rn(reg), r0, r1);
2400     str_i(rn(reg), r2);
2401     jit_unget_reg(reg);
2402 }
2403
2404 static void
2405 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2406 {
2407     jit_int32_t         reg;
2408     if (i0 >= -16 && i0 <= 15)
2409         STWI(r1, i0, r0);
2410     else if (i0 >= -8182 && i0 <= 8191)
2411         STWL(r1, i0, r0);
2412     else {
2413         reg = jit_get_reg(jit_class_gpr);
2414         addi(rn(reg), r0, i0);
2415         str_i(rn(reg), r1);
2416         jit_unget_reg(reg);
2417     }
2418 }
2419
2420 static jit_word_t
2421 _bcmpr(jit_state_t *_jit, jit_word_t c,
2422        jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2423 {
2424     jit_word_t          w;
2425     w = _jit->pc.w;
2426     CMPB_N_(c, r0, r1, ((i0 - w) >> 2) - 2);
2427     NOP();
2428     return (w);
2429 }
2430
2431 static jit_word_t
2432 _bcmpi(jit_state_t *_jit, jit_word_t c, jit_word_t ci,
2433        jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2434 {
2435     jit_word_t          w;
2436     jit_int32_t         reg;
2437     if (i1 >= -16 && i1 <= 15) {
2438         w = _jit->pc.w;
2439         CMPIB_N_(ci, i1, r0, ((i0 - w) >> 2) - 2);
2440     }
2441     else {
2442         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2443         movi(rn(reg), i1);
2444         w = _jit->pc.w;
2445         CMPB_N_(c, r0, rn(reg), ((i0 - w) >> 2) - 2);
2446         jit_unget_reg(reg);
2447     }
2448     NOP();
2449     return (w);
2450 }
2451
2452 static jit_word_t
2453 _bmxr(jit_state_t *_jit, jit_bool_t c,
2454       jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2455 {
2456     jit_word_t          w;
2457     jit_int32_t         reg;
2458     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2459     andr(rn(reg), r0, r1);
2460     w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2461     jit_unget_reg(reg);
2462     return (w);
2463 }
2464
2465 static jit_word_t
2466 _bmxi(jit_state_t *_jit, jit_bool_t c,
2467       jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2468 {
2469     jit_word_t          w;
2470     jit_int32_t         reg;
2471     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2472     movi(rn(reg), i1);
2473     andr(rn(reg), r0, rn(reg));
2474     w = c ? bnei(i0, rn(reg), 0) : beqi(i0, rn(reg), 0);
2475     jit_unget_reg(reg);
2476     return (w);
2477 }
2478
2479 static jit_word_t
2480 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2481 {
2482     jit_word_t          w;
2483     w = _jit->pc.w;
2484     ADDB_N_SV(r1, r0, ((i0 - w) >> 2) - 2);
2485     NOP();
2486     return (w);
2487 }
2488
2489 static jit_word_t
2490 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2491 {
2492     jit_word_t          w;
2493     jit_int32_t         reg;
2494     if (i1 >= -16 && i1 <= 15) {
2495         w = _jit->pc.w;
2496         ADDIB_N_SV(i1, r0, ((i0 - w) >> 2) - 2);
2497         NOP();
2498     }
2499     else {
2500         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2501         movi(rn(reg), i1);
2502         w = boaddr(i0, r0, rn(reg));
2503         jit_unget_reg(reg);
2504     }
2505     return (w);
2506 }
2507
2508 static jit_word_t
2509 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2510 {
2511     jit_word_t          w;
2512     w = _jit->pc.w;
2513     ADDB_N_UV(r1, r0, ((i0 - w) >> 2) - 2);
2514     NOP();
2515     return (w);
2516 }
2517
2518 static jit_word_t
2519 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2520 {
2521     jit_word_t          w;
2522     jit_int32_t         reg;
2523     if (i1 >= -16 && i1 <= 15) {
2524         w = _jit->pc.w;
2525         ADDIB_N_UV(i1, r0, ((i0 - w) >> 2) - 2);
2526         NOP();
2527     }
2528     else {
2529         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2530         movi(rn(reg), i1);
2531         w = boaddr_u(i0, r0, rn(reg));
2532         jit_unget_reg(reg);
2533     }
2534     return (w);
2535 }
2536
2537 static jit_word_t
2538 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2539 {
2540     jit_word_t          w;
2541     w = _jit->pc.w;
2542     ADDB_N_NSV(r1, r0, ((i0 - w) >> 2) - 2);
2543     NOP();
2544     return (w);
2545 }
2546
2547 static jit_word_t
2548 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2549 {
2550     jit_word_t          w;
2551     jit_int32_t         reg;
2552     if (i1 >= -16 && i1 <= 15) {
2553         w = _jit->pc.w;
2554         ADDIB_N_NSV(i1, r0, ((i0 - w) >> 2) - 2);
2555         NOP();
2556     }
2557     else {
2558         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2559         movi(rn(reg), i1);
2560         w = bxaddr(i0, r0, rn(reg));
2561         jit_unget_reg(reg);
2562     }
2563     return (w);
2564 }
2565
2566 static jit_word_t
2567 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2568 {
2569     jit_word_t          w;
2570     w = _jit->pc.w;
2571     ADDB_N_NUV(r1, r0, ((i0 - w) >> 2) - 2);
2572     NOP();
2573     return (w);
2574 }
2575
2576 static jit_word_t
2577 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2578 {
2579     jit_word_t          w;
2580     jit_int32_t         reg;
2581     if (i1 >= -16 && i1 <= 15) {
2582         w = _jit->pc.w;
2583         ADDIB_N_NUV(i1, r0, ((i0 - w) >> 2) - 2);
2584         NOP();
2585     }
2586     else {
2587         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2588         movi(rn(reg), i1);
2589         w = bxaddr_u(i0, r0, rn(reg));
2590         jit_unget_reg(reg);
2591     }
2592     return (w);
2593 }
2594
2595 static jit_word_t
2596 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2597 {
2598     jit_word_t          w;
2599     SUB_NSV(r0, r1, r0);
2600     w = _jit->pc.w;
2601     /* null'ed if no signed overflow */
2602     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2603     NOP();
2604     return (w);
2605 }
2606
2607 static jit_word_t
2608 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2609 {
2610     movi(_R1_REGNO, i1);
2611     return (bosubr(i0, r0, _R1_REGNO));
2612 }
2613
2614 static jit_word_t
2615 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2616 {
2617     SUB(r0, r1, r0);
2618     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2619     return (bnei(i0, _R1_REGNO, 0));
2620 }
2621
2622 static jit_word_t
2623 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2624 {
2625     movi(_R1_REGNO, i1);
2626     SUB(r0, _R1_REGNO, r0);
2627     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2628     return (bnei(i0, _R1_REGNO, 0));
2629 }
2630
2631 static jit_word_t
2632 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2633 {
2634     jit_word_t          w;
2635     SUB_SV(r0, r1, r0);
2636     w = _jit->pc.w;
2637     /* null'ed if signed overflow */
2638     B_N(((i0 - w) >> 2) - 2, _R0_REGNO);
2639     NOP();
2640     return (w);
2641 }
2642
2643 static jit_word_t
2644 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2645 {
2646     movi(_R1_REGNO, i1);
2647     return (bxsubr(i0, r0, _R1_REGNO));
2648 }
2649
2650 static jit_word_t
2651 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2652 {
2653     SUB(r0, r1, r0);
2654     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2655     return (beqi(i0, _R1_REGNO, 0));
2656 }
2657
2658 static jit_word_t
2659 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2660 {
2661     movi(_R1_REGNO, i1);
2662     SUB(r0, _R1_REGNO, r0);
2663     SUB_B(_R0_REGNO, _R0_REGNO, _R1_REGNO);
2664     return (beqi(i0, _R1_REGNO, 0));
2665 }
2666
2667 static void
2668 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2669 {
2670     BV_N(_R0_REGNO, r0);
2671 }
2672
2673 static jit_word_t
2674 _jmpi(jit_state_t *_jit, jit_word_t i0)
2675 {
2676     jit_word_t          d, w;
2677     w = _jit->pc.w;
2678     d = ((i0 - w) >> 2) - 2;
2679     if (d >= -32768 && d <= 32767)
2680         B_N(d, _R0_REGNO);
2681     else {
2682         movi(_R1_REGNO, d);
2683         BV_N(_R0_REGNO, _R1_REGNO);
2684     }
2685     return (w);
2686 }
2687
2688 static jit_word_t
2689 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2690 {
2691     jit_word_t          w;
2692     w = movi_p(_R1_REGNO, i0);
2693     jmpr(_R1_REGNO);
2694     return (w);
2695 }
2696
2697 static void
2698 _callr(jit_state_t *_jit, jit_int32_t r0)
2699 {
2700     jit_word_t          dyn;
2701     jit_word_t          imm;
2702     if (r0 != _R1_REGNO)
2703         COPY(r0, _R1_REGNO);
2704     /* inline $$dyncall */
2705     imm = _jit->pc.w;
2706     BBI_N_GE(_R1_REGNO, 30, 0);         /*   if (r1 & 2) {              */
2707     DEPWRI(0, 31, 2, _R1_REGNO);        /*      r1 &= ~2;               */
2708     LDWI(4, _R1_REGNO, _R19_REGNO);     /*      r19 = r1[1];            */
2709     LDWI(0, _R1_REGNO, _R1_REGNO);      /*      r1  = r1[0];            */
2710                                         /*   }                          */
2711     BVE_L(_R1_REGNO);
2712     STWL(_RP_REGNO, -24, _SP_REGNO);
2713     dyn = _jit->pc.w;
2714     jmpi(_jit->pc.w);
2715     patch_at(imm, _jit->pc.w);
2716     BVE_L_N(_R1_REGNO);
2717     NOP();
2718     patch_at(dyn, _jit->pc.w);
2719 }
2720
2721 static void
2722 _calli(jit_state_t *_jit, jit_word_t i0)
2723 {
2724     jit_word_t          w;
2725     if (i0 & 2) {
2726         i0 &= -4;
2727         movi(_R1_REGNO, i0);
2728         LDWI(4, _R1_REGNO, _R19_REGNO);
2729         LDWI(0, _R1_REGNO, _R1_REGNO);
2730         BVE_L(_R1_REGNO);
2731         STWL(_RP_REGNO, -24, _SP_REGNO);
2732     }
2733     else {
2734         w = ((i0 - _jit->pc.w) >> 2) - 2;
2735         if (w >= -32768 && w <= 32767)
2736             B_L_N(w);
2737         else {
2738             movi(_R1_REGNO, i0);
2739             BVE_L_N(_R1_REGNO);
2740         }
2741         NOP();
2742     }
2743 }
2744
2745 static jit_word_t
2746 _calli_p(jit_state_t *_jit, jit_word_t i0)
2747 {
2748     jit_word_t          w;
2749     w = movi_p(_R1_REGNO, i0);
2750     callr(_R1_REGNO);
2751     return (w);
2752 }
2753
2754 static jit_int32_t gr[] = {
2755      _R4,  _R5,  _R6,  _R7,  _R8,
2756      _R9, _R10, _R11, _R12, _R13,
2757     _R14, _R15, _R16, _R17, _R18
2758 };
2759
2760 static jit_int32_t fr[] = {
2761     _F12, _F13, _F14, _F15, _F16,
2762     _F17, _F18, _F19, _F20, _F21
2763 };
2764
2765 static void
2766 _prolog(jit_state_t *_jit, jit_node_t *node)
2767 {
2768     jit_int32_t         regno;
2769     jit_word_t          offset;
2770
2771     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2772         /* hppa stack grows up */
2773         assert(_jitc->function->self.aoff <= _jitc->function->frame);
2774         if (_jitc->function->assume_frame)
2775             return;
2776         _jitc->function->self.aoff = _jitc->function->frame;
2777     }
2778     if (_jitc->function->allocar) {
2779         _jitc->function->self.aoff += 63;
2780         _jitc->function->self.aoff &= -64;
2781     }
2782     _jitc->function->stack = ((_jitc->function->self.aoff -
2783                                _jitc->function->self.alen -
2784                                _jitc->function->self.size) + 63) & -64;
2785
2786     /* Save stack frame (FIXME Only required if non leaf) */
2787     STWL(_RP_REGNO, -20, _SP_REGNO);
2788
2789     /* Create stack frame */
2790     COPY(_FP_REGNO, _R1_REGNO);
2791     COPY(_SP_REGNO, _FP_REGNO);
2792     STWL_MA(_R1_REGNO, _jitc->function->stack, _SP_REGNO);
2793
2794     /* Save any modified callee save registers */
2795     offset = alloca_offset - 140;
2796     for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2797         if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2798             stxi(offset, _FP_REGNO, rn(gr[regno]));
2799     }
2800     for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2801         if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2802             stxi_d(offset, _FP_REGNO, rn(fr[regno]));
2803     }
2804
2805     if (_jitc->function->allocar) {
2806         regno = jit_get_reg(jit_class_gpr);
2807         movi(rn(regno), _jitc->function->self.aoff);
2808         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
2809         jit_unget_reg(regno);
2810     }
2811
2812     if (_jitc->function->self.call & jit_call_varargs) {
2813         for (regno = 3; regno >= _jitc->function->vagp; --regno)
2814             stxi(params_offset - regno * 4 - 4, _FP_REGNO, rn(_R26 - regno));
2815     }
2816 }
2817
2818 static void
2819 _epilog(jit_state_t *_jit, jit_node_t *node)
2820 {
2821     jit_int32_t         regno;
2822     jit_word_t          offset;
2823
2824     if (_jitc->function->assume_frame)
2825         return;
2826     /* Restore any modified callee save registers */
2827     offset = alloca_offset - 140;
2828     for (regno = 0; regno < jit_size(gr); regno++, offset += 4) {
2829         if (jit_regset_tstbit(&_jitc->function->regset, gr[regno]))
2830             ldxi(rn(gr[regno]), _FP_REGNO, offset);
2831     }
2832     for (regno = 0; regno < jit_size(fr); regno++, offset += 8) {
2833         if (jit_regset_tstbit(&_jitc->function->regset, fr[regno]))
2834             ldxi_d(rn(fr[regno]), _FP_REGNO, offset);
2835     }
2836
2837     /* Restore stack frame (FIXME Only required if non leaf) */
2838     LDWL(-20, _FP_REGNO, _RP_REGNO);
2839     LDO(_jitc->function->stack, _FP_REGNO, _SP_REGNO);
2840     LDWL_MB(-_jitc->function->stack, _SP_REGNO, _FP_REGNO);
2841 #if defined(__hpux)
2842     BVE_N(_RP_REGNO);
2843 #else
2844     BV_N(_R0_REGNO, _RP_REGNO);
2845 #endif
2846 }
2847
2848 static void
2849 _vastart(jit_state_t *_jit, jit_int32_t r0)
2850 {
2851     /* Initialize stack pointer to the first stack argument. */
2852     if (jit_arg_reg_p(_jitc->function->vagp))
2853         addi(r0, _FP_REGNO, params_offset - _jitc->function->vagp * 4);
2854     else
2855         addi(r0, _FP_REGNO, _jitc->function->self.size);
2856 }
2857
2858 static void
2859 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2860 {
2861     assert(_jitc->function->self.call & jit_call_varargs);
2862
2863     /* Update vararg stack pointer. */
2864     subi(r1, r1, 4);
2865
2866     /* Load argument. */
2867     ldr(r0, r1);
2868 }
2869
2870 static void
2871 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2872 {
2873     jit_word_t           w;
2874     union {
2875         jit_uint32_t    *i;
2876         jit_word_t       w;
2877     } u;
2878     u.w = instr;
2879     switch (u.i[0] >> 26) {
2880         case 0x8:                               /* LDIL */
2881             u.i[0] &= ~0x1fffff;
2882             u.i[0] |= re_assemble_21((label & ~0x7ff) >> 11);
2883             assert((u.i[1] >> 26) == 0xd);      /* LDO */
2884             u.i[1] &= ~0xffff;
2885             u.i[1] |= re_assemble_16(label & 0x7ff);
2886             break;
2887         case 0x20:      case 0x22:              /* CMPB */
2888         case 0x21:      case 0x23:              /* CMPIB */
2889         case 0x28:      case 0x2a:              /* ADDB */
2890         case 0x29:      case 0x2b:              /* ADDIB */
2891         case 0x31:                              /* BBI */
2892             w = ((label - instr) >> 2) - 2;
2893             assert(w >= -2048 && w <= 2047);
2894             u.i[0] &= ~0x1ffd;
2895             u.i[0] |= re_assemble_12(w);
2896             break;
2897         case 0x3a:                              /* B */
2898             w = ((label - instr) >> 2) - 2;
2899             assert(w >= -32768 && w <= 32767);
2900             u.i[0] &= ~0x1f1ffd;
2901             u.i[0] |= re_assemble_17(w);
2902             break;
2903         default:
2904             abort();
2905     }
2906 }
2907 #endif