deps/lightning/lib/jit_ppc-cpu.c

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