deps/lightning/lib/jit_ppc-cpu.c

   1 /*
   2  * Copyright (C) 2012-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 #  if __WORDSIZE == 32
  22 #    define gpr_save_area               72      /* r14~r31 = 18 * 4 */
  23 #    if _CALL_SYSV
  24 #      define params_offset             (sizeof(jit_word_t) << 1)
  25 #    else
  26 #      define params_offset             24
  27 #    endif
  28 #    define can_sign_extend_int_p(im)   1
  29 #    define can_zero_extend_int_p(im)   1
  30 #    define fits_uint32_p(im)           1
  31 #  else
  32 #    define gpr_save_area               144     /* r14~r31 = 18 * 8 */
  33 #    if _CALL_ELF == 2
  34 #      define params_offset             32
  35 #    else
  36 #      define params_offset             48
  37 #    endif
  38 #    define can_sign_extend_int_p(im)                                   \
  39         (((im) >= 0 && (long)(im) <=  0x7fffffffL) ||                   \
  40          ((im) <  0 && (long)(im) >= -0x80000000L))
  41 #    define can_zero_extend_int_p(im)                                   \
  42         ((im) >= 0 && (im) < 0x80000000L)
  43 #    define fits_uint32_p(im)           ((im & 0xffffffff00000000L) == 0)
  44 #  endif
  45 #  define fpr_save_area                 64
  46 #  define alloca_offset                 -(gpr_save_area + fpr_save_area)
  47 #  define ii(i)                         *_jit->pc.ui++ = i
  48 #  if __WORDSIZE == 32
  49 #    define iw(i)                       *_jit->pc.ui++ = i
  50 #  else
  51 #    define iw(i)                       *_jit->pc.ul++ = i
  52 #  endif
  53 #  define can_sign_extend_short_p(im)   ((im) >= -32768 && (im) <= 32767)
  54 #  define can_zero_extend_short_p(im)   ((im) >= 0 && (im) <= 65535)
  55 #  define can_sign_extend_jump_p(im)    ((im) >= -33554432 && (im) <= 33554431)
  56 #  define _R0_REGNO                     0
  57 #  define _SP_REGNO                     1
  58 #  define _R2_REGNO                     2
  59 #  define _R11_REGNO                    11
  60 #  define _R12_REGNO                    12
  61 #  define _FP_REGNO                     31
  62 #  if __WORDSIZE == 32
  63 #    define ldr(r0,r1)                  ldr_i(r0,r1)
  64 #    define ldxi(r0,r1,i0)              ldxi_i(r0,r1,i0)
  65 #    define ldxr(r0,r1,r2)              ldxr_i(r0,r1,r2)
  66 #    define stxi(i0,r0,r1)              stxi_i(i0,r0,r1)
  67 #    define stxr(r0,r1,r2)              stxr_i(r0,r1,r2)
  68 #  else
  69 #    define ldr(r0,r1)                  ldr_l(r0,r1)
  70 #    define ldxi(r0,r1,i0)              ldxi_l(r0,r1,i0)
  71 #    define ldxr(r0,r1,r2)              ldxr_l(r0,r1,r2)
  72 #    define stxi(i0,r0,r1)              stxi_l(i0,r0,r1)
  73 #    define stxr(r0,r1,r2)              stxr_l(r0,r1,r2)
  74 #  endif
  75 #  define FXO(o,d,a,b,e,x)              _FXO(_jit,o,d,a,b,e,x,0)
  76 #  define FXO_(o,d,a,b,e,x)             _FXO(_jit,o,d,a,b,e,x,1)
  77 static void _FXO(jit_state_t*,int,int,int,int,int,int,int);
  78 #  define FDs(o,d,a,s)                  _FDs(_jit,o,d,a,s)
  79 static void _FDs(jit_state_t*,int,int,int,int);
  80 #  define FDu(o,d,a,s)                  _FDu(_jit,o,d,a,s)
  81 static void _FDu(jit_state_t*,int,int,int,int);
  82 #  define FX(o,d,a,b,x)                 _FX(_jit,o,d,a,b,x,0)
  83 #  define FX_(o,d,a,b,x)                _FX(_jit,o,d,a,b,x,1)
  84 static void _FX(jit_state_t*,int,int,int,int,int,int);
  85 #  define FI(o,t,a,k)                   _FI(_jit,o,t,a,k)
  86 static void _FI(jit_state_t*,int,int,int,int);
  87 #  define FB(o,bo,bi,t,a,k)             _FB(_jit,o,bo,bi,t,a,k)
  88 static void _FB(jit_state_t*,int,int,int,int,int,int);
  89 #  define FXL(o,bo,bi,x)                _FXL(_jit,o,bo,bi,x,0)
  90 #  define FXL_(o,bo,bi,x)               _FXL(_jit,o,bo,bi,x,1)
  91 static void _FXL(jit_state_t*,int,int,int,int,int);
  92 #  define FC(o,d,l,a,b,x)               _FC(_jit,o,d,l,a,b,x)
  93 static void _FC(jit_state_t*,int,int,int,int,int,int);
  94 #  define FCI(o,d,l,a,s)                _FCI(_jit,o,d,l,a,s)
  95 static void _FCI(jit_state_t*,int,int,int,int,int);
  96 #  define FXFX(o,s,x,f)                 _FXFX(_jit,o,s,x,f)
  97 static void _FXFX(jit_state_t*,int,int,int,int);
  98 #  define FM(o,s,a,h,b,e,r)             _FM(_jit,o,s,a,h,b,e,r)
  99 static void _FM(jit_state_t*,int,int,int,int,int,int,int);
 100 #  if __WORDSIZE == 64
 101 #    define FMDS(o,s,a,b,e,x)           _FMDS(_jit,o,s,a,b,e,x,0)
 102 #    define FMDS_(o,s,a,b,e,x)          _FMDS(_jit,o,s,a,b,e,x,1)
 103 static void _FMDS(jit_state_t*,int,int,int,int,int,int,int);
 104 #    define FMD(o,s,a,h,b,x,i)          _FMD(_jit,o,s,a,h,b,x,i,0)
 105 #    define FMD_(o,s,a,h,b,x,i)         _FMD(_jit,o,s,a,h,b,x,i,1)
 106 static void _FMD(jit_state_t*,int,int,int,int,int,int,int,int);
 107 #  define FXS(o,d,a,h,x,i)              _FXS(_jit,o,d,a,h,x,i,0)
 108 #  define FXS_(o,d,a,h,x,i)             _FXS(_jit,o,d,a,h,x,i,1)
 109 static void _FXS(jit_state_t*,int,int,int,int,int,int,int);
 110 #  endif
 111 #  define CR_0                          0
 112 #  define CR_1                          1
 113 #  define CR_2                          2
 114 #  define CR_3                          3
 115 #  define CR_4                          4
 116 #  define CR_5                          5
 117 #  define CR_6                          6
 118 #  define CR_7                          7
 119 #  define CR_LT                         0
 120 #  define CR_GT                         1
 121 #  define CR_EQ                         2
 122 #  define CR_SO                         3
 123 #  define CR_UN                         3
 124 #  define BCC_F                         4
 125 #  define BCC_T                         12
 126 #  define ADD(d,a,b)                    FXO(31,d,a,b,0,266)
 127 #  define ADD_(d,a,b)                   FXO_(31,d,a,b,0,266)
 128 #  define ADDO(d,a,b)                   FXO(31,d,a,b,1,266)
 129 #  define ADDO_(d,a,b)                  FXO_(31,d,a,b,1,266)
 130 #  define ADDC(d,a,b)                   FXO_(31,d,a,b,0,10)
 131 #  define ADDC_(d,a,b)                  FXO_(31,d,a,b,0,10)
 132 #  define ADDCO(d,a,b)                  FXO(31,d,a,b,1,10)
 133 #  define ADDCO_(d,a,b)                 FXO_(31,d,a,b,1,10)
 134 #  define ADDE(d,a,b)                   FXO(31,d,a,b,0,138)
 135 #  define ADDE_(d,a,b)                  FXO_(31,d,a,b,0,138)
 136 #  define ADDEO(d,a,b)                  FXO(31,d,a,b,1,138)
 137 #  define ADDEO_(d,a,b)                 FXO_(31,d,a,b,1,138)
 138 #  define ADDI(d,a,s)                   FDs(14,d,a,s)
 139 #  define ADDIC(d,a,s)                  FDs(12,d,a,s)
 140 #  define ADDIC_(d,a,s)                 FDs(13,d,a,s)
 141 #  define ADDIS(d,a,s)                  FDs(15,d,a,s)
 142 #  define LIS(d,s)                      ADDIS(d,0,s)
 143 #  define ADDME(d,a)                    FXO(31,d,a,0,0,234)
 144 #  define ADDME_(d,a)                   FXO_(31,d,a,0,0,234)
 145 #  define ADDMEO(d,a)                   FXO(31,d,a,0,1,234)
 146 #  define ADDMEO_(d,a)                  FXO_(31,d,a,0,1,234)
 147 #  define ADDZE(d,a)                    FXO(31,d,a,0,0,202)
 148 #  define ADDZE_(d,a)                   FXO_(31,d,a,0,0,202)
 149 #  define ADDZEO(d,a)                   FXO(31,d,a,0,1,202)
 150 #  define ADDZEO_(d,a)                  FXO_(31,d,a,0,1,202)
 151 #  define AND(d,a,b)                    FX(31,a,d,b,28)
 152 #  define ANDC(d,a,b)                   FXO(31,a,d,b,0,60)
 153 #  define ANDC_(d,a,b)                  FXO_(31,a,d,b,0,60)
 154 #  define AND_(d,a,b)                   FX_(31,a,b,d,28)
 155 #  define ANDI_(d,a,u)                  FDu(28,a,d,u)
 156 #  define ANDIS_(d,a,u)                 FDu(29,a,d,u)
 157 #  define B(t)                          FI(18,t,0,0)
 158 #  define BA(t)                         FI(18,t,1,0)
 159 #  define BL(t)                         FI(18,t,0,1)
 160 #  define BLA(t)                        FI(18,t,1,1)
 161 #  define BC(o,i,t)                     FB(16,o,i,t,0,0)
 162 #  define BCA(o,i,t)                    FB(16,o,i,t,1,0)
 163 #  define BCL(o,i,t)                    FB(16,o,i,t,0,1)
 164 #  define BCLA(o,i,t)                   FB(16,o,i,t,1,1)
 165 #  define BLT(t)                        BC(BCC_T,CR_LT,t)
 166 #  define BLE(t)                        BC(BCC_F,CR_GT,t)
 167 #  define BEQ(t)                        BC(BCC_T,CR_EQ,t)
 168 #  define BGE(t)                        BC(BCC_F,CR_LT,t)
 169 #  define BGT(t)                        BC(BCC_T,CR_GT,t)
 170 #  define BNE(t)                        BC(BCC_F,CR_EQ,t)
 171 #  define BUN(t)                        BC(BCC_T,CR_UN,t)
 172 #  define BNU(t)                        BC(BCC_F,CR_UN,t)
 173 #  define BCCTR(o,i)                    FXL(19,o,i,528)
 174 #  define BCCTRL(o,i)                   FXL_(19,o,i,528)
 175 #  define BLTCTR()                      BCCTR(BCC_T,CR_LT)
 176 #  define BLECTR()                      BCCTR(BCC_F,CR_GT)
 177 #  define BEQCTR()                      BCCTR(BCC_T,CR_EQ)
 178 #  define BGECTR()                      BCCTR(BCC_F,CR_LT)
 179 #  define BGTCTR()                      BCCTR(BCC_T,CR_GT)
 180 #  define BNECTR()                      BCCTR(BCC_F,CR_EQ)
 181 #  define BCTR()                        BCCTR(20,0)
 182 #  define BCTRL()                       BCCTRL(20,0)
 183 #  define BCLR(o,i)                     FXL(19,o,i,16)
 184 #  define BCLRL(o,i)                    FXL_(19,o,i,16)
 185 #  define BLTLR()                       BCLR(BCC_T,CR_LT)
 186 #  define BLELR()                       BCLR(BCC_F,CR_GT)
 187 #  define BEQLR()                       BCLR(BCC_T,CR_EQ)
 188 #  define BGELR()                       BCLR(BCC_F,CR_LT)
 189 #  define BGTLR()                       BCLR(BCC_T,CR_GT)
 190 #  define BNELR()                       BCLR(BCC_F,CR_EQ)
 191 #  define BLR()                         BCLR(20,0)
 192 #  define BLRL()                        BCLRL(20,0)
 193 #  define XCMP(cr,l,a,b)                FC(31,cr,l,a,b,0)
 194 #  define CMPD(a,b)                     XCMP(0,1,a,b)
 195 #  define CMPW(a,b)                     XCMP(0,0,a,b)
 196 #  define XCMPI(cr,l,a,s)               FCI(11,cr,l,a,s)
 197 #  define CMPDI(a,s)                    XCMPI(0,1,a,s)
 198 #  define CMPWI(a,s)                    XCMPI(0,0,a,s)
 199 #  define XCMPL(cr,l,a,b)               FC(31,cr,l,a,b,32)
 200 #  define CMPLD(a,b)                    XCMPL(0,1,a,b)
 201 #  define CMPLW(a,b)                    XCMPL(0,0,a,b)
 202 #  define XCMPLI(cr,l,a,u)              FCI(10,cr,l,a,u)
 203 #  define CMPLDI(a,s)                   XCMPLI(0,1,a,s)
 204 #  define CMPLWI(a,s)                   XCMPLI(0,0,a,s)
 205 #  if __WORDSIZE == 32
 206 #  define CMPX(a,b)                     CMPW(a,b)
 207 #  define CMPXI(a,s)                    CMPWI(a,s)
 208 #  define CMPLX(a,b)                    CMPLW(a,b)
 209 #  define CMPLXI(a,s)                   CMPLWI(a,s)
 210 #  else
 211 #  define CMPX(a,b)                     CMPD(a,b)
 212 #  define CMPXI(a,s)                    CMPDI(a,s)
 213 #  define CMPLX(a,b)                    CMPLD(a,b)
 214 #  define CMPLXI(a,s)                   CMPLDI(a,s)
 215 #  endif
 216 #  define CNTLZW(a,s)                   FX(31,s,a,0,26)
 217 #  define CNTLZW_(a,s)                  FX_(31,s,a,0,26)
 218 #  define CNTLZD(a,s)                   FX(31,s,a,0,58)
 219 #  define CNTLZD_(a,s)                  FX_(31,s,a,0,58)
 220 #  define CRAND(d,a,b)                  FX(19,d,a,b,257)
 221 #  define CRANDC(d,a,b)                 FX(19,d,a,b,129)
 222 #  define CREQV(d,a,b)                  FX(19,d,a,b,289)
 223 #  define CRSET(d)                      CREQV(d,d,d)
 224 #  define CRNAND(d,a,b)                 FX(19,d,a,b,225)
 225 #  define CRNOR(d,a,b)                  FX(19,d,a,b,33)
 226 #  define CRNOT(d,a)                    CRNOR(d,a,a)
 227 #  define CROR(d,a,b)                   FX(19,d,a,b,449)
 228 #  define CRMOVE(d,a)                   CROR(d,a,a)
 229 #  define CRORC(d,a,b)                  FX(19,d,a,b,417)
 230 #  define CRXOR(d,a,b)                  FX(19,d,a,b,193)
 231 #  define CRCLR(d)                      CRXOR(d,d,d)
 232 #  define DCBA(a,b)                     FX(31,0,a,b,758)
 233 #  define DCBF(a,b)                     FX(31,0,a,b,86)
 234 #  define DCBI(a,b)                     FX(31,0,a,b,470)
 235 #  define DCBST(a,b)                    FX(31,0,a,b,54)
 236 #  define DCBT(a,b)                     FX(31,0,a,b,278)
 237 #  define DCBTST(a,b)                   FX(31,0,a,b,246)
 238 #  define DCBZ(a,b)                     FX(31,0,a,b,1014)
 239 #  define DIVW(d,a,b)                   FXO(31,d,a,b,0,491)
 240 #  define DIVW_(d,a,b)                  FXO_(31,d,a,b,0,491)
 241 #  define DIVWO(d,a,b)                  FXO(31,d,a,b,1,491)
 242 #  define DIVWO_(d,a,b)                 FXO_(31,d,a,b,1,491)
 243 #  define DIVWU(d,a,b)                  FXO(31,d,a,b,0,459)
 244 #  define DIVWU_(d,a,b)                 FXO_(31,d,a,b,0,459)
 245 #  define DIVWUO(d,a,b)                 FXO(31,d,a,b,1,459)
 246 #  define DIVWUO_(d,a,b)                FXO_(31,d,a,b,1,459)
 247 #  define DIVD(d,a,b)                   FXO(31,d,a,b,0,489)
 248 #  define DIVD_(d,a,b)                  FXO_(31,d,a,b,0,489)
 249 #  define DIVDO(d,a,b)                  FXO(31,d,a,b,1,489)
 250 #  define DIVDO_(d,a,b)                 FXO_(31,d,a,b,1,489)
 251 #  define DIVDU(d,a,b)                  FXO(31,d,a,b,0,457)
 252 #  define DIVDU_(d,a,b)                 FXO_(31,d,a,b,0,457)
 253 #  define DIVDUO(d,a,b)                 FXO(31,d,a,b,1,457)
 254 #  define DIVDUO_(d,a,b)                FXO_(31,d,a,b,1,457)
 255 #  define ECIWX(d,a,b)                  FX(31,d,a,b,310)
 256 #  define ECOWX(s,a,b)                  FX(31,s,a,b,438)
 257 #  define EIEIO()                       FX(31,0,0,0,854)
 258 #  define EQV(d,a,b)                    FX(31,a,d,b,284)
 259 #  define EQV_(d,a,b)                   FX_(31,a,d,b,284)
 260 #  define EXTSB(d,a)                    FX(31,a,d,0,954)
 261 #  define EXTSB_(d,a)                   FX_(31,a,d,0,954)
 262 #  define EXTSH(d,a)                    FX(31,a,d,0,922)
 263 #  define EXTSH_(d,a)                   FX_(31,a,d,0,922)
 264 #  define EXTSW(d,a)                    FX(31,a,d,0,986)
 265 #  define EXTSW_(d,a)                   FX_(31,a,d,0,986)
 266 #  define ICIB(a,b)                     FX(31,0,a,b,982)
 267 #  define ISYNC()                       FXL(19,0,0,150)
 268 #  define LBZ(d,a,s)                    FDs(34,d,a,s)
 269 #  define LBZU(d,a,s)                   FDs(35,d,a,s)
 270 #  define LBZUX(d,a,b)                  FX(31,d,a,b,119)
 271 #  define LBZX(d,a,b)                   FX(31,d,a,b,87)
 272 #  define LHA(d,a,s)                    FDs(42,d,a,s)
 273 #  define LHAU(d,a,s)                   FDs(43,d,a,s)
 274 #  define LHAUX(d,a,b)                  FX(31,d,a,b,375)
 275 #  define LHAX(d,a,b)                   FX(31,d,a,b,343)
 276 #  define LHBRX(d,a,b)                  FX(31,d,a,b,790)
 277 #  define LHZ(d,a,s)                    FDs(40,d,a,s)
 278 #  define LHZU(d,a,s)                   FDs(41,d,a,s)
 279 #  define LHZUX(d,a,b)                  FX(31,d,a,b,311)
 280 #  define LHZX(d,a,b)                   FX(31,d,a,b,279)
 281 #  define LA(d,a,s)                     ADDI(d,a,s)
 282 #  define LI(d,s)                       ADDI(d,0,s)
 283 #  define LMW(d,a,s)                    FDs(46,d,a,s)
 284 #  define LSWI(d,a,n)                   FX(31,d,a,n,597)
 285 #  define LSWX(d,a,b)                   FX(31,d,a,b,533)
 286 #  define LWARX(d,a,b)                  FX(31,d,a,b,20)
 287 #  define LDARX(d,a,b)                  FX(31,d,a,b,84)
 288 #  define LWBRX(d,a,b)                  FX(31,d,a,b,534)
 289 #  define LWA(d,a,s)                    FDs(58,d,a,s|2)
 290 #  define LWAUX(d,a,b)                  FX(31,d,a,b,373)
 291 #  define LWAX(d,a,b)                   FX(31,d,a,b,341)
 292 #  define LWZ(d,a,s)                    FDs(32,d,a,s)
 293 #  define LWZU(d,a,s)                   FDs(33,d,a,s)
 294 #  define LWZUX(d,a,b)                  FX(31,d,a,b,55)
 295 #  define LWZX(d,a,b)                   FX(31,d,a,b,23)
 296 #  define LD(d,a,s)                     FDs(58,d,a,s)
 297 #  define LDX(d,a,b)                    FX(31,d,a,b,21)
 298 #  define MCRF(d,s)                     FXL(19,d<<2,(s)<<2,0)
 299 #  if DEBUG
 300 /* In case instruction is emulated, check the kernel can handle it.
 301    Will only generate it if DEBUG is enabled.
 302 """
 303 Chapter 6. Optional Facilities and Instructions that are being
 304 Phased Out of the Architecture
 305 ...
 306 6.1 Move To Condition Register from XER
 307 The mcrxr instruction is being phased out of the archi-
 308 tecture. Its description is included here as an aid to
 309 constructing operating system code to emulate it.
 310
 311 Move to Condition Register from XER
 312 X-form
 313 mcrxr BF
 314 31      BF      //      ///     ///     512     /
 315 0       6       9       11      16      21      31
 316 CR(4xBF:4xBF+3) <- XER(32:35)
 317 XER(32:35) <- 0b0000
 318 The contents of XER(32:35) are copied to Condition Reg-
 319 ister field BF. XER(32:35) are set to zero.
 320 Special Registers Altered:
 321 CR field BF XER(32:35)
 322
 323 Programming Note
 324 Warning: This instruction has been phased out of
 325 the architecture. Attempting to execute this
 326 instruction will cause the system illegal instruction
 327 error handler to be invoked
 328 """
 329  */
 330 #    define MCRXR(d)                    FX(31,d<<2,0,0,512)
 331 #  else
 332 #    define MCRXR(cr)                   _MCRXR(_jit,cr);
 333 static void _MCRXR(jit_state_t*, jit_int32_t);
 334 #  endif
 335 #  define MFCR(d)                       FX(31,d,0,0,19)
 336 #  define MFMSR(d)                      FX(31,d,0,0,83)
 337 #  define MFSPR(d,s)                    FXFX(31,d,s<<5,339)
 338 #  define MFXER(d)                      MFSPR(d,1)
 339 #  define MFLR(d)                       MFSPR(d,8)
 340 #  define MFCTR(d)                      MFSPR(d,9)
 341 #  define MFSR(d,s)                     FX(31,d,s,0,595)
 342 #  define MFSRIN(d,b)                   FX(31,d,0,b,659)
 343 #  define MFTB(d,x,y)                   FXFX(31,d,(x)|((y)<<5),371)
 344 #  define MFTBL(d)                      MFTB(d,8,12)
 345 #  define MFTBU(d)                      MFTB(d,8,13)
 346 #  define MTCRF(c,s)                    FXFX(31,s,c<<1,144)
 347 #  define MTCR(s)                       MTCRF(0xff,s)
 348 #  define MTMSR(s)                      FX(31,s,0,0,146)
 349 #  define MTSPR(d,s)                    FXFX(31,d,s<<5,467)
 350 #  define MTXER(d)                      MTSPR(d,1)
 351 #  define MTLR(d)                       MTSPR(d,8)
 352 #  define MTCTR(d)                      MTSPR(d,9)
 353 #  define MTSR(r,s)                     FX(31,s<<1,r,0,210)
 354 #  define MTSRIN(r,b)                   FX(31,r<<1,0,b,242)
 355 #  define MULLI(d,a,s)                  FDs(07,d,a,s)
 356 #  define MULHW(d,a,b)                  FXO(31,d,a,b,0,75)
 357 #  define MULHW_(d,a,b)                 FXO_(31,d,a,b,0,75)
 358 #  define MULHWU(d,a,b)                 FXO(31,d,a,b,0,11)
 359 #  define MULHWU_(d,a,b)                FXO_(31,d,a,b,0,11)
 360 #  define MULLW(d,a,b)                  FXO(31,d,a,b,0,235)
 361 #  define MULLW_(d,a,b)                 FXO_(31,d,a,b,0,235)
 362 #  define MULLWO(d,a,b)                 FXO(31,d,a,b,1,235)
 363 #  define MULLWO_(d,a,b)                FXO_(31,d,a,b,1,235)
 364 #  define MULHD(d,a,b)                  FXO(31,d,a,b,0,73)
 365 #  define MULHD_(d,a,b)                 FXO_(31,d,a,b,0,73)
 366 #  define MULHDU(d,a,b)                 FXO(31,d,a,b,0,9)
 367 #  define MULHDU_(d,a,b)                FXO_(31,d,a,b,0,9)
 368 #  define MULLD(d,a,b)                  FXO(31,d,a,b,0,233)
 369 #  define MULLD_(d,a,b)                 FXO_(31,d,a,b,0,233)
 370 #  define MULLDO(d,a,b)                 FXO(31,d,a,b,1,233)
 371 #  define MULLDO_(d,a,b)                FXO_(31,d,a,b,1,233)
 372 #  define NAND(d,a,b)                   FX(31,a,d,b,476)
 373 #  define NAND_(d,a,b)                  FX_(31,a,d,b,476)
 374 #  define NEG(d,a)                      FXO(31,d,a,0,0,104)
 375 #  define NEG_(d,a)                     FXO_(31,d,a,0,0,104)
 376 #  define NEGO(d,a)                     FXO(31,d,a,0,1,104)
 377 #  define NEGO_(d,a)                    FXO_(31,d,a,0,1,104)
 378 #  define NOR(d,a,b)                    FX(31,a,d,b,124)
 379 #  define NOR_(d,a,b)                   FX_(31,a,d,b,124)
 380 #  define NOT(d,s)                      NOR(d,s,s)
 381 #  define OR(d,a,b)                     FX(31,a,d,b,444)
 382 #  define OR_(d,a,b)                    FX_(31,a,d,b,444)
 383 #  define MR(d,a)                       OR(d,a,a)
 384 #  define ORC(d,a,b)                    FX(31,a,d,b,412)
 385 #  define ORC_(d,a,b)                   FX_(31,a,d,b,412)
 386 #  define ORI(d,a,u)                    FDu(24,a,d,u)
 387 #  define NOP()                         ORI(0,0,0)
 388 #  define ORIS(d,a,u)                   FDu(25,a,d,u)
 389 #  define RFI()                         FXL(19,0,0,50)
 390 #  define RLWIMI(d,s,h,b,e)             FM(20,s,d,h,b,e,0)
 391 #  define RLWIMI_(d,s,h,b,e)            FM(20,s,d,h,b,e,1)
 392 #  define INSLWI(a,s,n,b)               RLWIMI(a,s,32-b,b,b+n-1)
 393 #  define INSRWI(a,s,n,b)               RLWIMI(a,s,32-(b+n),b,(b+n)-1)
 394 #  define RLWINM(a,s,h,b,e)             FM(21,s,a,h,b,e,0)
 395 #  define RLWINM_(a,s,h,b,e)            FM(21,s,a,h,b,e,1)
 396 #  define EXTLWI(a,s,n,b)               RLWINM(a,s,b,0,n-1)
 397 #  define EXTRWI(a,s,n,b)               RLWINM(a,s,b+n,32-n,31)
 398 #  define ROTLWI(a,s,n)                 RLWINM(a,s,n,0,31)
 399 #  define ROTRWI(a,s,n)                 RLWINM(a,s,32-n,0,31)
 400 #  define SLWI(a,s,n)                   RLWINM(a,s,n,0,31-n)
 401 #  define SRWI(a,s,n)                   RLWINM(a,s,32-n,n,31)
 402 #  define CLRLWI(a,s,n)                 RLWINM(a,s,0,n,31)
 403 #  define CLRRWI(a,s,n)                 RLWINM(a,s,0,0,31-n)
 404 #  define CLRLSWI(a,s,b,n)              RLWINM(a,s,n,b-n,31-n)
 405 #  define RLWNM(a,s,b,m,e)              FM(23,s,a,b,m,e,0)
 406 #  define RLWNM_(a,s,b,m,e)             FM(23,s,a,b,m,e,1)
 407 #  define ROTLW(a,s,b)                  RLWNM(a,s,b,0,31)
 408 #  define SC()                          FDu(17,0,0,2)
 409 #  define SLW(a,s,b)                    FX(31,s,a,b,24)
 410 #  define SLW_(a,s,b)                   FX_(31,s,a,b,24)
 411 #  define SRAW(a,s,b)                   FX(31,s,a,b,792)
 412 #  define SRAW_(a,s,b)                  FX_(31,s,a,b,792)
 413 #  define SRAWI(a,s,h)                  FX(31,s,a,h,824)
 414 #  define SRAWI_(a,s,h)                 FX_(31,s,a,h,824)
 415 #  define SRW(a,s,b)                    FX(31,s,a,b,536)
 416 #  define SRW_(a,s,b)                   FX_(31,s,a,b,536)
 417 #  if __WORDSIZE == 64
 418 #    define RLDICL(a,s,h,b)             FMD(30,s,a,h&~32,b,0,h>>5)
 419 #    define RLDICL_(a,s,h,b)            FMD_(30,s,a,h&~32,b,0,h>>5)
 420 #    define EXTRDI(x,y,n,b)             RLDICL(x,y,(b+n),(64-n))
 421 #    define SRDI(x,y,n)                 RLDICL(x,y,(64-n),n)
 422 #    define CLRLDI(x,y,n)               RLDICL(x,y,0,n)
 423 #    define RLDICR(a,s,h,e)             FMD(30,s,a,h&~32,e,1,h>>5)
 424 #    define RLDICR_(a,s,h,e)            FMD_(30,s,a,h&~32,e,1,h>>5)
 425 #    define EXTRLI(x,y,n,b)             RLDICR(x,y,b,(n-1))
 426 #    define SLDI(x,y,n)                 RLDICR(x,y,n,(63-n))
 427 #    define CLRRDI(x,y,n)               RLDICR(x,y,0,(63-n))
 428 #    define RLDIC(a,s,h,b)              FMD(30,s,a,h&~32,b,2,h>>5)
 429 #    define RLDIC_(a,s,h,b)             FMD_(30,s,a,h&~32,b,2,h>>5)
 430 #    define CLRLSLDI(x,y,b,n)           RLDIC(x,y,n,(b-n))
 431 #    define RLDCL(a,s,h,b)              FMDS(30,s,a,h,b,8)
 432 #    define RLDCL_(a,s,h,b)             FMDS_(30,s,a,h,b,8)
 433 #    define ROTLD(x,y,z)                RLDCL(x,y,z,0)
 434 #    define RLDCR(a,s,b,e)              FMDS(30,s,a,b,e,0)
 435 #    define RLDCR_(a,s,b,e)             FMDS_(30,s,a,b,e,0)
 436 #    define RLDIMI(a,s,h,b)             FMD(30,s,a,h&~32,b,3,h>>5)
 437 #    define RLDIMI_(a,s,h,b)            FMD_(30,s,a,h&~32,b,3,h>>5)
 438 #    define INSRDI(x,y,n,b)             RLDIMI(x,y,(64-(b+n)),b)
 439 #    define SLD(a,s,b)                  FX(31,s,a,b,27)
 440 #    define SLD_(a,s,b)                 FX_(31,s,a,b,27)
 441 #    define SRD(a,s,b)                  FX(31,s,a,b,539)
 442 #    define SRD_(a,s,b)                 FX_(31,s,a,b,539)
 443 #    define SRADI(a,s,h)                FXS(31,s,a,h&~32,413,h>>5)
 444 #    define SRADI_(a,s,h)               FXS_(31,s,a,h&~32,413,h>>5)
 445 #    define SRAD(a,s,b)                 FX(31,s,a,b,794)
 446 #    define SRAD_(a,s,b)                FX_(31,s,a,b,794)
 447 #  endif
 448 #  define STB(s,a,d)                    FDs(38,s,a,d)
 449 #  define STBU(s,a,d)                   FDs(39,s,a,d)
 450 #  define STBUX(s,a,b)                  FX(31,s,a,b,247)
 451 #  define STBX(s,a,b)                   FX(31,s,a,b,215)
 452 #  define STH(s,a,d)                    FDs(44,s,a,d)
 453 #  define STHBRX(s,a,b)                 FX(31,s,a,b,918)
 454 #  define STHU(s,a,d)                   FDs(45,s,a,d)
 455 #  define STHUX(s,a,b)                  FX(31,s,a,b,439)
 456 #  define STHX(s,a,b)                   FX(31,s,a,b,407)
 457 #  define STMW(s,a,d)                   FDs(47,s,a,d)
 458 #  define STWSI(s,a,nb)                 FX(31,s,a,nb,725)
 459 #  define STSWX(s,a,b)                  FX(31,s,a,b,661)
 460 #  define STW(s,a,d)                    FDs(36,s,a,d)
 461 #  define STWBRX(s,a,b)                 FX(31,s,a,b,662)
 462 #  define STWCX_(s,a,b)                 FX_(31,s,a,b,150)
 463 #  define STDCX_(s,a,b)                 FX_(31,s,a,b,214)
 464 #  define STWU(s,a,d)                   FDs(37,s,a,d)
 465 #  define STWUX(s,a,b)                  FX(31,s,a,b,183)
 466 #  define STWX(s,a,b)                   FX(31,s,a,b,151)
 467 #  define STD(s,a,d)                    FDs(62,s,a,d)
 468 #  define STDX(s,a,b)                   FX(31,s,a,b,149)
 469 #  define STDU(s,a,d)                   FDs(62,s,a,d|1)
 470 #  define STDUX(s,a,b)                  FX(31,s,a,b,181)
 471 #  define SUBF(d,a,b)                   FXO(31,d,a,b,0,40)
 472 #  define SUBF_(d,a,b)                  FXO_(31,d,a,b,0,40)
 473 #  define SUBFO(d,a,b)                  FXO(31,d,a,b,1,40)
 474 #  define SUBFO_(d,a,b)                 FXO_(31,d,a,b,1,40)
 475 #  define SUB(d,a,b)                    SUBF(d,b,a)
 476 #  define SUB_(d,a,b)                   SUBF_(d,b,a)
 477 #  define SUBO(d,a,b)                   SUBFO(d,b,a)
 478 #  define SUBO_(d,a,b)                  SUBFO_(d,b,a)
 479 #  define SUBI(d,a,s)                   ADDI(d,a,-s)
 480 #  define SUBIS(d,a,s)                  ADDIS(d,a,-s)
 481 #  define SUBFC(d,a,b)                  FXO(31,d,a,b,0,8)
 482 #  define SUBFC_(d,a,b)                 FXO_(31,d,a,b,0,8)
 483 #  define SUBFCO(d,a,b)                 FXO(31,d,a,b,1,8)
 484 #  define SUBFCO_(d,a,b)                FXO_(31,d,a,b,1,8)
 485 #  define SUBC(d,a,b)                   SUBFC(d,b,a)
 486 #  define SUBIC(d,a,s)                  ADDIC(d,a,-s)
 487 #  define SUBIC_(d,a,s)                 ADDIC_(d,a,-s)
 488 #  define SUBFE(d,a,b)                  FXO(31,d,a,b,0,136)
 489 #  define SUBFE_(d,a,b)                 FXO_(31,d,a,b,0,136)
 490 #  define SUBFEO(d,a,b)                 FXO(31,d,a,b,1,136)
 491 #  define SUBFEO_(d,a,b)                FXO_(31,d,a,b,1,136)
 492 #  define SUBE(d,a,b)                   SUBFE(d,b,a)
 493 #  define SUBFIC(d,a,s)                 FDs(8,d,a,s)
 494 #  define SUBFME(d,a)                   FXO(31,d,a,0,0,232)
 495 #  define SUBFME_(d,a)                  FXO_(31,d,a,0,0,232)
 496 #  define SUBFMEO(d,a)                  FXO(31,d,a,0,1,232)
 497 #  define SUBFMEO_(d,a)                 FXO_(31,d,a,0,1,232)
 498 #  define SUBFZE(d,a)                   FXO(31,d,a,0,0,200)
 499 #  define SUBFZE_(d,a)                  FXO_(31,d,a,0,0,200)
 500 #  define SUBFZEO(d,a)                  FXO(31,d,a,0,1,200)
 501 #  define SUBFZEO_(d,a)                 FXO_(31,d,a,0,1,200)
 502 #  define SYNC()                        FX(31,0,0,0,598)
 503 #  define TLBIA()                       FX(31,0,0,0,370)
 504 #  define TLBIE(b)                      FX(31,0,0,b,306)
 505 #  define TLBSYNC()                     FX(31,0,0,0,566)
 506 #  define TW(t,a,b)                     FX(31,t,a,b,4)
 507 #  define TWEQ(a,b)                     FX(31,4,a,b,4)
 508 #  define TWLGE(a,b)                    FX(31,5,a,b,4)
 509 #  define TRAP()                        FX(31,31,0,0,4)
 510 #  define TWI(t,a,s)                    FDs(3,t,a,s)
 511 #  define TWGTI(a,s)                    TWI(8,a,s)
 512 #  define TWLLEI(a,s)                   TWI(6,a,s)
 513 #  define XOR(d,a,b)                    FX(31,a,d,b,316)
 514 #  define XOR_(d,a,b)                   FX_(31,a,d,b,316)
 515 #  define XORI(s,a,u)                   FDu(26,a,s,u)
 516 #  define XORIS(s,a,u)                  FDu(27,a,s,u)
 517 #  define nop(c)                        _nop(_jit,c)
 518 static void _nop(jit_state_t*,jit_int32_t);
 519 #  define movr(r0,r1)                   _movr(_jit,r0,r1)
 520 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
 521 #  define movi(r0,i0)                   _movi(_jit,r0,i0)
 522 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
 523 #  define movnr(r0,r1,r2)               _movnr(_jit,r0,r1,r2)
 524 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 525 #  define movzr(r0,r1,r2)               _movzr(_jit,r0,r1,r2)
 526 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 527 #  define movi_p(r0,i0)                 _movi_p(_jit,r0,i0)
 528 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 529 #  define casx(r0, r1, r2, r3, i0)      _casx(_jit, r0, r1, r2, r3, i0)
 530 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 531                   jit_int32_t,jit_int32_t,jit_word_t);
 532 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 533 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 534 #  define negr(r0,r1)                   NEG(r0,r1)
 535 #  define comr(r0,r1)                   NOT(r0,r1)
 536 #  define bitswap(r0, r1)               _bitswap(_jit, r0, r1)
 537 static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t);
 538 #  define clor(r0, r1)                  _clor(_jit, r0, r1)
 539 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
 540 #  if __WORDSIZE == 32
 541 #    define clzr(r0, r1)                CNTLZW(r0, r1)
 542 #  else
 543 #    define clzr(r0, r1)                CNTLZD(r0, r1)
 544 #  endif
 545 #  define ctor(r0, r1)                  _ctor(_jit, r0, r1)
 546 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
 547 #  define ctzr(r0, r1)                  _ctzr(_jit, r0, r1)
 548 static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
 549 #  define extr_c(r0,r1)                 EXTSB(r0,r1)
 550 #  define extr_uc(r0,r1)                ANDI_(r0,r1,0xff)
 551 #  define extr_s(r0,r1)                 EXTSH(r0,r1)
 552 #  define extr_us(r0,r1)                ANDI_(r0,r1,0xffff)
 553 #  if __WORDSIZE == 64
 554 #    define extr_i(r0,r1)               EXTSW(r0,r1)
 555 #    define extr_ui(r0,r1)              CLRLDI(r0,r1,32)
 556 #  endif
 557 #  define bswapr_us_lh(r0,r1,no_flag)   _bswapr_us(_jit,r0,r1,no_flag)
 558 #  define bswapr_us(r0,r1)              _bswapr_us(_jit,r0,r1,0)
 559 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
 560 #  define bswapr_ui_lw(r0,r1,no_flag)   _bswapr_ui(_jit,r0,r1,no_flag)
 561 #  define bswapr_ui(r0,r1)              _bswapr_ui(_jit,r0,r1,0)
 562 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
 563 #  if __WORDSIZE == 64
 564 #    define bswapr_ul(r0,r1)            generic_bswapr_ul(_jit,r0,r1)
 565 #  endif
 566 #  define addr(r0,r1,r2)                ADD(r0,r1,r2)
 567 #  define addi(r0,r1,i0)                _addi(_jit,r0,r1,i0)
 568 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 569 #  define addcr(r0,r1,r2)               ADDC(r0,r1,r2)
 570 #  define addci(r0,r1,i0)               _addci(_jit,r0,r1,i0)
 571 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 572 #  define addxr(r0,r1,r2)               ADDE(r0,r1,r2)
 573 #  define addxi(r0,r1,i0)               _addxi(_jit,r0,r1,i0)
 574 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 575 #  define subr(r0,r1,r2)                SUB(r0,r1,r2)
 576 #  define subi(r0,r1,i0)                _subi(_jit,r0,r1,i0)
 577 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 578 #  define subcr(r0,r1,r2)               SUBC(r0,r1,r2)
 579 #  define subci(r0,r1,i0)               _subci(_jit,r0,r1,i0)
 580 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 581 #  define subxr(r0,r1,r2)               SUBFE(r0,r2,r1)
 582 #  define subxi(r0,r1,i0)               _subxi(_jit,r0,r1,i0)
 583 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 584 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
 585 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 586 #  if __WORDSIZE == 32
 587 #    define mulr(r0,r1,r2)              MULLW(r0,r1,r2)
 588 #    define mullr(r0,r1,r2)             MULLW(r0,r1,r2)
 589 #    define mulhr(r0,r1,r2)             MULHW(r0,r1,r2)
 590 #    define mulhr_u(r0,r1,r2)           MULHWU(r0,r1,r2)
 591 #  else
 592 #    define mulr(r0,r1,r2)              MULLD(r0,r1,r2)
 593 #    define mullr(r0,r1,r2)             MULLD(r0,r1,r2)
 594 #    define mulhr(r0,r1,r2)             MULHD(r0,r1,r2)
 595 #    define mulhr_u(r0,r1,r2)           MULHDU(r0,r1,r2)
 596 #  endif
 597 #  define muli(r0,r1,i0)                _muli(_jit,r0,r1,i0)
 598 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 599 #  define qmulr(r0,r1,r2,r3)            iqmulr(r0,r1,r2,r3,1)
 600 #  define qmulr_u(r0,r1,r2,r3)          iqmulr(r0,r1,r2,r3,0)
 601 #  define iqmulr(r0,r1,r2,r3,cc)        _iqmulr(_jit,r0,r1,r2,r3,cc)
 602 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
 603                     jit_int32_t,jit_int32_t,jit_bool_t);
 604 #  define qmuli(r0,r1,r2,i0)            iqmuli(r0,r1,r2,i0,1)
 605 #  define qmuli_u(r0,r1,r2,i0)          iqmuli(r0,r1,r2,i0,0)
 606 #  define iqmuli(r0,r1,r2,i0,cc)        _iqmuli(_jit,r0,r1,r2,i0,cc)
 607 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
 608                     jit_int32_t,jit_word_t,jit_bool_t);
 609 #  if __WORDSIZE == 32
 610 #    define divr(r0,r1,r2)              DIVW(r0,r1,r2)
 611 #  else
 612 #    define divr(r0,r1,r2)              DIVD(r0,r1,r2)
 613 #  endif
 614 #  define divi(r0,r1,i0)                _divi(_jit,r0,r1,i0)
 615 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 616 #  if __WORDSIZE == 32
 617 #    define divr_u(r0,r1,r2)            DIVWU(r0,r1,r2)
 618 #  else
 619 #    define divr_u(r0,r1,r2)            DIVDU(r0,r1,r2)
 620 #  endif
 621 #  define divi_u(r0,r1,i0)              _divi_u(_jit,r0,r1,i0)
 622 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 623 #  define qdivr(r0,r1,r2,r3)            iqdivr(r0,r1,r2,r3,1)
 624 #  define qdivr_u(r0,r1,r2,r3)          iqdivr(r0,r1,r2,r3,0)
 625 #  define iqdivr(r0,r1,r2,r3,cc)        _iqdivr(_jit,r0,r1,r2,r3,cc)
 626 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
 627                     jit_int32_t,jit_int32_t,jit_bool_t);
 628 #  define qdivi(r0,r1,r2,i0)            iqdivi(r0,r1,r2,i0,1)
 629 #  define qdivi_u(r0,r1,r2,i0)          iqdivi(r0,r1,r2,i0,0)
 630 #  define iqdivi(r0,r1,r2,i0,cc)        _iqdivi(_jit,r0,r1,r2,i0,cc)
 631 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
 632                     jit_int32_t,jit_word_t,jit_bool_t);
 633 #  define remr(r0,r1,r2)                _remr(_jit,r0,r1,r2)
 634 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 635 #  define remi(r0,r1,i0)                _remi(_jit,r0,r1,i0)
 636 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 637 #  define remr_u(r0,r1,r2)              _remr_u(_jit,r0,r1,r2)
 638 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 639 #  define remi_u(r0,r1,i0)              _remi_u(_jit,r0,r1,i0)
 640 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 641 #  define andr(r0,r1,r2)                AND(r0,r1,r2)
 642 #  define andi(r0,r1,i0)                _andi(_jit,r0,r1,i0)
 643 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 644 #  define orr(r0,r1,r2)                 OR(r0,r1,r2)
 645 #  define ori(r0,r1,i0)                 _ori(_jit,r0,r1,i0)
 646 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 647 #  define xorr(r0,r1,r2)                XOR(r0,r1,r2)
 648 #  define xori(r0,r1,i0)                _xori(_jit,r0,r1,i0)
 649 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 650 #  if __WORDSIZE == 32
 651 #    define lshr(r0,r1,r2)              SLW(r0,r1,r2)
 652 #  else
 653 #    define lshr(r0,r1,r2)              SLD(r0,r1,r2)
 654 #  endif
 655 #  define lshi(r0,r1,i0)                _lshi(_jit,r0,r1,i0)
 656 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 657 #  if __WORDSIZE == 32
 658 #    define rshr(r0,r1,r2)              SRAW(r0,r1,r2)
 659 #  else
 660 #    define rshr(r0,r1,r2)              SRAD(r0,r1,r2)
 661 #  endif
 662 #  define rshi(r0,r1,i0)                _rshi(_jit,r0,r1,i0)
 663 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 664 #  if __WORDSIZE == 32
 665 #    define rshr_u(r0,r1,r2)            SRW(r0,r1,r2)
 666 #  else
 667 #    define rshr_u(r0,r1,r2)            SRD(r0,r1,r2)
 668 #  endif
 669 #  define rshi_u(r0,r1,i0)              _rshi_u(_jit,r0,r1,i0)
 670 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 671 #  define ltr(r0,r1,r2)                 _ltr(_jit,r0,r1,r2)
 672 static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 673 #  define lti(r0,r1,i0)                 _lti(_jit,r0,r1,i0)
 674 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 675 #  define ltr_u(r0,r1,r2)               _ltr_u(_jit,r0,r1,r2)
 676 static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 677 #  define lti_u(r0,r1,i0)               _lti_u(_jit,r0,r1,i0)
 678 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 679 #  define ler(r0,r1,r2)                 _ler(_jit,r0,r1,r2)
 680 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 681 #  define lei(r0,r1,i0)                 _lei(_jit,r0,r1,i0)
 682 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 683 #  define ler_u(r0,r1,r2)               _ler_u(_jit,r0,r1,r2)
 684 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 685 #  define lei_u(r0,r1,i0)               _lei_u(_jit,r0,r1,i0)
 686 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 687 #  define eqr(r0,r1,r2)                 _eqr(_jit,r0,r1,r2)
 688 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 689 #  define eqi(r0,r1,i0)                 _eqi(_jit,r0,r1,i0)
 690 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 691 #  define ger(r0,r1,r2)                 _ger(_jit,r0,r1,r2)
 692 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 693 #  define gei(r0,r1,i0)                 _gei(_jit,r0,r1,i0)
 694 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 695 #  define ger_u(r0,r1,r2)               _ger_u(_jit,r0,r1,r2)
 696 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 697 #  define gei_u(r0,r1,i0)               _gei_u(_jit,r0,r1,i0)
 698 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 699 #  define gtr(r0,r1,r2)                 _gtr(_jit,r0,r1,r2)
 700 static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 701 #  define gti(r0,r1,i0)                 _gti(_jit,r0,r1,i0)
 702 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 703 #  define gtr_u(r0,r1,r2)               _gtr_u(_jit,r0,r1,r2)
 704 static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 705 #  define gti_u(r0,r1,i0)               _gti_u(_jit,r0,r1,i0)
 706 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 707 #  define ner(r0,r1,r2)                 _ner(_jit,r0,r1,r2)
 708 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 709 #  define nei(r0,r1,i0)                 _nei(_jit,r0,r1,i0)
 710 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 711 #define bltr(i0,r0,r1)                  _bltr(_jit,i0,r0,r1)
 712 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 713 #define blti(i0,r0,i1)                  _blti(_jit,i0,r0,i1)
 714 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 715 #define bltr_u(i0,r0,r1)                _bltr_u(_jit,i0,r0,r1)
 716 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 717 #define blti_u(i0,r0,i1)                _blti_u(_jit,i0,r0,i1)
 718 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 719 #define bler(i0,r0,r1)                  _bler(_jit,i0,r0,r1)
 720 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 721 #define blei(i0,r0,i1)                  _blei(_jit,i0,r0,i1)
 722 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 723 #define bler_u(i0,r0,r1)                _bler_u(_jit,i0,r0,r1)
 724 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 725 #define blei_u(i0,r0,i1)                _blei_u(_jit,i0,r0,i1)
 726 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 727 #define beqr(i0,r0,r1)                  _beqr(_jit,i0,r0,r1)
 728 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 729 #define beqi(i0,r0,i1)                  _beqi(_jit,i0,r0,i1)
 730 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 731 #define bger(i0,r0,r1)                  _bger(_jit,i0,r0,r1)
 732 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 733 #define bgei(i0,r0,i1)                  _bgei(_jit,i0,r0,i1)
 734 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 735 #define bger_u(i0,r0,r1)                _bger_u(_jit,i0,r0,r1)
 736 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 737 #define bgei_u(i0,r0,i1)                _bgei_u(_jit,i0,r0,i1)
 738 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 739 #define bgtr(i0,r0,r1)                  _bgtr(_jit,i0,r0,r1)
 740 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 741 #define bgti(i0,r0,i1)                  _bgti(_jit,i0,r0,i1)
 742 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 743 #define bgtr_u(i0,r0,r1)                _bgtr_u(_jit,i0,r0,r1)
 744 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 745 #define bgti_u(i0,r0,i1)                _bgti_u(_jit,i0,r0,i1)
 746 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 747 #define bner(i0,r0,r1)                  _bner(_jit,i0,r0,r1)
 748 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 749 #define bnei(i0,r0,i1)                  _bnei(_jit,i0,r0,i1)
 750 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 751 #define bmsr(i0,r0,r1)                  _bmsr(_jit,i0,r0,r1)
 752 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 753 #define bmsi(i0,r0,i1)                  _bmsi(_jit,i0,r0,i1)
 754 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 755 #define bmcr(i0,r0,r1)                  _bmcr(_jit,i0,r0,r1)
 756 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 757 #define bmci(i0,r0,i1)                  _bmci(_jit,i0,r0,i1)
 758 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 759 #define boaddr(i0,r0,r1)                _boaddr(_jit,i0,r0,r1)
 760 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 761 #define boaddi(i0,r0,i1)                _boaddi(_jit,i0,r0,i1)
 762 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 763 #define bxaddr(i0,r0,r1)                _bxaddr(_jit,i0,r0,r1)
 764 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 765 #define bxaddi(i0,r0,i1)                _bxaddi(_jit,i0,r0,i1)
 766 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 767 #define bosubr(i0,r0,r1)                _bosubr(_jit,i0,r0,r1)
 768 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 769 #define bosubi(i0,r0,i1)                _bosubi(_jit,i0,r0,i1)
 770 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 771 #define bxsubr(i0,r0,r1)                _bxsubr(_jit,i0,r0,r1)
 772 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 773 #define bxsubi(i0,r0,i1)                _bxsubi(_jit,i0,r0,i1)
 774 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 775 #define boaddr_u(i0,r0,r1)              _boaddr_u(_jit,i0,r0,r1)
 776 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 777 #define boaddi_u(i0,r0,i1)              _boaddi_u(_jit,i0,r0,i1)
 778 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 779 #define bxaddr_u(i0,r0,r1)              _bxaddr_u(_jit,i0,r0,r1)
 780 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 781 #define bxaddi_u(i0,r0,i1)              _bxaddi_u(_jit,i0,r0,i1)
 782 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 783 #define bosubr_u(i0,r0,r1)              _bosubr_u(_jit,i0,r0,r1)
 784 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 785 #define bosubi_u(i0,r0,i1)              _bosubi_u(_jit,i0,r0,i1)
 786 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 787 #define bxsubr_u(i0,r0,r1)              _bxsubr_u(_jit,i0,r0,r1)
 788 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 789 #define bxsubi_u(i0,r0,i1)              _bxsubi_u(_jit,i0,r0,i1)
 790 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 791 #  define ldr_c(r0,r1)                  _ldr_c(_jit,r0,r1)
 792 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
 793 #  define ldi_c(r0,i0)                  _ldi_c(_jit,r0,i0)
 794 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
 795 #  define ldxr_c(r0,r1,i0)              _ldxr_c(_jit,r0,r1,i0)
 796 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 797 #  define ldxi_c(r0,r1,i0)              _ldxi_c(_jit,r0,r1,i0)
 798 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 799 #  define ldr_uc(r0,r1)                 LBZX(r0, _R0_REGNO, r1)
 800 #  define ldi_uc(r0,i0)                 _ldi_uc(_jit,r0,i0)
 801 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
 802 #  define ldxr_uc(r0,r1,r2)             _ldxr_uc(_jit,r0,r1,r2)
 803 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 804 #  define ldxi_uc(r0,r1,i0)             _ldxi_uc(_jit,r0,r1,i0)
 805 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 806 #  define ldr_s(r0,r1)                  LHAX(r0, _R0_REGNO, r1)
 807 #  define ldi_s(r0,i0)                  _ldi_s(_jit,r0,i0)
 808 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
 809 #  define ldxr_s(r0,r1,i0)              _ldxr_s(_jit,r0,r1,i0)
 810 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 811 #  define ldxi_s(r0,r1,i0)              _ldxi_s(_jit,r0,r1,i0)
 812 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 813 #  define ldr_us(r0,r1)                 LHZX(r0, _R0_REGNO, r1)
 814 #  define ldi_us(r0,i0)                 _ldi_us(_jit,r0,i0)
 815 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
 816 #  define ldxr_us(r0,r1,i0)             _ldxr_us(_jit,r0,r1,i0)
 817 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 818 #  define ldxi_us(r0,r1,i0)             _ldxi_us(_jit,r0,r1,i0)
 819 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 820 #  if __WORDSIZE == 32
 821 #    define ldr_i(r0,r1)                LWZX(r0, _R0_REGNO, r1)
 822 #  else
 823 #    define ldr_i(r0,r1)                LWAX(r0, _R0_REGNO, r1)
 824 #  endif
 825 #  define ldi_i(r0,i0)                  _ldi_i(_jit,r0,i0)
 826 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
 827 #  define ldxr_i(r0,r1,i0)              _ldxr_i(_jit,r0,r1,i0)
 828 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 829 #  define ldxi_i(r0,r1,i0)              _ldxi_i(_jit,r0,r1,i0)
 830 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 831 #  if __WORDSIZE == 64
 832 #    define ldr_ui(r0,r1)               LWZX(r0, _R0_REGNO, r1)
 833 #    define ldi_ui(r0,i0)               _ldi_ui(_jit,r0,i0)
 834 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
 835 #    define ldxr_ui(r0,r1,i0)           _ldxr_ui(_jit,r0,r1,i0)
 836 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 837 #    define ldxi_ui(r0,r1,i0)           _ldxi_ui(_jit,r0,r1,i0)
 838 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 839 #    define ldr_l(r0,r1)                LDX(r0, _R0_REGNO, r1)
 840 #    define ldi_l(r0,i0)                _ldi_l(_jit,r0,i0)
 841 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
 842 #    define ldxr_l(r0,r1,i0)            _ldxr_l(_jit,r0,r1,i0)
 843 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 844 #    define ldxi_l(r0,r1,i0)            _ldxi_l(_jit,r0,r1,i0)
 845 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 846 #  endif
 847 #  define str_c(r0,r1)                  STBX(r1, _R0_REGNO, r0)
 848 #  define sti_c(i0,r0)                  _sti_c(_jit,i0,r0)
 849 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
 850 #  define stxr_c(r0,r1,r2)              _stxr_c(_jit,r0,r1,r2)
 851 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 852 #  define stxi_c(i0,r0,r1)              _stxi_c(_jit,i0,r0,r1)
 853 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 854 #  define str_s(r0,r1)                  STHX(r1, _R0_REGNO, r0)
 855 #  define sti_s(i0,r0)                  _sti_s(_jit,i0,r0)
 856 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
 857 #  define stxr_s(r0,r1,r2)              _stxr_s(_jit,r0,r1,r2)
 858 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 859 #  define stxi_s(i0,r0,r1)              _stxi_s(_jit,i0,r0,r1)
 860 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 861 #  define str_i(r0,r1)                  STWX(r1, _R0_REGNO, r0)
 862 #  define sti_i(i0,r0)                  _sti_i(_jit,i0,r0)
 863 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
 864 #  define stxr_i(r0,r1,r2)              _stxr_i(_jit,r0,r1,r2)
 865 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 866 #  define stxi_i(i0,r0,r1)              _stxi_i(_jit,i0,r0,r1)
 867 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 868 #  if __WORDSIZE == 64
 869 #    define str_l(r0,r1)                STDX(r1, _R0_REGNO, r0)
 870 #    define sti_l(i0,r0)                _sti_l(_jit,i0,r0)
 871 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
 872 #    define stxr_l(r0,r1,r2)            _stxr_l(_jit,r0,r1,r2)
 873 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 874 #    define stxi_l(i0,r0,r1)            _stxi_l(_jit,i0,r0,r1)
 875 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 876 #  endif
 877 #  define jmpr(r0)                      _jmpr(_jit,r0)
 878 static void _jmpr(jit_state_t*,jit_int32_t);
 879 #  define jmpi(i0)                      _jmpi(_jit,i0)
 880 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
 881 #  define jmpi_p(i0)                    _jmpi_p(_jit,i0)
 882 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
 883 #  if _CALL_SYSV
 884 #    define callr(r0,i0)                _callr(_jit,r0,i0)
 885 static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
 886 #    define calli(i0,i1)                _calli(_jit,i0,i1)
 887 static jit_word_t _calli(jit_state_t*,jit_word_t,jit_int32_t);
 888 #  define calli_p(i0,i1)                _calli_p(_jit,i0,i1)
 889 static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
 890 #  else
 891 #    define callr(r0)                   _callr(_jit,r0)
 892 static void _callr(jit_state_t*,jit_int32_t);
 893 #    define calli(i0)                   _calli(_jit,i0)
 894 static jit_word_t _calli(jit_state_t*,jit_word_t);
 895 #    define calli_p(i0)                 _calli_p(_jit,i0)
 896 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 897 #endif
 898 #  define prolog(node)                  _prolog(_jit, node)
 899 static void _prolog(jit_state_t*, jit_node_t*);
 900 #  define epilog(node)                  _epilog(_jit, node)
 901 static void _epilog(jit_state_t*, jit_node_t*);
 902 #  define vastart(r0)                   _vastart(_jit, r0)
 903 static void _vastart(jit_state_t*, jit_int32_t);
 904 #  define vaarg(r0, r1)                 _vaarg(_jit, r0, r1)
 905 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 906 #  define vaarg_d(r0, r1)               _vaarg_d(_jit, r0, r1)
 907 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
 908 #  define patch_at(i,l)                 _patch_at(_jit,i,l)
 909 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 910 #endif
 911
 912 #if CODE
 913 #  define _u16(v)                       ((v) & 0xffff)
 914 #  define _u26(v)                       ((v) & 0x3ffffff)
 915 static void
 916 _FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
 917 {
 918     assert(!(o & ~((1 << 6) - 1)));
 919     assert(!(d & ~((1 << 5) - 1)));
 920     assert(!(a & ~((1 << 5) - 1)));
 921     assert(!(b & ~((1 << 5) - 1)));
 922     assert(!(e & ~((1 << 1) - 1)));
 923     assert(!(x & ~((1 << 9) - 1)));
 924     assert(!(r & ~((1 << 1) - 1)));
 925     ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
 926 }
 927
 928 static void
 929 _FDs(jit_state_t *_jit, int o, int d, int a, int s)
 930 {
 931     assert(!(o & ~((1 << 6) - 1)));
 932     assert(!(d & ~((1 << 5) - 1)));
 933     assert(!(a & ~((1 << 5) - 1)));
 934     assert(can_sign_extend_short_p(s));
 935     ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
 936 }
 937
 938 static void
 939 _FDu(jit_state_t *_jit, int o, int d, int a, int s)
 940 {
 941     assert(!(o & ~((1 << 6) - 1)));
 942     assert(!(d & ~((1 << 5) - 1)));
 943     assert(!(a & ~((1 << 5) - 1)));
 944     assert(can_zero_extend_short_p(s));
 945     ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
 946 }
 947
 948 static void
 949 _FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
 950 {
 951     assert(!(o & ~((1 <<  6) - 1)));
 952     assert(!(s & ~((1 <<  5) - 1)));
 953     assert(!(a & ~((1 <<  5) - 1)));
 954     assert(!(b & ~((1 <<  5) - 1)));
 955     assert(!(x & ~((1 << 10) - 1)));
 956     assert(!(r & ~((1 <<  1) - 1)));
 957     ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
 958 }
 959
 960 static void
 961 _FI(jit_state_t *_jit, int o, int t, int a, int k)
 962 {
 963     assert(!(o & ~(( 1 <<  6) - 1)));
 964     assert(!(t & 3) && can_sign_extend_jump_p(t));
 965     assert(!(a & ~(( 1 <<  1) - 1)));
 966     assert(!(k & ~(( 1 <<  1) - 1)));
 967     ii((o<<26)|_u26(t)|(a<<1)|k);
 968 }
 969
 970 static void
 971 _FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
 972 {
 973     assert(!( o & ~((1 <<  6) - 1)));
 974     assert(!(bo & ~((1 <<  5) - 1)));
 975     assert(!(bi & ~((1 <<  5) - 1)));
 976     assert(!(t & 3) && can_sign_extend_short_p(t));
 977     assert(!(a & ~(( 1 <<  1) - 1)));
 978     assert(!(k & ~(( 1 <<  1) - 1)));
 979     ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
 980 }
 981
 982 static void
 983 _FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
 984 {
 985     assert(!( o & ~((1 <<  6) - 1)));
 986     assert(!(bo & ~((1 <<  5) - 1)));
 987     assert(!(bi & ~((1 <<  5) - 1)));
 988     assert(!(x & ~(( 1 << 10) - 1)));
 989     assert(!(k & ~(( 1 <<  1) - 1)));
 990     ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
 991 }
 992
 993 static void
 994 _FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
 995 {
 996     assert(!(o & ~((1 <<  6) - 1)));
 997     assert(!(d & ~((1 <<  3) - 1)));
 998     assert(!(l & ~((1 <<  1) - 1)));
 999     assert(!(a & ~((1 <<  5) - 1)));
1000     assert(!(b & ~((1 <<  5) - 1)));
1001     assert(!(x & ~((1 << 10) - 1)));
1002     ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
1003 }
1004
1005 static void
1006 _FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
1007 {
1008     assert(!(o & ~((1 << 6) - 1)));
1009     assert(!(d & ~((1 << 3) - 1)));
1010     assert(!(l & ~((1 << 1) - 1)));
1011     assert(!(a & ~((1 << 5) - 1)));
1012     if (o == 11)        assert(can_sign_extend_short_p(s));
1013     else if (o == 10)   assert(can_zero_extend_short_p(s));
1014 #if DEBUG
1015     else                abort();
1016 #endif
1017     ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
1018 }
1019
1020 static void
1021 _FXFX(jit_state_t *_jit, int o, int d, int x, int f)
1022 {
1023     assert(!(o & ~((1 <<  6) - 1)));
1024     assert(!(d & ~((1 <<  5) - 1)));
1025     assert(!(x & ~((1 << 10) - 1)));
1026     assert(!(f & ~((1 << 10) - 1)));
1027     ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
1028 }
1029
1030 static void
1031 _FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, int r)
1032 {
1033     assert(!(o & ~((1 << 6) - 1)));
1034     assert(!(s & ~((1 << 5) - 1)));
1035     assert(!(a & ~((1 << 5) - 1)));
1036     assert(!(h & ~((1 << 5) - 1)));
1037     assert(!(b & ~((1 << 5) - 1)));
1038     assert(!(e & ~((1 << 5) - 1)));
1039     assert(!(r & ~((1 << 1) - 1)));
1040     ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1041 }
1042
1043 #  if __WORDSIZE == 64
1044 static void
1045 _FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1046 {
1047     assert(!(o & ~((1 << 6) - 1)));
1048     assert(!(s & ~((1 << 5) - 1)));
1049     assert(!(a & ~((1 << 5) - 1)));
1050     assert(!(b & ~((1 << 5) - 1)));
1051     assert(!(e & ~((1 << 6) - 1)));
1052     assert(!(x & ~((1 << 4) - 1)));
1053     assert(!(r & ~((1 << 1) - 1)));
1054     e = (e >> 5) | ((e << 1) & 63);
1055     ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1056 }
1057
1058 static void
1059 _FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1060 {
1061     assert(!(o & ~((1 << 6) - 1)));
1062     assert(!(s & ~((1 << 5) - 1)));
1063     assert(!(a & ~((1 << 5) - 1)));
1064     assert(!(h & ~((1 << 5) - 1)));
1065     assert(!(e & ~((1 << 6) - 1)));
1066     assert(!(x & ~((1 << 3) - 1)));
1067     assert(!(i & ~((1 << 1) - 1)));
1068     assert(!(r & ~((1 << 1) - 1)));
1069     e = (e >> 5) | ((e << 1) & 63);
1070     ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1071 }
1072
1073 static void
1074 _FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1075 {
1076     assert(!(o & ~((1 << 6) - 1)));
1077     assert(!(s & ~((1 << 5) - 1)));
1078     assert(!(a & ~((1 << 5) - 1)));
1079     assert(!(h & ~((1 << 5) - 1)));
1080     assert(!(x & ~((1 << 9) - 1)));
1081     assert(!(i & ~((1 << 1) - 1)));
1082     assert(!(r & ~((1 << 1) - 1)));
1083     ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1084 }
1085 #endif
1086
1087 #if !DEBUG
1088 /*
1089  * Use the sequence commented at
1090  * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1091  */
1092 static void
1093 _MCRXR(jit_state_t *_jit, jit_int32_t cr)
1094 {
1095     jit_int32_t         reg;
1096     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1097     MFXER(rn(reg));
1098     MTCRF(128, rn(reg));
1099     RLWINM(rn(reg), rn(reg), 0, 0, 28);
1100     MTXER(rn(reg));
1101     jit_unget_reg(reg);
1102 }
1103 #endif
1104
1105 static void
1106 _nop(jit_state_t *_jit, jit_int32_t i0)
1107 {
1108     for (; i0 > 0; i0 -= 4)
1109         NOP();
1110     assert(i0 == 0);
1111 }
1112
1113 static void
1114 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1115 {
1116     if (r0 != r1)
1117         MR(r0, r1);
1118 }
1119
1120 static void
1121 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1122 {
1123     if (can_sign_extend_short_p(i0))
1124         LI(r0, i0);
1125     else {
1126         if (can_sign_extend_int_p(i0))
1127             LIS(r0, (jit_int16_t)(i0 >> 16));
1128         else if (can_zero_extend_int_p(i0)) {
1129             if (i0 & 0xffff0000) {
1130                 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1131                 SLWI(r0, r0, 16);
1132             }
1133         }
1134 #  if __WORDSIZE == 64
1135         else {
1136             movi(r0, (jit_uint32_t)(i0 >> 32));
1137             if (i0 & 0xffff0000) {
1138                 SLDI(r0, r0, 16);
1139                 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1140                 SLDI(r0, r0, 16);
1141             }
1142             else
1143                 SLDI(r0, r0, 32);
1144         }
1145 #  endif
1146         if (i0 & 0xffff)
1147             ORI(r0, r0, (jit_uint16_t)i0);
1148     }
1149 }
1150
1151 static void
1152 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1153 {
1154     CMPXI(r2, 0);
1155     BEQ(8);
1156     MR(r0, r1);
1157 }
1158
1159 static void
1160 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1161 {
1162     CMPXI(r2, 0);
1163     BNE(8);
1164     MR(r0, r1);
1165 }
1166
1167 static jit_word_t
1168 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1169 {
1170     jit_word_t          word = _jit->pc.w;
1171 #  if __WORDSIZE == 32
1172     LIS(r0, (jit_int16_t)(i0 >> 16));
1173     ORI(r0, r0, (jit_uint16_t)i0);
1174 #  else
1175     LIS(r0, (jit_int16_t)(i0 >> 48));
1176     ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1177     SLDI(r0, r0, 16);
1178     ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1179     SLDI(r0, r0, 16);
1180     ORI(r0, r0, (jit_uint16_t)i0);
1181 #  endif
1182     return (word);
1183 }
1184
1185 static void
1186 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1187       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1188 {
1189     jit_int32_t         r1_reg, iscasi;
1190     jit_word_t          retry, done, jump0, jump1;
1191     if ((iscasi = (r1 == _NOREG))) {
1192         r1_reg = jit_get_reg(jit_class_gpr);
1193         r1 = rn(r1_reg);
1194         movi(r1, i0);
1195     }
1196     SYNC();
1197     /* retry: */
1198     retry = _jit->pc.w;
1199 #  if __WORDSIZE == 32
1200     LWARX(r0, _R0_REGNO, r1);
1201 #  else
1202     LDARX(r0, _R0_REGNO, r1);
1203 #  endif
1204     jump0 = bner(_jit->pc.w, r0, r2);   /* bne done r0 r2 */
1205 #  if __WORDSIZE == 32
1206     STWCX_(r3, _R0_REGNO, r1);
1207 #  else
1208     STDCX_(r3, _R0_REGNO, r1);
1209 #  endif
1210     jump1 = _jit->pc.w;
1211     BNE(0);                             /* BNE retry */
1212     /* done: */
1213     done = _jit->pc.w;
1214     ISYNC();
1215     MFCR(r0);
1216     EXTRWI(r0, r0, 1, CR_EQ);
1217     patch_at(jump0, done);
1218     patch_at(jump1, retry);
1219     if (iscasi)
1220         jit_unget_reg(r1_reg);
1221 }
1222
1223 /* http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel */
1224 /*
1225 unsigned int v; // 32-bit word to reverse bit order
1226
1227 // swap odd and even bits
1228 v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1);
1229 // swap consecutive pairs
1230 v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);
1231 // swap nibbles ...
1232 v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);
1233 // swap bytes
1234 v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
1235 // swap 2-byte long pairs
1236 v = ( v >> 16             ) | ( v               << 16);
1237  */
1238 static void
1239 _bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1240 {
1241     jit_int32_t         t0, t1, t2, t3, t4;
1242     movr(r0, r1);
1243     t0 = jit_get_reg(jit_class_gpr);
1244     t1 = jit_get_reg(jit_class_gpr);
1245     t2 = jit_get_reg(jit_class_gpr);
1246     movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L);
1247     rshi_u(rn(t1), r0, 1);              /* t1 = v >> 1 */
1248     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1249     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1250     lshi(rn(t2), rn(t2), 1);            /* t2 <<= 1 */
1251     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1252     movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L);
1253     rshi_u(rn(t1), r0, 2);              /* t1 = v >> 2 */
1254     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1255     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1256     lshi(rn(t2), rn(t2), 2);            /* t2 <<= 2 */
1257     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1258     movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL);
1259     rshi_u(rn(t1), r0, 4);              /* t1 = v >> 4 */
1260     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1261     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1262     lshi(rn(t2), rn(t2), 4);            /* t2 <<= 4 */
1263     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1264     movi(rn(t0), __WORDSIZE == 32 ?  0x00ff00ffL : 0x00ff00ff00ff00ffL);
1265     rshi_u(rn(t1), r0, 8);              /* t1 = v >> 8 */
1266     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1267     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1268     lshi(rn(t2), rn(t2), 8);            /* t2 <<= 8 */
1269     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1270 #  if __WORDSIZE == 32
1271     rshi_u(rn(t1), r0, 16);             /* t1 = v >> 16 */
1272     lshi(rn(t2), r0, 16);               /* t2 = v << 16 */
1273     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1274 #  else
1275     movi(rn(t0), 0x0000ffff0000ffffL);
1276     rshi_u(rn(t1), r0, 16);             /* t1 = v >> 16 */
1277     andr(rn(t1), rn(t1), rn(t0));       /* t1 &= t0 */
1278     andr(rn(t2), r0, rn(t0));           /* t2 = v & t0*/
1279     lshi(rn(t2), rn(t2), 16);           /* t2 <<= 16 */
1280     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1281     rshi_u(rn(t1), r0, 32);             /* t1 = v >> 32 */
1282     lshi(rn(t2), r0, 32);               /* t2 = v << 32 */
1283     orr(r0, rn(t1), rn(t2));            /* v = t1 | t2 */
1284 #  endif
1285     jit_unget_reg(t2);
1286     jit_unget_reg(t1);
1287     jit_unget_reg(t0);
1288 }
1289
1290 static void
1291 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1292 {
1293     comr(r0, r1);
1294     clzr(r0, r0);
1295 }
1296
1297 static void
1298 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1299 {
1300     bitswap(r0, r1);
1301     clor(r0, r0);
1302 }
1303
1304 static void
1305 _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1306 {
1307     bitswap(r0, r1);
1308     clzr(r0, r0);
1309 }
1310
1311 static void
1312 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1313 {
1314     jit_int32_t         reg, addr_reg;
1315
1316     /* Convert load followed by bswap to a single instruction */
1317     /* FIXME r0 and r1 do not need to be the same, only must check if
1318      * r1 was loaded in previous instruction */
1319     if (no_flag && r0 == r1) {
1320         if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00022e | r0 << 21)) {
1321             /* Convert LHZX to LHBRX */
1322             _jit->pc.ui--;
1323             LHBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1324             return;
1325         }
1326
1327         if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0xa0000000 | r0 << 21)) {
1328             /* Convert LHZ to LHBRX */
1329             _jit->pc.ui--;
1330             addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1331
1332             reg = jit_get_reg(jit_class_gpr);
1333             LI(rn(reg), (short)*_jit->pc.ui);
1334             LHBRX(r0, rn(reg), addr_reg);
1335             jit_unget_reg(reg);
1336             return;
1337         }
1338     }
1339
1340     if (r0 == r1) {
1341         RLWIMI(r0, r0, 16, 8, 15);
1342         RLWINM(r0, r0, 24, 16, 31);
1343     } else {
1344         RLWINM(r0, r1, 8, 16, 23);
1345         RLWIMI(r0, r1, 24, 24, 31);
1346     }
1347 }
1348
1349 static void
1350 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1351 {
1352     jit_int32_t         reg, addr_reg;
1353
1354     /* Convert load followed by bswap to a single instruction */
1355     /* FIXME r0 and r1 do not need to be the same, only must check if
1356      * r1 was loaded in previous instruction */
1357     if (no_flag && r0 == r1) {
1358         if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00002e | r0 << 21)) {
1359             /* Convert LWZX to LWBRX */
1360             _jit->pc.ui--;
1361             LWBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1362             return;
1363         }
1364
1365         if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0x80000000 | r0 << 21)) {
1366             /* Convert LWZ to LWBRX */
1367             _jit->pc.ui--;
1368             addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1369
1370             reg = jit_get_reg(jit_class_gpr);
1371             LI(rn(reg), (short)*_jit->pc.ui);
1372             LWBRX(r0, rn(reg), addr_reg);
1373             jit_unget_reg(reg);
1374             return;
1375         }
1376     }
1377
1378     reg = jit_get_reg(jit_class_gpr);
1379     ROTLWI(rn(reg), r1, 8);
1380     RLWIMI(rn(reg), r1, 24, 0, 7);
1381     RLWIMI(rn(reg), r1, 24, 16, 23);
1382 #  if __WORDSIZE == 64
1383     CLRLDI(r0, rn(reg), 32);
1384 #  else
1385     MR(r0,rn(reg));
1386 #  endif
1387     jit_unget_reg(reg);
1388 }
1389
1390 static void
1391 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1392 {
1393     jit_int32_t         reg;
1394     if (can_sign_extend_short_p(i0))
1395         ADDI(r0, r1, i0);
1396     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1397         ADDIS(r0, r1, i0 >> 16);
1398     else {
1399         reg = jit_get_reg(jit_class_gpr);
1400         movi(rn(reg), i0);
1401         ADD(r0, r1, rn(reg));
1402         jit_unget_reg(reg);
1403     }
1404 }
1405
1406 static void
1407 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1408 {
1409     jit_int32_t         reg;
1410     if (can_sign_extend_short_p(i0))
1411         ADDIC(r0, r1, i0);
1412     else {
1413         reg = jit_get_reg(jit_class_gpr);
1414         movi(rn(reg), i0);
1415         ADDC(r0, r1, rn(reg));
1416         jit_unget_reg(reg);
1417     }
1418 }
1419
1420 static void
1421 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1422 {
1423     jit_int32_t         reg;
1424     reg = jit_get_reg(jit_class_gpr);
1425     movi(rn(reg), i0);
1426     ADDE(r0, r1, rn(reg));
1427     jit_unget_reg(reg);
1428 }
1429
1430 static void
1431 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1432 {
1433     jit_int32_t         reg;
1434     jit_word_t          ni0 = -i0;
1435     if (can_sign_extend_short_p(ni0))
1436         ADDI(r0, r1, ni0);
1437     else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1438         ADDIS(r0, r1, ni0 >> 16);
1439     else {
1440         reg = jit_get_reg(jit_class_gpr);
1441         movi(rn(reg), i0);
1442         SUB(r0, r1, rn(reg));
1443         jit_unget_reg(reg);
1444     }
1445 }
1446
1447 static void
1448 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1449 {
1450     jit_int32_t         reg;
1451     reg = jit_get_reg(jit_class_gpr);
1452     movi(rn(reg), i0);
1453     SUBC(r0, r1, rn(reg));
1454     jit_unget_reg(reg);
1455 }
1456
1457 static void
1458 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1459 {
1460     jit_int32_t         reg;
1461     reg = jit_get_reg(jit_class_gpr);
1462     movi(rn(reg), i0);
1463     SUBE(r0, r1, rn(reg));
1464     jit_unget_reg(reg);
1465 }
1466
1467 static void
1468 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1469 {
1470     subi(r0, r1, i0);
1471     negr(r0, r0);
1472 }
1473
1474 static void
1475 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1476 {
1477     jit_int32_t         reg;
1478     if (can_sign_extend_short_p(i0))
1479         MULLI(r0, r1, i0);
1480     else {
1481         reg = jit_get_reg(jit_class_gpr);
1482         movi(rn(reg), i0);
1483         mulr(r0, r1, rn(reg));
1484         jit_unget_reg(reg);
1485     }
1486 }
1487
1488 static void
1489 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1490         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1491 {
1492     jit_int32_t         reg;
1493     if (r0 == r2 || r0 == r3) {
1494         reg = jit_get_reg(jit_class_gpr);
1495         mullr(rn(reg), r2, r3);
1496     }
1497     else
1498         mullr(r0, r2, r3);
1499     if (sign)
1500         mulhr(r1, r2, r3);
1501     else
1502         mulhr_u(r1, r2, r3);
1503     if (r0 == r2 || r0 == r3) {
1504         movr(r0, rn(reg));
1505         jit_unget_reg(reg);
1506     }
1507 }
1508
1509 static void
1510 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1511         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1512 {
1513     jit_int32_t         reg;
1514     reg = jit_get_reg(jit_class_gpr);
1515     movi(rn(reg), i0);
1516     iqmulr(r0, r1, r2, rn(reg), sign);
1517     jit_unget_reg(reg);
1518 }
1519
1520 static void
1521 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1522 {
1523     jit_int32_t         reg;
1524     reg = jit_get_reg(jit_class_gpr);
1525     movi(rn(reg), i0);
1526     divr(r0, r1, rn(reg));
1527     jit_unget_reg(reg);
1528 }
1529
1530 static void
1531 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1532 {
1533     jit_int32_t         reg;
1534     reg = jit_get_reg(jit_class_gpr);
1535     movi(rn(reg), i0);
1536     divr_u(r0, r1, rn(reg));
1537     jit_unget_reg(reg);
1538 }
1539
1540 static void
1541 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1542         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1543 {
1544     jit_int32_t         sv0, rg0;
1545     jit_int32_t         sv1, rg1;
1546
1547     if (r0 == r2 || r0 == r3) {
1548         sv0 = jit_get_reg(jit_class_gpr);
1549         rg0 = rn(sv0);
1550     }
1551     else
1552         rg0 = r0;
1553     if (r1 == r2 || r1 == r3) {
1554         sv1 = jit_get_reg(jit_class_gpr);
1555         rg1 = rn(sv1);
1556     }
1557     else
1558         rg1 = r1;
1559
1560     if (sign)
1561         divr(rg0, r2, r3);
1562     else
1563         divr_u(rg0, r2, r3);
1564     mulr(rg1, r3, rg0);
1565     subr(rg1, r2, rg1);
1566     if (rg0 != r0) {
1567         movr(r0, rg0);
1568         jit_unget_reg(sv0);
1569     }
1570     if (rg1 != r1) {
1571         movr(r1, rg1);
1572         jit_unget_reg(sv1);
1573     }
1574 }
1575
1576 static void
1577 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1578         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1579 {
1580     jit_int32_t         reg;
1581     reg = jit_get_reg(jit_class_gpr);
1582     movi(rn(reg), i0);
1583     iqdivr(r0, r1, r2, rn(reg), sign);
1584     jit_unget_reg(reg);
1585 }
1586
1587 static void
1588 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1589 {
1590     jit_int32_t         reg;
1591     if (r0 == r1 || r0 == r2) {
1592         reg = jit_get_reg(jit_class_gpr);
1593         divr(rn(reg), r1, r2);
1594         mulr(rn(reg), r2, rn(reg));
1595         subr(r0, r1, rn(reg));
1596         jit_unget_reg(reg);
1597     }
1598     else {
1599         divr(r0, r1, r2);
1600         mulr(r0, r2, r0);
1601         subr(r0, r1, r0);
1602     }
1603 }
1604
1605 static void
1606 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1607 {
1608     jit_int32_t         reg;
1609     reg = jit_get_reg(jit_class_gpr);
1610     movi(rn(reg), i0);
1611     remr(r0, r1, rn(reg));
1612     jit_unget_reg(reg);
1613 }
1614
1615 static void
1616 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1617 {
1618     jit_int32_t         reg;
1619     if (r0 == r1 || r0 == r2) {
1620         reg = jit_get_reg(jit_class_gpr);
1621         divr_u(rn(reg), r1, r2);
1622         mulr(rn(reg), r2, rn(reg));
1623         subr(r0, r1, rn(reg));
1624         jit_unget_reg(reg);
1625     }
1626     else {
1627         divr_u(r0, r1, r2);
1628         mulr(r0, r2, r0);
1629         subr(r0, r1, r0);
1630     }
1631 }
1632
1633 static void
1634 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1635 {
1636     jit_int32_t         reg;
1637     reg = jit_get_reg(jit_class_gpr);
1638     movi(rn(reg), i0);
1639     remr_u(r0, r1, rn(reg));
1640     jit_unget_reg(reg);
1641 }
1642
1643 #  define is_mask(im)           ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
1644
1645 static void
1646 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1647 {
1648     jit_int32_t         reg, offt;
1649     if (can_zero_extend_short_p(i0))
1650         ANDI_(r0, r1, i0);
1651     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1652         ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1653     else if (__WORDSIZE == 32 && is_mask(i0)) {
1654         offt = __builtin_ctzl(i0);
1655         RLWINM(r0, r1, 0, 32 - offt - __builtin_popcountl(i0), 31 - offt);
1656     } else if (__WORDSIZE == 32 && is_mask(~i0)) {
1657         offt = __builtin_ctzl(~i0);
1658         RLWINM(r0, r1, 0, 32 - offt, 31 - offt - __builtin_popcountl(~i0));
1659     } else {
1660         reg = jit_get_reg(jit_class_gpr);
1661         movi(rn(reg), i0);
1662         AND(r0, r1, rn(reg));
1663         jit_unget_reg(reg);
1664     }
1665 }
1666
1667 static void
1668 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1669 {
1670     jit_int32_t         reg;
1671     if (can_zero_extend_short_p(i0))
1672         ORI(r0, r1, i0);
1673     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1674         ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1675     else {
1676         reg = jit_get_reg(jit_class_gpr);
1677         movi(rn(reg), i0);
1678         OR(r0, r1, rn(reg));
1679         jit_unget_reg(reg);
1680     }
1681 }
1682
1683 static void
1684 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1685 {
1686     jit_int32_t         reg;
1687     if (can_zero_extend_short_p(i0))
1688         XORI(r0, r1, i0);
1689     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1690         XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1691     else {
1692         reg = jit_get_reg(jit_class_gpr);
1693         movi(rn(reg), i0);
1694         XOR(r0, r1, rn(reg));
1695         jit_unget_reg(reg);
1696     }
1697 }
1698
1699 static void
1700 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1701 {
1702     if (i0 == 0)
1703         movr(r0, r1);
1704     else {
1705 #  if __WORDSIZE == 32
1706         SLWI(r0, r1, i0);
1707 #  else
1708         SLDI(r0, r1, i0);
1709 #  endif
1710     }
1711 }
1712
1713 static void
1714 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1715 {
1716     if (i0 == 0)
1717         movr(r0, r1);
1718     else {
1719 #  if __WORDSIZE == 32
1720         SRAWI(r0, r1, i0);
1721 #  else
1722         SRADI(r0, r1, i0);
1723 #  endif
1724     }
1725 }
1726
1727 static void
1728 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1729 {
1730     if (i0 == 0)
1731         movr(r0, r1);
1732     else {
1733 #  if __WORDSIZE == 32
1734         SRWI(r0, r1, i0);
1735 #  else
1736         SRDI(r0, r1, i0);
1737 #  endif
1738     }
1739 }
1740
1741 static void
1742 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1743 {
1744     CMPX(r1, r2);
1745     MFCR(r0);
1746     EXTRWI(r0, r0, 1, CR_LT);
1747 }
1748
1749 static void
1750 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1751 {
1752     jit_int32_t         reg;
1753     if (can_sign_extend_short_p(i0))
1754         CMPXI(r1, i0);
1755     else {
1756         reg = jit_get_reg(jit_class_gpr);
1757         movi(rn(reg), i0);
1758         CMPX(r1, rn(reg));
1759         jit_unget_reg(reg);
1760     }
1761     MFCR(r0);
1762     EXTRWI(r0, r0, 1, CR_LT);
1763 }
1764
1765 static void
1766 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1767 {
1768     CMPLW(r1, r2);
1769     MFCR(r0);
1770     EXTRWI(r0, r0, 1, CR_LT);
1771 }
1772
1773 static void
1774 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1775 {
1776     jit_int32_t         reg;
1777     if (can_zero_extend_short_p(i0))
1778         CMPLWI(r1, i0);
1779     else {
1780         reg = jit_get_reg(jit_class_gpr);
1781         movi(rn(reg), i0);
1782         CMPLW(r1, rn(reg));
1783         jit_unget_reg(reg);
1784     }
1785     MFCR(r0);
1786     EXTRWI(r0, r0, 1, CR_LT);
1787 }
1788
1789 static void
1790 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1791 {
1792     CMPX(r1, r2);
1793     CRNOT(CR_GT, CR_GT);
1794     MFCR(r0);
1795     EXTRWI(r0, r0, 1, CR_GT);
1796 }
1797
1798 static void
1799 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1800 {
1801     jit_int32_t         reg;
1802     if (can_sign_extend_short_p(i0))
1803         CMPXI(r1, i0);
1804     else {
1805         reg = jit_get_reg(jit_class_gpr);
1806         movi(rn(reg), i0);
1807         CMPX(r1, rn(reg));
1808         jit_unget_reg(reg);
1809     }
1810     CRNOT(CR_GT, CR_GT);
1811     MFCR(r0);
1812     EXTRWI(r0, r0, 1, CR_GT);
1813 }
1814
1815 static void
1816 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1817 {
1818     CMPLW(r1, r2);
1819     CRNOT(CR_GT, CR_GT);
1820     MFCR(r0);
1821     EXTRWI(r0, r0, 1, CR_GT);
1822 }
1823
1824 static void
1825 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1826 {
1827     jit_int32_t         reg;
1828     if (can_zero_extend_short_p(i0))
1829         CMPLWI(r1, i0);
1830     else {
1831         reg = jit_get_reg(jit_class_gpr);
1832         movi(rn(reg), i0);
1833         CMPLW(r1, rn(reg));
1834         jit_unget_reg(reg);
1835     }
1836     CRNOT(CR_GT, CR_GT);
1837     MFCR(r0);
1838     EXTRWI(r0, r0, 1, CR_GT);
1839 }
1840
1841 static void
1842 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1843 {
1844     CMPX(r1, r2);
1845     MFCR(r0);
1846     EXTRWI(r0, r0, 1, CR_EQ);
1847 }
1848
1849 static void
1850 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1851 {
1852     jit_int32_t         reg;
1853     if (can_sign_extend_short_p(i0))
1854         CMPXI(r1, i0);
1855     else if (can_zero_extend_short_p(i0))
1856         CMPLWI(r1, i0);
1857     else {
1858         reg = jit_get_reg(jit_class_gpr);
1859         movi(rn(reg), i0);
1860         CMPX(r1, rn(reg));
1861         jit_unget_reg(reg);
1862     }
1863     MFCR(r0);
1864     EXTRWI(r0, r0, 1, CR_EQ);
1865 }
1866
1867 static void
1868 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1869 {
1870     CMPX(r1, r2);
1871     CRNOT(CR_LT, CR_LT);
1872     MFCR(r0);
1873     EXTRWI(r0, r0, 1, CR_LT);
1874 }
1875
1876 static void
1877 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1878 {
1879     jit_int32_t         reg;
1880     if (can_sign_extend_short_p(i0))
1881         CMPXI(r1, i0);
1882     else {
1883         reg = jit_get_reg(jit_class_gpr);
1884         movi(rn(reg), i0);
1885         CMPX(r1, rn(reg));
1886         jit_unget_reg(reg);
1887     }
1888     CRNOT(CR_LT, CR_LT);
1889     MFCR(r0);
1890     EXTRWI(r0, r0, 1, CR_LT);
1891 }
1892
1893 static void
1894 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1895 {
1896     CMPLW(r1, r2);
1897     CRNOT(CR_LT, CR_LT);
1898     MFCR(r0);
1899     EXTRWI(r0, r0, 1, CR_LT);
1900 }
1901
1902 static void
1903 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1904 {
1905     jit_int32_t         reg;
1906     if (can_zero_extend_short_p(i0))
1907         CMPLWI(r1, i0);
1908     else {
1909         reg = jit_get_reg(jit_class_gpr);
1910         movi(rn(reg), i0);
1911         CMPLW(r1, rn(reg));
1912         jit_unget_reg(reg);
1913     }
1914     CRNOT(CR_LT, CR_LT);
1915     MFCR(r0);
1916     EXTRWI(r0, r0, 1, CR_LT);
1917 }
1918
1919 static void
1920 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1921 {
1922     CMPX(r1, r2);
1923     MFCR(r0);
1924     EXTRWI(r0, r0, 1, CR_GT);
1925 }
1926
1927 static void
1928 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1929 {
1930     jit_int32_t         reg;
1931     if (can_sign_extend_short_p(i0))
1932         CMPXI(r1, i0);
1933     else {
1934         reg = jit_get_reg(jit_class_gpr);
1935         movi(rn(reg), i0);
1936         CMPX(r1, rn(reg));
1937         jit_unget_reg(reg);
1938     }
1939     MFCR(r0);
1940     EXTRWI(r0, r0, 1, CR_GT);
1941 }
1942
1943 static void
1944 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1945 {
1946     CMPLW(r1, r2);
1947     MFCR(r0);
1948     EXTRWI(r0, r0, 1, CR_GT);
1949 }
1950
1951 static void
1952 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1953 {
1954     jit_int32_t         reg;
1955     if (can_zero_extend_short_p(i0))
1956         CMPLWI(r1, i0);
1957     else {
1958         reg = jit_get_reg(jit_class_gpr);
1959         movi(rn(reg), i0);
1960         CMPLW(r1, rn(reg));
1961         jit_unget_reg(reg);
1962     }
1963     MFCR(r0);
1964     EXTRWI(r0, r0, 1, CR_GT);
1965 }
1966
1967 static void
1968 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1969 {
1970     CMPX(r1, r2);
1971     CRNOT(CR_EQ, CR_EQ);
1972     MFCR(r0);
1973     EXTRWI(r0, r0, 1, CR_EQ);
1974 }
1975
1976 static void
1977 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1978 {
1979     jit_int32_t         reg;
1980     if (can_sign_extend_short_p(i0))
1981         CMPXI(r1, i0);
1982     else if (can_zero_extend_short_p(i0))
1983         CMPLWI(r1, i0);
1984     else {
1985         reg = jit_get_reg(jit_class_gpr);
1986         movi(rn(reg), i0);
1987         CMPX(r1, rn(reg));
1988         jit_unget_reg(reg);
1989     }
1990     CRNOT(CR_EQ, CR_EQ);
1991     MFCR(r0);
1992     EXTRWI(r0, r0, 1, CR_EQ);
1993 }
1994
1995 static jit_word_t
1996 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1997 {
1998     jit_word_t          d, w;
1999     CMPX(r0, r1);
2000     w = _jit->pc.w;
2001     d = (i0 - w) & ~3;
2002     BLT(d);
2003     return (w);
2004 }
2005
2006 static jit_word_t
2007 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2008 {
2009     jit_int32_t         reg;
2010     jit_word_t          d, w;
2011     if (can_sign_extend_short_p(i1))
2012         CMPXI(r0, i1);
2013     else {
2014         reg = jit_get_reg(jit_class_gpr);
2015         movi(rn(reg), i1);
2016         CMPX(r0, rn(reg));
2017         jit_unget_reg(reg);
2018     }
2019     w = _jit->pc.w;
2020     d = (i0 - w) & ~3;
2021     BLT(d);
2022     return (w);
2023 }
2024
2025 static jit_word_t
2026 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2027 {
2028     jit_word_t          d, w;
2029     CMPLW(r0, r1);
2030     w = _jit->pc.w;
2031     d = (i0 - w) & ~3;
2032     BLT(d);
2033     return (w);
2034 }
2035
2036 static jit_word_t
2037 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2038 {
2039     jit_int32_t         reg;
2040     jit_word_t          d, w;
2041     if (can_zero_extend_short_p(i1))
2042         CMPLWI(r0, i1);
2043     else {
2044         reg = jit_get_reg(jit_class_gpr);
2045         movi(rn(reg), i1);
2046         CMPLW(r0, rn(reg));
2047         jit_unget_reg(reg);
2048     }
2049     w = _jit->pc.w;
2050     d = (i0 - w) & ~3;
2051     BLT(d);
2052     return (w);
2053 }
2054
2055 static jit_word_t
2056 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2057 {
2058     jit_word_t          d, w;
2059     CMPX(r0, r1);
2060     w = _jit->pc.w;
2061     d = (i0 - w) & ~3;
2062     BLE(d);
2063     return (w);
2064 }
2065
2066 static jit_word_t
2067 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2068 {
2069     jit_int32_t         reg;
2070     jit_word_t          d, w;
2071     if (can_sign_extend_short_p(i1))
2072         CMPXI(r0, i1);
2073     else {
2074         reg = jit_get_reg(jit_class_gpr);
2075         movi(rn(reg), i1);
2076         CMPX(r0, rn(reg));
2077         jit_unget_reg(reg);
2078     }
2079     w = _jit->pc.w;
2080     d = (i0 - w) & ~3;
2081     BLE(d);
2082     return (w);
2083 }
2084
2085 static jit_word_t
2086 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2087 {
2088     jit_word_t          d, w;
2089     CMPLW(r0, r1);
2090     w = _jit->pc.w;
2091     d = (i0 - w) & ~3;
2092     BLE(d);
2093     return (w);
2094 }
2095
2096 static jit_word_t
2097 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2098 {
2099     jit_int32_t         reg;
2100     jit_word_t          d, w;
2101     if (can_zero_extend_short_p(i1))
2102         CMPLWI(r0, i1);
2103     else {
2104         reg = jit_get_reg(jit_class_gpr);
2105         movi(rn(reg), i1);
2106         CMPLW(r0, rn(reg));
2107         jit_unget_reg(reg);
2108     }
2109     w = _jit->pc.w;
2110     d = (i0 - w) & ~3;
2111     BLE(d);
2112     return (w);
2113 }
2114
2115 static jit_word_t
2116 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2117 {
2118     jit_word_t          d, w;
2119     CMPX(r0, r1);
2120     w = _jit->pc.w;
2121     d = (i0 - w) & ~3;
2122     BEQ(d);
2123     return (w);
2124 }
2125
2126 static jit_word_t
2127 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2128 {
2129     jit_int32_t         reg;
2130     jit_word_t          d, w;
2131     if (can_sign_extend_short_p(i1))
2132         CMPXI(r0, i1);
2133     else if (can_zero_extend_short_p(i1))
2134         CMPLWI(r0, i1);
2135     else {
2136         reg = jit_get_reg(jit_class_gpr);
2137         movi(rn(reg), i1);
2138         CMPX(r0, rn(reg));
2139         jit_unget_reg(reg);
2140     }
2141     w = _jit->pc.w;
2142     d = (i0 - w) & ~3;
2143     BEQ(d);
2144     return (w);
2145 }
2146
2147 static jit_word_t
2148 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2149 {
2150     jit_word_t          d, w;
2151     CMPX(r0, r1);
2152     w = _jit->pc.w;
2153     d = (i0 - w) & ~3;
2154     BGE(d);
2155     return (w);
2156 }
2157
2158 static jit_word_t
2159 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2160 {
2161     jit_int32_t         reg;
2162     jit_word_t          d, w;
2163     if (can_sign_extend_short_p(i1))
2164         CMPXI(r0, i1);
2165     else {
2166         reg = jit_get_reg(jit_class_gpr);
2167         movi(rn(reg), i1);
2168         CMPX(r0, rn(reg));
2169         jit_unget_reg(reg);
2170     }
2171     w = _jit->pc.w;
2172     d = (i0 - w) & ~3;
2173     BGE(d);
2174     return (w);
2175 }
2176
2177 static jit_word_t
2178 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2179 {
2180     jit_word_t          d, w;
2181     CMPLW(r0, r1);
2182     w = _jit->pc.w;
2183     d = (i0 - w) & ~3;
2184     BGE(d);
2185     return (w);
2186 }
2187
2188 static jit_word_t
2189 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2190 {
2191     jit_int32_t         reg;
2192     jit_word_t          d, w;
2193     if (can_zero_extend_short_p(i1))
2194         CMPLWI(r0, i1);
2195     else {
2196         reg = jit_get_reg(jit_class_gpr);
2197         movi(rn(reg), i1);
2198         CMPLW(r0, rn(reg));
2199         jit_unget_reg(reg);
2200     }
2201     w = _jit->pc.w;
2202     d = (i0 - w) & ~3;
2203     BGE(d);
2204     return (w);
2205 }
2206
2207 static jit_word_t
2208 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2209 {
2210     jit_word_t          d, w;
2211     CMPX(r0, r1);
2212     w = _jit->pc.w;
2213     d = (i0 - w) & ~3;
2214     BGT(d);
2215     return (w);
2216 }
2217
2218 static jit_word_t
2219 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2220 {
2221     jit_int32_t         reg;
2222     jit_word_t          d, w;
2223     if (can_sign_extend_short_p(i1))
2224         CMPXI(r0, i1);
2225     else {
2226         reg = jit_get_reg(jit_class_gpr);
2227         movi(rn(reg), i1);
2228         CMPX(r0, rn(reg));
2229         jit_unget_reg(reg);
2230     }
2231     w = _jit->pc.w;
2232     d = (i0 - w) & ~3;
2233     BGT(d);
2234     return (w);
2235 }
2236
2237 static jit_word_t
2238 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2239 {
2240     jit_word_t          d, w;
2241     CMPLW(r0, r1);
2242     w = _jit->pc.w;
2243     d = (i0 - w) & ~3;
2244     BGT(d);
2245     return (w);
2246 }
2247
2248 static jit_word_t
2249 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2250 {
2251     jit_int32_t         reg;
2252     jit_word_t          d, w;
2253     if (can_zero_extend_short_p(i1))
2254         CMPLWI(r0, i1);
2255     else {
2256         reg = jit_get_reg(jit_class_gpr);
2257         movi(rn(reg), i1);
2258         CMPLW(r0, rn(reg));
2259         jit_unget_reg(reg);
2260     }
2261     w = _jit->pc.w;
2262     d = (i0 - w) & ~3;
2263     BGT(d);
2264     return (w);
2265 }
2266
2267 static jit_word_t
2268 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2269 {
2270     jit_word_t          d, w;
2271     CMPX(r0, r1);
2272     w = _jit->pc.w;
2273     d = (i0 - w) & ~3;
2274     BNE(d);
2275     return (w);
2276 }
2277
2278 static jit_word_t
2279 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2280 {
2281     jit_int32_t         reg;
2282     jit_word_t          d, w;
2283     if (can_sign_extend_short_p(i1))
2284         CMPXI(r0, i1);
2285     else if (can_zero_extend_short_p(i1))
2286         CMPLWI(r0, i1);
2287     else {
2288         reg = jit_get_reg(jit_class_gpr);
2289         movi(rn(reg), i1);
2290         CMPX(r0, rn(reg));
2291         jit_unget_reg(reg);
2292     }
2293     w = _jit->pc.w;
2294     d = (i0 - w) & ~3;
2295     BNE(d);
2296     return (w);
2297 }
2298
2299 static jit_word_t
2300 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2301 {
2302     jit_word_t          w;
2303     jit_int32_t         reg;
2304     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2305     andr(rn(reg), r0, r1);
2306     w = bnei(i0, rn(reg), 0);
2307     jit_unget_reg(reg);
2308     return (w);
2309 }
2310
2311 static jit_word_t
2312 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2313 {
2314     jit_word_t          w;
2315     jit_int32_t         reg;
2316     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2317     andi(rn(reg), r0, i1);
2318     w = bnei(i0, rn(reg), 0);
2319     jit_unget_reg(reg);
2320     return (w);
2321 }
2322
2323 static jit_word_t
2324 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2325 {
2326     jit_word_t          w;
2327     jit_int32_t         reg;
2328     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2329     andr(rn(reg), r0, r1);
2330     w = beqi(i0, rn(reg), 0);
2331     jit_unget_reg(reg);
2332     return (w);
2333 }
2334
2335 static jit_word_t
2336 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2337 {
2338     jit_word_t          w;
2339     jit_int32_t         reg;
2340     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2341     andi(rn(reg), r0, i1);
2342     w = beqi(i0, rn(reg), 0);
2343     jit_unget_reg(reg);
2344     return (w);
2345 }
2346
2347 static jit_word_t
2348 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2349 {
2350     jit_word_t          d, w;
2351     ADDO(r0, r0, r1);
2352     MCRXR(CR_0);
2353     w = _jit->pc.w;
2354     d = (i0 - w) & ~3;
2355     BGT(d);                             /* GT = bit 1 of XER = OV */
2356     return (w);
2357 }
2358
2359 static jit_word_t
2360 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2361 {
2362     jit_word_t          w;
2363     jit_int32_t         reg;
2364     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2365     movi(rn(reg), i1);
2366     w = boaddr(i0, r0, rn(reg));
2367     jit_unget_reg(reg);
2368     return (w);
2369 }
2370
2371 static jit_word_t
2372 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2373 {
2374     jit_word_t          d, w;
2375     ADDO(r0, r0, r1);
2376     MCRXR(CR_0);
2377     w = _jit->pc.w;
2378     d = (i0 - w) & ~3;
2379     BLE(d);
2380     return (w);
2381 }
2382
2383 static jit_word_t
2384 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2385 {
2386     jit_word_t          w;
2387     jit_int32_t         reg;
2388     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2389     movi(rn(reg), i1);
2390     w = bxaddr(i0, r0, rn(reg));
2391     jit_unget_reg(reg);
2392     return (w);
2393 }
2394
2395 static jit_word_t
2396 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2397 {
2398     jit_word_t          d, w;
2399     SUBO(r0, r0, r1);
2400     MCRXR(CR_0);
2401     w = _jit->pc.w;
2402     d = (i0 - w) & ~3;
2403     BGT(d);
2404     return (w);
2405 }
2406
2407 static jit_word_t
2408 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2409 {
2410     jit_word_t          w;
2411     jit_int32_t         reg;
2412     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2413     movi(rn(reg), i1);
2414     w = bosubr(i0, r0, rn(reg));
2415     jit_unget_reg(reg);
2416     return (w);
2417 }
2418
2419 static jit_word_t
2420 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2421 {
2422     jit_word_t          d, w;
2423     SUBO(r0, r0, r1);
2424     MCRXR(CR_0);
2425     w = _jit->pc.w;
2426     d = (i0 - w) & ~3;
2427     BLE(d);
2428     return (w);
2429 }
2430
2431 static jit_word_t
2432 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2433 {
2434     jit_word_t          w;
2435     jit_int32_t         reg;
2436     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2437     movi(rn(reg), i1);
2438     w = bxsubr(i0, r0, rn(reg));
2439     jit_unget_reg(reg);
2440     return (w);
2441 }
2442
2443 static jit_word_t
2444 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2445 {
2446     jit_word_t          d, w;
2447     ADDC(r0, r0, r1);
2448     MCRXR(CR_0);
2449     w = _jit->pc.w;
2450     d = (i0 - w) & ~3;
2451     BEQ(d);                             /* EQ = bit 2 of XER = CA */
2452     return (w);
2453 }
2454
2455 static jit_word_t
2456 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2457 {
2458     jit_int32_t         reg;
2459     jit_word_t          d, w;
2460     if (can_sign_extend_short_p(i1)) {
2461         ADDIC(r0, r0, i1);
2462         MCRXR(CR_0);
2463         w = _jit->pc.w;
2464         d = (i0 - w) & ~3;
2465         BEQ(d);
2466         return (w);
2467     }
2468     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2469     movi(rn(reg), i1);
2470     w = boaddr_u(i0, r0, rn(reg));
2471     jit_unget_reg(reg);
2472     return (w);
2473 }
2474
2475 static jit_word_t
2476 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2477 {
2478     jit_word_t          d, w;
2479     ADDC(r0, r0, r1);
2480     MCRXR(CR_0);
2481     w = _jit->pc.w;
2482     d = (i0 - w) & ~3;
2483     BNE(d);
2484     return (w);
2485 }
2486
2487 static jit_word_t
2488 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2489 {
2490     jit_int32_t         reg;
2491     jit_word_t          d, w;
2492     if (can_sign_extend_short_p(i1)) {
2493         ADDIC(r0, r0, i1);
2494         MCRXR(CR_0);
2495         w = _jit->pc.w;
2496         d = (i0 - w) & ~3;
2497         BNE(d);
2498         return (w);
2499     }
2500     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2501     movi(rn(reg), i1);
2502     w = bxaddr_u(i0, r0, rn(reg));
2503     jit_unget_reg(reg);
2504     return (w);
2505 }
2506
2507 static jit_word_t
2508 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2509 {
2510     jit_word_t          d, w;
2511     SUBC(r0, r0, r1);
2512     MCRXR(CR_0);
2513     w = _jit->pc.w;
2514     d = (i0 - w) & ~3;
2515     BNE(d);                             /* PPC uses "carry" not "borrow" */
2516     return (w);
2517 }
2518
2519 static jit_word_t
2520 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2521 {
2522     jit_word_t          w;
2523     jit_int32_t         reg;
2524     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2525     movi(rn(reg), i1);
2526     w = bosubr_u(i0, r0, rn(reg));
2527     jit_unget_reg(reg);
2528     return (w);
2529 }
2530
2531 static jit_word_t
2532 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2533 {
2534     jit_word_t          d, w;
2535     SUBC(r0, r0, r1);
2536     MCRXR(CR_0);
2537     w = _jit->pc.w;
2538     d = (i0 - w) & ~3;
2539     BEQ(d);
2540     return (w);
2541 }
2542
2543 static jit_word_t
2544 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2545 {
2546     jit_word_t          w;
2547     jit_int32_t         reg;
2548     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2549     movi(rn(reg), i1);
2550     w = bxsubr_u(i0, r0, rn(reg));
2551     jit_unget_reg(reg);
2552     return (w);
2553 }
2554
2555 static void
2556 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2557 {
2558     ldr_uc(r0, r1);
2559     extr_c(r0, r0);
2560 }
2561
2562 static void
2563 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2564 {
2565     ldi_uc(r0, i0);
2566     extr_c(r0, r0);
2567 }
2568
2569 static void
2570 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2571 {
2572     ldxr_uc(r0, r1, r2);
2573     extr_c(r0, r0);
2574 }
2575
2576 static void
2577 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2578 {
2579     ldxi_uc(r0, r1, i0);
2580     extr_c(r0, r0);
2581 }
2582
2583 static void
2584 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2585 {
2586     jit_bool_t          inv;
2587     jit_int32_t         reg;
2588     jit_word_t          lo, hi;
2589     if (can_sign_extend_short_p(i0))
2590         LBZ(r0, _R0_REGNO, i0);
2591     else if (can_sign_extend_int_p(i0)) {
2592         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2593         lo = (jit_int16_t)(i0 - (hi << 16));
2594         reg = jit_get_reg(jit_class_gpr);
2595         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2596         LIS(rn(reg), hi);
2597         LBZ(r0, rn(reg), lo);
2598         jit_unget_reg(reg);
2599         if (inv)                        jit_unget_reg(_R0);
2600     }
2601     else {
2602         reg = jit_get_reg(jit_class_gpr);
2603         movi(rn(reg), i0);
2604         ldr_uc(r0, rn(reg));
2605         jit_unget_reg(reg);
2606     }
2607 }
2608
2609 static void
2610 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2611 {
2612     jit_int32_t         reg;
2613     if (r1 == _R0_REGNO) {
2614         if (r2 != _R0_REGNO)
2615             LBZX(r0, r2, r1);
2616         else {
2617             reg = jit_get_reg(jit_class_gpr);
2618             movr(rn(reg), r1);
2619             LBZX(r0, rn(reg), r2);
2620             jit_unget_reg(reg);
2621         }
2622     }
2623     else
2624         LBZX(r0, r1, r2);
2625 }
2626
2627 static void
2628 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2629 {
2630     jit_int32_t         reg;
2631     if (i0 == 0)
2632         ldr_uc(r0, r1);
2633     else if (can_sign_extend_short_p(i0)) {
2634         if (r1 == _R0_REGNO) {
2635             reg = jit_get_reg(jit_class_gpr);
2636             movr(rn(reg), r1);
2637             LBZ(r0, rn(reg), i0);
2638             jit_unget_reg(reg);
2639         }
2640         else
2641             LBZ(r0, r1, i0);
2642     }
2643     else {
2644         reg = jit_get_reg(jit_class_gpr);
2645         movi(rn(reg), i0);
2646         ldxr_uc(r0, r1, rn(reg));
2647         jit_unget_reg(reg);
2648     }
2649 }
2650
2651 static void
2652 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2653 {
2654     jit_bool_t          inv;
2655     jit_int32_t         reg;
2656     jit_word_t          lo, hi;
2657     if (can_sign_extend_short_p(i0))
2658         LHA(r0, _R0_REGNO, i0);
2659     else if (can_sign_extend_int_p(i0)) {
2660         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2661         lo = (jit_int16_t)(i0 - (hi << 16));
2662         reg = jit_get_reg(jit_class_gpr);
2663         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2664         LIS(rn(reg), hi);
2665         LHA(r0, rn(reg), lo);
2666         jit_unget_reg(reg);
2667         if (inv)                        jit_unget_reg(_R0);
2668     }
2669     else {
2670         reg = jit_get_reg(jit_class_gpr);
2671         movi(rn(reg), i0);
2672         ldr_s(r0, rn(reg));
2673         jit_unget_reg(reg);
2674     }
2675 }
2676
2677 static void
2678 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2679 {
2680     jit_int32_t         reg;
2681     if (r1 == _R0_REGNO) {
2682         if (r2 != _R0_REGNO)
2683             LHAX(r0, r2, r1);
2684         else {
2685             reg = jit_get_reg(jit_class_gpr);
2686             movr(rn(reg), r1);
2687             LHAX(r0, rn(reg), r2);
2688             jit_unget_reg(reg);
2689         }
2690     }
2691     else
2692         LHAX(r0, r1, r2);
2693 }
2694
2695 static void
2696 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2697 {
2698     jit_int32_t         reg;
2699     if (i0 == 0)
2700         ldr_s(r0, r1);
2701     else if (can_sign_extend_short_p(i0)) {
2702         if (r1 == _R0_REGNO) {
2703             reg = jit_get_reg(jit_class_gpr);
2704             movr(rn(reg), r1);
2705             LHA(r0, rn(reg), i0);
2706             jit_unget_reg(reg);
2707         }
2708         else
2709             LHA(r0, r1, i0);
2710     }
2711     else {
2712         reg = jit_get_reg(jit_class_gpr);
2713         movi(rn(reg), i0);
2714         ldxr_s(r0, r1, rn(reg));
2715         jit_unget_reg(reg);
2716     }
2717 }
2718
2719 static void
2720 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2721 {
2722     jit_bool_t          inv;
2723     jit_int32_t         reg;
2724     jit_word_t          lo, hi;
2725     if (can_sign_extend_short_p(i0))
2726         LHZ(r0, _R0_REGNO, i0);
2727     else if (can_sign_extend_int_p(i0)) {
2728         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2729         lo = (jit_int16_t)(i0 - (hi << 16));
2730         reg = jit_get_reg(jit_class_gpr);
2731         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2732         LIS(rn(reg), hi);
2733         LHZ(r0, rn(reg), lo);
2734         jit_unget_reg(reg);
2735         if (inv)                        jit_unget_reg(_R0);
2736     }
2737     else {
2738         reg = jit_get_reg(jit_class_gpr);
2739         movi(rn(reg), i0);
2740         ldr_us(r0, rn(reg));
2741         jit_unget_reg(reg);
2742     }
2743 }
2744
2745 static void
2746 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2747 {
2748     jit_int32_t         reg;
2749     if (r1 == _R0_REGNO) {
2750         if (r2 != _R0_REGNO)
2751             LHZX(r0, r2, r1);
2752         else {
2753             reg = jit_get_reg(jit_class_gpr);
2754             movr(rn(reg), r1);
2755             LHZX(r0, rn(reg), r2);
2756             jit_unget_reg(reg);
2757         }
2758     }
2759     else
2760         LHZX(r0, r1, r2);
2761 }
2762
2763 static void
2764 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2765 {
2766     jit_int32_t         reg;
2767     if (i0 == 0)
2768         ldr_us(r0, r1);
2769     else if (can_sign_extend_short_p(i0)) {
2770         if (r1 == _R0_REGNO) {
2771             reg = jit_get_reg(jit_class_gpr);
2772             movr(rn(reg), r1);
2773             LHZ(r0, rn(reg), i0);
2774             jit_unget_reg(reg);
2775         }
2776         else
2777             LHZ(r0, r1, i0);
2778     }
2779     else {
2780         reg = jit_get_reg(jit_class_gpr);
2781         movi(rn(reg), i0);
2782         ldxr_us(r0, r1, rn(reg));
2783         jit_unget_reg(reg);
2784     }
2785 }
2786
2787 #  if __WORDSIZE == 32
2788 static void
2789 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2790 {
2791     jit_bool_t          inv;
2792     jit_int32_t         reg;
2793     jit_word_t          lo, hi;
2794     if (can_sign_extend_short_p(i0))
2795         LWZ(r0, _R0_REGNO, i0);
2796     else if (can_sign_extend_int_p(i0)) {
2797         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2798         lo = (jit_int16_t)(i0 - (hi << 16));
2799         reg = jit_get_reg(jit_class_gpr);
2800         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2801         LIS(rn(reg), hi);
2802         LWZ(r0, rn(reg), lo);
2803         jit_unget_reg(reg);
2804         if (inv)                        jit_unget_reg(_R0);
2805     }
2806     else {
2807         reg = jit_get_reg(jit_class_gpr);
2808         movi(rn(reg), i0);
2809         ldr_i(r0, rn(reg));
2810         jit_unget_reg(reg);
2811     }
2812 }
2813
2814 static void
2815 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2816 {
2817     jit_int32_t         reg;
2818     if (r1 == _R0_REGNO) {
2819         if (r2 != _R0_REGNO)
2820             LWZX(r0, r2, r1);
2821         else {
2822             reg = jit_get_reg(jit_class_gpr);
2823             movr(rn(reg), r1);
2824             LWZX(r0, rn(reg), r2);
2825             jit_unget_reg(reg);
2826         }
2827     }
2828     else
2829         LWZX(r0, r1, r2);
2830 }
2831
2832 static void
2833 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2834 {
2835     jit_int32_t         reg;
2836     if (i0 == 0)
2837         ldr_i(r0, r1);
2838     else if (can_sign_extend_short_p(i0)) {
2839         if (r1 == _R0_REGNO) {
2840             reg = jit_get_reg(jit_class_gpr);
2841             movr(rn(reg), r1);
2842             LWZ(r0, rn(reg), i0);
2843             jit_unget_reg(reg);
2844         }
2845         else
2846             LWZ(r0, r1, i0);
2847     }
2848     else {
2849         reg = jit_get_reg(jit_class_gpr);
2850         movi(rn(reg), i0);
2851         ldxr_i(r0, r1, rn(reg));
2852         jit_unget_reg(reg);
2853     }
2854 }
2855
2856 #  else
2857 static void
2858 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2859 {
2860     jit_bool_t          inv;
2861     jit_int32_t         reg;
2862     jit_word_t          lo, hi;
2863     if (can_sign_extend_short_p(i0))
2864         LWA(r0, _R0_REGNO, i0);
2865     else if (can_sign_extend_int_p(i0)) {
2866         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2867         lo = (jit_int16_t)(i0 - (hi << 16));
2868         reg = jit_get_reg(jit_class_gpr);
2869         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2870         LIS(rn(reg), hi);
2871         LWA(r0, rn(reg), lo);
2872         jit_unget_reg(reg);
2873         if (inv)                        jit_unget_reg(_R0);
2874     }
2875     else {
2876         reg = jit_get_reg(jit_class_gpr);
2877         movi(rn(reg), i0);
2878         ldr_i(r0, rn(reg));
2879         jit_unget_reg(reg);
2880     }
2881 }
2882
2883 static void
2884 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2885 {
2886     jit_int32_t         reg;
2887     if (r1 == _R0_REGNO) {
2888         if (r2 != _R0_REGNO)
2889             LWAX(r0, r2, r1);
2890         else {
2891             reg = jit_get_reg(jit_class_gpr);
2892             movr(rn(reg), r1);
2893             LWAX(r0, rn(reg), r2);
2894             jit_unget_reg(reg);
2895         }
2896     }
2897     else
2898         LWAX(r0, r1, r2);
2899 }
2900
2901 static void
2902 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2903 {
2904     jit_int32_t         reg;
2905     if (i0 == 0)
2906         ldr_i(r0, r1);
2907     else if (can_sign_extend_short_p(i0)) {
2908         if (r1 == _R0_REGNO) {
2909             reg = jit_get_reg(jit_class_gpr);
2910             movr(rn(reg), r1);
2911             LWA(r0, rn(reg), i0);
2912             jit_unget_reg(reg);
2913         }
2914         else
2915             LWA(r0, r1, i0);
2916     }
2917     else {
2918         reg = jit_get_reg(jit_class_gpr);
2919         movi(rn(reg), i0);
2920         ldxr_i(r0, r1, rn(reg));
2921         jit_unget_reg(reg);
2922     }
2923 }
2924
2925 static void
2926 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2927 {
2928     jit_bool_t          inv;
2929     jit_int32_t         reg;
2930     jit_word_t          lo, hi;
2931     if (can_sign_extend_short_p(i0))
2932         LWZ(r0, _R0_REGNO, i0);
2933     else if (can_sign_extend_int_p(i0)) {
2934         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2935         lo = (jit_int16_t)(i0 - (hi << 16));
2936         reg = jit_get_reg(jit_class_gpr);
2937         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2938         LIS(rn(reg), hi);
2939         LWZ(r0, rn(reg), lo);
2940         jit_unget_reg(reg);
2941         if (inv)                        jit_unget_reg(_R0);
2942     }
2943     else {
2944         reg = jit_get_reg(jit_class_gpr);
2945         movi(rn(reg), i0);
2946         ldr_ui(r0, rn(reg));
2947         jit_unget_reg(reg);
2948     }
2949 }
2950
2951 static void
2952 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2953 {
2954     jit_int32_t         reg;
2955     if (r1 == _R0_REGNO) {
2956         if (r2 != _R0_REGNO)
2957             LWZX(r0, r2, r1);
2958         else {
2959             reg = jit_get_reg(jit_class_gpr);
2960             movr(rn(reg), r1);
2961             LWZX(r0, rn(reg), r2);
2962             jit_unget_reg(reg);
2963         }
2964     }
2965     else
2966         LWZX(r0, r1, r2);
2967 }
2968
2969 static void
2970 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2971 {
2972     jit_int32_t         reg;
2973     if (i0 == 0)
2974         ldr_i(r0, r1);
2975     else if (can_sign_extend_short_p(i0)) {
2976         if (r1 == _R0_REGNO) {
2977             reg = jit_get_reg(jit_class_gpr);
2978             movr(rn(reg), r1);
2979             LWZ(r0, rn(reg), i0);
2980             jit_unget_reg(reg);
2981         }
2982         else
2983             LWZ(r0, r1, i0);
2984     }
2985     else {
2986         reg = jit_get_reg(jit_class_gpr);
2987         movi(rn(reg), i0);
2988         ldxr_ui(r0, r1, rn(reg));
2989         jit_unget_reg(reg);
2990     }
2991 }
2992
2993 static void
2994 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2995 {
2996     jit_bool_t          inv;
2997     jit_int32_t         reg;
2998     jit_word_t          lo, hi;
2999     if (can_sign_extend_short_p(i0))
3000         LD(r0, _R0_REGNO, i0);
3001     else if (can_sign_extend_int_p(i0)) {
3002         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3003         lo = (jit_int16_t)(i0 - (hi << 16));
3004         reg = jit_get_reg(jit_class_gpr);
3005         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
3006         LIS(rn(reg), hi);
3007         LD(r0, rn(reg), lo);
3008         jit_unget_reg(reg);
3009         if (inv)                        jit_unget_reg(_R0);
3010     }
3011     else {
3012         reg = jit_get_reg(jit_class_gpr);
3013         movi(rn(reg), i0);
3014         ldr_l(r0, rn(reg));
3015         jit_unget_reg(reg);
3016     }
3017 }
3018
3019 static void
3020 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3021 {
3022     jit_int32_t         reg;
3023     if (r1 == _R0_REGNO) {
3024         if (r2 != _R0_REGNO)
3025             LDX(r0, r2, r1);
3026         else {
3027             reg = jit_get_reg(jit_class_gpr);
3028             movr(rn(reg), r1);
3029             LDX(r0, rn(reg), r2);
3030             jit_unget_reg(reg);
3031         }
3032     }
3033     else
3034         LDX(r0, r1, r2);
3035 }
3036
3037 static void
3038 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3039 {
3040     jit_int32_t         reg;
3041     if (i0 == 0)
3042         ldr_l(r0, r1);
3043     else if (can_sign_extend_short_p(i0)) {
3044         if (r1 == _R0_REGNO) {
3045             reg = jit_get_reg(jit_class_gpr);
3046             movr(rn(reg), r1);
3047             LD(r0, rn(reg), i0);
3048             jit_unget_reg(reg);
3049         }
3050         else
3051             LD(r0, r1, i0);
3052     }
3053     else {
3054         reg = jit_get_reg(jit_class_gpr);
3055         movi(rn(reg), i0);
3056         ldxr_l(r0, r1, rn(reg));
3057         jit_unget_reg(reg);
3058     }
3059 }
3060 #  endif
3061
3062 static void
3063 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3064 {
3065     jit_bool_t          inv;
3066     jit_int32_t         reg;
3067     jit_word_t          lo, hi;
3068     if (can_sign_extend_short_p(i0))
3069         STB(r0, _R0_REGNO, i0);
3070     else if (can_sign_extend_int_p(i0)) {
3071         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3072         lo = (jit_int16_t)(i0 - (hi << 16));
3073         reg = jit_get_reg(jit_class_gpr);
3074         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
3075         LIS(rn(reg), hi);
3076         STB(r0, rn(reg), lo);
3077         jit_unget_reg(reg);
3078         if (inv)                        jit_unget_reg(_R0);
3079     }
3080     else {
3081         reg = jit_get_reg(jit_class_gpr);
3082         movi(rn(reg), i0);
3083         str_c(rn(reg), r0);
3084         jit_unget_reg(reg);
3085     }
3086 }
3087
3088 static void
3089 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3090 {
3091     jit_int32_t         reg;
3092     if (r0 == _R0_REGNO) {
3093         if (r1 != _R0_REGNO)
3094             STBX(r2, r1, r0);
3095         else {
3096             reg = jit_get_reg(jit_class_gpr);
3097             movr(rn(reg), r0);
3098             STBX(r2, rn(reg), r1);
3099             jit_unget_reg(reg);
3100         }
3101     }
3102     else
3103         STBX(r2, r0, r1);
3104 }
3105
3106 static void
3107 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3108 {
3109     jit_int32_t         reg;
3110     if (i0 == 0)
3111         str_c(r0, r1);
3112     else if (can_sign_extend_short_p(i0)) {
3113         if (r0 == _R0_REGNO) {
3114             reg = jit_get_reg(jit_class_gpr);
3115             movr(rn(reg), i0);
3116             STB(r1, rn(reg), i0);
3117             jit_unget_reg(reg);
3118         }
3119         else
3120             STB(r1, r0, i0);
3121     }
3122     else {
3123         reg = jit_get_reg(jit_class_gpr);
3124         movi(rn(reg), i0);
3125         stxr_c(rn(reg), r0, r1);
3126         jit_unget_reg(reg);
3127     }
3128 }
3129
3130 static void
3131 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3132 {
3133     jit_bool_t          inv;
3134     jit_int32_t         reg;
3135     jit_word_t          lo, hi;
3136     if (can_sign_extend_short_p(i0))
3137         STH(r0, _R0_REGNO, i0);
3138     else if (can_sign_extend_int_p(i0)) {
3139         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3140         lo = (jit_int16_t)(i0 - (hi << 16));
3141         reg = jit_get_reg(jit_class_gpr);
3142         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
3143         LIS(rn(reg), hi);
3144         STH(r0, rn(reg), lo);
3145         jit_unget_reg(reg);
3146         if (inv)                        jit_unget_reg(_R0);
3147     }
3148     else {
3149         reg = jit_get_reg(jit_class_gpr);
3150         movi(rn(reg), i0);
3151         str_s(rn(reg), r0);
3152         jit_unget_reg(reg);
3153     }
3154 }
3155
3156 static void
3157 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3158 {
3159     jit_int32_t         reg;
3160     if (r0 == _R0_REGNO) {
3161         if (r1 != _R0_REGNO)
3162             STHX(r2, r1, r0);
3163         else {
3164             reg = jit_get_reg(jit_class_gpr);
3165             movr(rn(reg), r0);
3166             STHX(r2, rn(reg), r1);
3167             jit_unget_reg(reg);
3168         }
3169     }
3170     else
3171         STHX(r2, r0, r1);
3172 }
3173
3174 static void
3175 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3176 {
3177     jit_int32_t         reg;
3178     if (i0 == 0)
3179         str_s(r0, r1);
3180     else if (can_sign_extend_short_p(i0)) {
3181         if (r0 == _R0_REGNO) {
3182             reg = jit_get_reg(jit_class_gpr);
3183             movr(rn(reg), i0);
3184             STH(r1, rn(reg), i0);
3185             jit_unget_reg(reg);
3186         }
3187         else
3188             STH(r1, r0, i0);
3189     }
3190     else {
3191         reg = jit_get_reg(jit_class_gpr);
3192         movi(rn(reg), i0);
3193         stxr_s(rn(reg), r0, r1);
3194         jit_unget_reg(reg);
3195     }
3196 }
3197
3198 static void
3199 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3200 {
3201     jit_bool_t          inv;
3202     jit_int32_t         reg;
3203     jit_word_t          lo, hi;
3204     if (can_sign_extend_short_p(i0))
3205         STW(r0, _R0_REGNO, i0);
3206     else if (can_sign_extend_int_p(i0)) {
3207         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3208         lo = (jit_int16_t)(i0 - (hi << 16));
3209         reg = jit_get_reg(jit_class_gpr);
3210         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
3211         LIS(rn(reg), hi);
3212         STW(r0, rn(reg), lo);
3213         jit_unget_reg(reg);
3214         if (inv)                        jit_unget_reg(_R0);
3215     }
3216     else {
3217         reg = jit_get_reg(jit_class_gpr);
3218         movi(rn(reg), i0);
3219         str_i(rn(reg), r0);
3220         jit_unget_reg(reg);
3221     }
3222 }
3223
3224 static void
3225 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3226 {
3227     jit_int32_t         reg;
3228     if (r0 == _R0_REGNO) {
3229         if (r1 != _R0_REGNO)
3230             STWX(r2, r1, r0);
3231         else {
3232             reg = jit_get_reg(jit_class_gpr);
3233             movr(rn(reg), r0);
3234             STWX(r2, rn(reg), r1);
3235             jit_unget_reg(reg);
3236         }
3237     }
3238     else
3239         STWX(r2, r0, r1);
3240 }
3241
3242 static void
3243 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3244 {
3245     jit_int32_t         reg;
3246     if (i0 == 0)
3247         str_i(r0, r1);
3248     else if (can_sign_extend_short_p(i0)) {
3249         if (r0 == _R0_REGNO) {
3250             reg = jit_get_reg(jit_class_gpr);
3251             movr(rn(reg), i0);
3252             STW(r1, rn(reg), i0);
3253             jit_unget_reg(reg);
3254         }
3255         else
3256             STW(r1, r0, i0);
3257     }
3258     else {
3259         reg = jit_get_reg(jit_class_gpr);
3260         movi(rn(reg), i0);
3261         stxr_i(rn(reg), r0, r1);
3262         jit_unget_reg(reg);
3263     }
3264 }
3265
3266 #  if __WORDSIZE == 64
3267 static void
3268 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3269 {
3270     jit_bool_t          inv;
3271     jit_int32_t         reg;
3272     jit_word_t          lo, hi;
3273     if (can_sign_extend_short_p(i0))
3274         STD(r0, _R0_REGNO, i0);
3275     else if (can_sign_extend_int_p(i0)) {
3276         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3277         lo = (jit_int16_t)(i0 - (hi << 16));
3278         reg = jit_get_reg(jit_class_gpr);
3279         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
3280         LIS(rn(reg), hi);
3281         STD(r0, rn(reg), lo);
3282         jit_unget_reg(reg);
3283         if (inv)                        jit_unget_reg(_R0);
3284     }
3285     else {
3286         reg = jit_get_reg(jit_class_gpr);
3287         movi(rn(reg), i0);
3288         str_l(rn(reg), r0);
3289         jit_unget_reg(reg);
3290     }
3291 }
3292
3293 static void
3294 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3295 {
3296     jit_int32_t         reg;
3297     if (r0 == _R0_REGNO) {
3298         if (r1 != _R0_REGNO)
3299             STDX(r2, r1, r0);
3300         else {
3301             reg = jit_get_reg(jit_class_gpr);
3302             movr(rn(reg), r0);
3303             STDX(r2, rn(reg), r1);
3304             jit_unget_reg(reg);
3305         }
3306     }
3307     else
3308         STDX(r2, r0, r1);
3309 }
3310
3311 static void
3312 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3313 {
3314     jit_int32_t         reg;
3315     if (i0 == 0)
3316         str_l(r0, r1);
3317     else if (can_sign_extend_short_p(i0)) {
3318         if (r0 == _R0_REGNO) {
3319             reg = jit_get_reg(jit_class_gpr);
3320             movr(rn(reg), i0);
3321             STD(r1, rn(reg), i0);
3322             jit_unget_reg(reg);
3323         }
3324         else
3325             STD(r1, r0, i0);
3326     }
3327     else {
3328         reg = jit_get_reg(jit_class_gpr);
3329         movi(rn(reg), i0);
3330         stxr_l(rn(reg), r0, r1);
3331         jit_unget_reg(reg);
3332     }
3333 }
3334 #  endif
3335
3336 static void
3337 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3338 {
3339 #if 0
3340     MTLR(r0);
3341     BLR();
3342 #else
3343     MTCTR(r0);
3344     BCTR();
3345 #endif
3346 }
3347
3348 /* pc relative jump */
3349 static jit_word_t
3350 _jmpi(jit_state_t *_jit, jit_word_t i0)
3351 {
3352     jit_int32_t         reg;
3353     jit_word_t          w, d;
3354     w = _jit->pc.w;
3355     d = (i0 - w) & ~3;
3356     if (can_sign_extend_jump_p(d))
3357         B(d);
3358     else {
3359         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3360         w = movi_p(rn(reg), i0);
3361         jmpr(rn(reg));
3362         jit_unget_reg(reg);
3363     }
3364     return (w);
3365 }
3366
3367 /* absolute jump */
3368 static jit_word_t
3369 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3370 {
3371     jit_word_t          w;
3372     jit_int32_t         reg;
3373     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3374     w = movi_p(rn(reg), i0);
3375     jmpr(rn(reg));
3376     jit_unget_reg(reg);
3377     return (w);
3378 }
3379
3380 static void
3381 _callr(jit_state_t *_jit, jit_int32_t r0
3382 #  if _CALL_SYSV
3383        , jit_int32_t varargs
3384 #  endif
3385        )
3386 {
3387 #  if _CALL_AIXDESC
3388     stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3389     /* FIXME Pretend to not know about r11? */
3390     if (r0 == _R0_REGNO) {
3391         movr(_R11_REGNO, _R0_REGNO);
3392         ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3393         ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3394     }
3395     else {
3396         ldxi(_R2_REGNO, r0, sizeof(void*));
3397         ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3398     }
3399     ldr(r0, r0);
3400 #  else
3401 #    if _CALL_SYSV
3402     /* Tell double arguments were passed in registers. */
3403     if (varargs)
3404         CREQV(6, 6, 6);
3405 #    endif
3406     movr(_R12_REGNO, r0);
3407 #  endif
3408
3409     MTCTR(r0);
3410     BCTRL();
3411
3412 #  if _CALL_AIXDESC
3413     ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3414 #  endif
3415 }
3416
3417 /* assume fixed address or reachable address */
3418 static jit_word_t
3419 _calli(jit_state_t *_jit, jit_word_t i0
3420 #  if _CALL_SYSV
3421        , jit_int32_t varargs
3422 #  endif
3423        )
3424 {
3425     jit_word_t          w;
3426 #  if _CALL_SYSV
3427     jit_word_t          d;
3428     d = (i0 - _jit->pc.w - !!varargs * 4) & ~3;
3429     if (can_sign_extend_jump_p(d)) {
3430         /* Tell double arguments were passed in registers. */
3431         if (varargs)
3432             CREQV(6, 6, 6);
3433         w = _jit->pc.w;
3434         BL(d);
3435     }
3436     else
3437 #  endif
3438     {
3439         w = _jit->pc.w;
3440         movi(_R12_REGNO, i0);
3441         callr(_R12_REGNO
3442 #  if _CALL_SYSV
3443               , varargs
3444 #  endif
3445               );
3446     }
3447     return (w);
3448 }
3449
3450 /* absolute jump */
3451 static jit_word_t
3452 _calli_p(jit_state_t *_jit, jit_word_t i0
3453 #  if _CALL_SYSV
3454        , jit_int32_t varargs
3455 #  endif
3456          )
3457 {
3458     jit_word_t          w;
3459     w = movi_p(_R12_REGNO, i0);
3460     callr(_R12_REGNO
3461 #  if _CALL_SYSV
3462           , varargs
3463 #  endif
3464           );
3465     return (w);
3466 }
3467
3468 /* order is not guaranteed to be sequential */
3469 static jit_int32_t save[] = {
3470     _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3471     _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3472 };
3473
3474 static void
3475 _prolog(jit_state_t *_jit, jit_node_t *node)
3476 {
3477     unsigned long       regno;
3478     jit_word_t          offset;
3479
3480     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3481         jit_int32_t     frame = -_jitc->function->frame;
3482         assert(_jitc->function->self.aoff >= frame);
3483         if (_jitc->function->assume_frame)
3484             return;
3485         _jitc->function->self.aoff = frame;
3486     }
3487     if (_jitc->function->allocar) {
3488         _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3489         _jitc->function->self.aoff &= -16;
3490     }
3491     _jitc->function->stack = ((_jitc->function->self.alen +
3492                               _jitc->function->self.size -
3493                               _jitc->function->self.aoff) + 15) & -16;
3494
3495     /* return address */
3496     MFLR(_R0_REGNO);
3497
3498     /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3499      * alloca <  %r31-80 */
3500
3501 #if _CALL_SYSV
3502     stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3503 #else
3504     stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3505 #endif
3506     offset = -gpr_save_area;
3507     for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3508         if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3509             stxi(offset, _SP_REGNO, rn(save[regno]));
3510     }
3511     for (offset = 0; offset < 8; offset++) {
3512         if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3513             stxi_d(-(gpr_save_area + 8 + offset * 8),
3514                    _SP_REGNO, rn(_F14 + offset));
3515     }
3516
3517     stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3518
3519     movr(_FP_REGNO, _SP_REGNO);
3520 #if __WORDSIZE == 32
3521     STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3522 #else
3523     STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3524 #endif
3525
3526     if (_jitc->function->allocar) {
3527         regno = jit_get_reg(jit_class_gpr);
3528         movi(rn(regno), _jitc->function->self.aoff);
3529         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3530         jit_unget_reg(regno);
3531     }
3532
3533 #if !_CALL_SYSV
3534     if (_jitc->function->self.call & jit_call_varargs) {
3535         for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3536             stxi(params_offset + regno * sizeof(jit_word_t),
3537                  _FP_REGNO, rn(JIT_RA0 - regno));
3538     }
3539 #else
3540     if (_jitc->function->self.call & jit_call_varargs) {
3541         for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3542             stxi(_jitc->function->vaoff + first_gp_offset +
3543                  regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3544         for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3545             stxi_d(_jitc->function->vaoff + first_fp_offset +
3546                    regno * va_fp_increment, _FP_REGNO,
3547                    rn(JIT_FA0 - regno));
3548     }
3549 #endif
3550 }
3551
3552 static void
3553 _epilog(jit_state_t *_jit, jit_node_t *node)
3554 {
3555     unsigned long       regno;
3556     jit_word_t          offset;
3557
3558     if (_jitc->function->assume_frame)
3559         return;
3560     if (_jitc->function->allocar)
3561         ldr(_SP_REGNO, _SP_REGNO);
3562     else
3563         addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3564 #if _CALL_SYSV
3565     ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3566 #else
3567     ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3568 #endif
3569     offset = -gpr_save_area;
3570     for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3571         if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3572             ldxi(rn(save[regno]), _SP_REGNO, offset);
3573     }
3574     for (offset = 0; offset < 8; offset++) {
3575         if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3576             ldxi_d(rn(_F14 + offset), _SP_REGNO,
3577                    -(gpr_save_area + 8 + offset * 8));
3578     }
3579
3580     MTLR(_R0_REGNO);
3581     ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3582
3583     BLR();
3584 }
3585
3586 static void
3587 _vastart(jit_state_t *_jit, jit_int32_t r0)
3588 {
3589 #if !_CALL_SYSV
3590     assert(_jitc->function->self.call & jit_call_varargs);
3591     /* Initialize stack pointer to the first stack argument. */
3592     addi(r0, _FP_REGNO, _jitc->function->self.size);
3593 #else
3594     jit_int32_t         reg;
3595     assert(_jitc->function->self.call & jit_call_varargs);
3596
3597     /* Return jit_va_list_t in the register argument */
3598     addi(r0, _FP_REGNO, _jitc->function->vaoff);
3599     reg = jit_get_reg(jit_class_gpr);
3600
3601     /* Initialize the gp counter. */
3602     movi(rn(reg), _jitc->function->vagp);
3603     stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3604
3605     /* Initialize the fp counter. */
3606     movi(rn(reg), _jitc->function->vafp);
3607     stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3608
3609     /* Initialize overflow pointer to the first stack argument. */
3610     addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3611     stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3612
3613     /* Initialize register save area pointer. */
3614     addi(rn(reg), r0, first_gp_offset);
3615     stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3616
3617     jit_unget_reg(reg);
3618 #endif
3619 }
3620
3621 static void
3622 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3623 {
3624 #if !_CALL_SYSV
3625     assert(_jitc->function->self.call & jit_call_varargs);
3626     /* Load argument. */
3627     ldr(r0, r1);
3628     /* Update va_list. */
3629     addi(r1, r1, sizeof(jit_word_t));
3630 #else
3631     jit_int32_t         rg0;
3632     jit_int32_t         rg1;
3633     jit_word_t          ge_code;
3634     jit_word_t          lt_code;
3635
3636     assert(_jitc->function->self.call & jit_call_varargs);
3637
3638     rg0 = jit_get_reg(jit_class_gpr);
3639     rg1 = jit_get_reg(jit_class_gpr);
3640
3641     /* Load the gp offset in save area in the first temporary. */
3642     ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3643
3644     /* Jump over if there are no remaining arguments in the save area. */
3645     ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3646
3647     /* Update the gp counter. */
3648     addi(rn(rg1), rn(rg0), 1);
3649     stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3650
3651     /* Load the save area pointer in the second temporary. */
3652     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3653
3654     /* Load the vararg argument in the first argument. */
3655     lshi(rn(rg0), rn(rg0), va_gp_shift);
3656     ldxr(r0, rn(rg1), rn(rg0));
3657
3658     /* Will only need one temporary register below. */
3659     jit_unget_reg(rg1);
3660
3661     /* Jump over overflow code. */
3662     lt_code = _jit->pc.w;
3663     B(0);
3664
3665     /* Where to land if argument is in overflow area. */
3666     patch_at(ge_code, _jit->pc.w);
3667
3668     /* Load overflow pointer. */
3669     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3670
3671     /* Load argument. */
3672     ldr(r0, rn(rg0));
3673
3674     /* Update overflow pointer. */
3675     addi(rn(rg0), rn(rg0), va_gp_increment);
3676     stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3677
3678     /* Where to land if argument is in save area. */
3679     patch_at(lt_code, _jit->pc.w);
3680
3681     jit_unget_reg(rg0);
3682 #endif
3683 }
3684
3685 static void
3686 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3687 {
3688 #if !_CALL_SYSV
3689     assert(_jitc->function->self.call & jit_call_varargs);
3690     /* Load argument. */
3691     ldr_d(r0, r1);
3692     /* Update va_list. */
3693     addi(r1, r1, sizeof(jit_float64_t));
3694 #else
3695     jit_int32_t         rg0;
3696     jit_int32_t         rg1;
3697     jit_word_t          ge_code;
3698     jit_word_t          lt_code;
3699
3700     assert(_jitc->function->self.call & jit_call_varargs);
3701
3702     rg0 = jit_get_reg(jit_class_gpr);
3703     rg1 = jit_get_reg(jit_class_gpr);
3704
3705     /* Load the fp offset in save area in the first temporary. */
3706     ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3707
3708     /* Jump over if there are no remaining arguments in the save area. */
3709     ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3710
3711     /* Update the fp counter. */
3712     addi(rn(rg1), rn(rg0), 1);
3713     stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3714
3715     /* Load the save area pointer in the second temporary. */
3716     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3717
3718     /* Load the vararg argument in the first argument. */
3719     lshi(rn(rg0), rn(rg0), 3);
3720     addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3721          offsetof(jit_va_list_t, first_gp_argument));
3722     ldxr_d(r0, rn(rg1), rn(rg0));
3723
3724     /* Jump over overflow code. */
3725     lt_code = _jit->pc.w;
3726     B(0);
3727
3728     /* Where to land if argument is in overflow area. */
3729     patch_at(ge_code, _jit->pc.w);
3730
3731     /* Load overflow pointer. */
3732     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3733
3734 #  if __WORDSIZE == 32
3735     /* Align if required. */
3736     andi(rn(rg1), rn(rg0), 7);
3737     addr(rn(rg0), rn(rg0), rn(rg1));
3738 #  endif
3739
3740     /* Load argument. */
3741     ldr_d(r0, rn(rg0));
3742
3743     /* Update overflow pointer. */
3744     addi(rn(rg0), rn(rg0), va_fp_increment);
3745     stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3746
3747     /* Where to land if argument is in save area. */
3748     patch_at(lt_code, _jit->pc.w);
3749
3750     jit_unget_reg(rg0);
3751     jit_unget_reg(rg1);
3752 #endif
3753 }
3754
3755 static void
3756 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3757 {
3758     jit_word_t           d;
3759     union {
3760         jit_int32_t     *i;
3761         jit_word_t       w;
3762     } u;
3763     u.w = instr;
3764     switch ((u.i[0] & 0xfc000000) >> 26) {
3765         case 16:                                        /* BCx */
3766             d = label - instr;
3767             assert(!(d & 3));
3768             if (!can_sign_extend_short_p(d)) {
3769                 /* use absolute address */
3770                 assert(can_sign_extend_short_p(label));
3771                 d = label | 2;
3772             }
3773             u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3774             break;
3775         case 18:                                        /* Bx */
3776 #if _CALL_AIXDESC
3777             if (_jitc->jump && (!(u.i[0] & 1))) {       /* jmpi label */
3778                 /* zero is used for toc and env, so, quick check
3779                  * if this is a "jmpi main" like initial jit
3780                  * instruction */
3781                 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3782                     for (d = 0; d < _jitc->prolog.offset; d++) {
3783                         /* not so pretty, but hides powerpc
3784                          * specific abi intrinsics and/or
3785                          * implementation from user */
3786                         if (_jitc->prolog.ptr[d] == label) {
3787                             label += sizeof(void*) * 3;
3788                             break;
3789                         }
3790                     }
3791                 }
3792             }
3793 #endif
3794             d = label - instr;
3795             assert(!(d & 3));
3796             if (!can_sign_extend_jump_p(d)) {
3797                 /* use absolute address */
3798                 assert(can_sign_extend_jump_p(label));
3799                 d = label | 2;
3800             }
3801             u.i[0] = (u.i[0] & ~0x3fffffc) | (d & 0x3fffffd);
3802             break;
3803         case 15:                                        /* LI */
3804 #if __WORDSIZE == 32
3805 #  define MTCTR_OFF             2
3806 #  define BCTR_OFF              3
3807 #else
3808 #  define MTCTR_OFF             6
3809 #  define BCTR_OFF              7
3810 #endif
3811 #if _CALL_AIXDESC
3812             /* movi reg label; jmpr reg */
3813             if (_jitc->jump &&
3814 #if 0
3815                 /* check for MLTR(reg) */
3816                 (u.i[MTCTR_OFF] >> 26) == 31 &&
3817                 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3818                 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3819                 /* check for BLR */
3820                 u.i[BCTR_OFF] == 0x4e800020) {
3821 #else
3822                 /* check for MTCTR(reg) */
3823                 (u.i[MTCTR_OFF] >> 26) == 31 &&
3824                 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3825                 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3826                 /* check for BCTR */
3827                 u.i[BCTR_OFF] == 0x4e800420) {
3828 #endif
3829                 /* zero is used for toc and env, so, quick check
3830                  * if this is a "jmpi main" like initial jit
3831                  * instruction */
3832                 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3833                     for (d = 0; d < _jitc->prolog.offset; d++) {
3834                         /* not so pretty, but hides powerpc
3835                          * specific abi intrinsics and/or
3836                          * implementation from user */
3837                         if (_jitc->prolog.ptr[d] == label) {
3838                             label += sizeof(void*) * 3;
3839                             break;
3840                         }
3841                     }
3842                 }
3843             }
3844 #endif
3845 #undef BCTR_OFF
3846 #undef MTCTR_OFF
3847 #if __WORDSIZE == 32
3848             assert(!(u.i[0] & 0x1f0000));
3849             u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3850             assert((u.i[1] & 0xfc000000) >> 26 == 24);  /* ORI */
3851             assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3852             u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3853 #else
3854             assert(!(u.i[0] & 0x1f0000));
3855             u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3856             assert((u.i[1] & 0xfc000000) >> 26 == 24);  /* ORI */
3857             assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3858             u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3859             /* not fully validating SLDI */
3860             assert((u.i[2] & 0xfc000000) >> 26 == 30);  /* SLDI */
3861             assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3862             assert((u.i[3] & 0xfc000000) >> 26 == 24);  /* ORI */
3863             assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3864             u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3865             /* not fully validating SLDI */
3866             assert((u.i[4] & 0xfc000000) >> 26 == 30);  /* SLDI */
3867             assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3868             assert((u.i[5] & 0xfc000000) >> 26 == 24);  /* ORI */
3869             assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3870             u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3871 #endif
3872             break;
3873         default:
3874             assert(!"unhandled branch opcode");
3875     }
3876 }
3877 #endif