deps/lightning/lib/jit_ppc-cpu.c

   1 /*
   2  * Copyright (C) 2012-2022  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 = _jit->pc.w;
1185     BNE(0);                             /* BNE retry */
1186     /* done: */
1187     done = _jit->pc.w;
1188     ISYNC();
1189     MFCR(r0);
1190     EXTRWI(r0, r0, 1, CR_EQ);
1191     patch_at(jump0, done);
1192     patch_at(jump1, retry);
1193     if (iscasi)
1194         jit_unget_reg(r1_reg);
1195 }
1196
1197 static void
1198 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1199 {
1200     jit_int32_t         reg, addr_reg;
1201
1202     /* Convert load followed by bswap to a single instruction */
1203     /* FIXME r0 and r1 do not need to be the same, only must check if
1204      * r1 was loaded in previous instruction */
1205     if (no_flag && r0 == r1) {
1206         if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00022e | r0 << 21)) {
1207             /* Convert LHZX to LHBRX */
1208             _jit->pc.ui--;
1209             LHBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1210             return;
1211         }
1212
1213         if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0xa0000000 | r0 << 21)) {
1214             /* Convert LHZ to LHBRX */
1215             _jit->pc.ui--;
1216             addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1217
1218             reg = jit_get_reg(jit_class_gpr);
1219             LI(rn(reg), (short)*_jit->pc.ui);
1220             LHBRX(r0, rn(reg), addr_reg);
1221             jit_unget_reg(reg);
1222             return;
1223         }
1224     }
1225
1226     if (r0 == r1) {
1227         RLWIMI(r0, r0, 16, 8, 15);
1228         RLWINM(r0, r0, 24, 16, 31);
1229     } else {
1230         RLWINM(r0, r1, 8, 16, 23);
1231         RLWIMI(r0, r1, 24, 24, 31);
1232     }
1233 }
1234
1235 static void
1236 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1237 {
1238     jit_int32_t         reg, addr_reg;
1239
1240     /* Convert load followed by bswap to a single instruction */
1241     /* FIXME r0 and r1 do not need to be the same, only must check if
1242      * r1 was loaded in previous instruction */
1243     if (no_flag && r0 == r1) {
1244         if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00002e | r0 << 21)) {
1245             /* Convert LWZX to LWBRX */
1246             _jit->pc.ui--;
1247             LWBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1248             return;
1249         }
1250
1251         if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0x80000000 | r0 << 21)) {
1252             /* Convert LWZ to LWBRX */
1253             _jit->pc.ui--;
1254             addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1255
1256             reg = jit_get_reg(jit_class_gpr);
1257             LI(rn(reg), (short)*_jit->pc.ui);
1258             LWBRX(r0, rn(reg), addr_reg);
1259             jit_unget_reg(reg);
1260             return;
1261         }
1262     }
1263
1264     reg = jit_get_reg(jit_class_gpr);
1265     ROTLWI(rn(reg), r1, 8);
1266     RLWIMI(rn(reg), r1, 24, 0, 7);
1267     RLWIMI(rn(reg), r1, 24, 16, 23);
1268 #  if __WORDSIZE == 64
1269     CLRLDI(r0, rn(reg), 32);
1270 #  else
1271     MR(r0,rn(reg));
1272 #  endif
1273     jit_unget_reg(reg);
1274 }
1275
1276 static void
1277 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1278 {
1279     jit_int32_t         reg;
1280     if (can_sign_extend_short_p(i0))
1281         ADDI(r0, r1, i0);
1282     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1283         ADDIS(r0, r1, i0 >> 16);
1284     else {
1285         reg = jit_get_reg(jit_class_gpr);
1286         movi(rn(reg), i0);
1287         ADD(r0, r1, rn(reg));
1288         jit_unget_reg(reg);
1289     }
1290 }
1291
1292 static void
1293 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1294 {
1295     jit_int32_t         reg;
1296     if (can_sign_extend_short_p(i0))
1297         ADDIC(r0, r1, i0);
1298     else {
1299         reg = jit_get_reg(jit_class_gpr);
1300         movi(rn(reg), i0);
1301         ADDC(r0, r1, rn(reg));
1302         jit_unget_reg(reg);
1303     }
1304 }
1305
1306 static void
1307 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1308 {
1309     jit_int32_t         reg;
1310     reg = jit_get_reg(jit_class_gpr);
1311     movi(rn(reg), i0);
1312     ADDE(r0, r1, rn(reg));
1313     jit_unget_reg(reg);
1314 }
1315
1316 static void
1317 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1318 {
1319     jit_int32_t         reg;
1320     jit_word_t          ni0 = -i0;
1321     if (can_sign_extend_short_p(ni0))
1322         ADDI(r0, r1, ni0);
1323     else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1324         ADDIS(r0, r1, ni0 >> 16);
1325     else {
1326         reg = jit_get_reg(jit_class_gpr);
1327         movi(rn(reg), i0);
1328         SUB(r0, r1, rn(reg));
1329         jit_unget_reg(reg);
1330     }
1331 }
1332
1333 static void
1334 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1335 {
1336     jit_int32_t         reg;
1337     reg = jit_get_reg(jit_class_gpr);
1338     movi(rn(reg), i0);
1339     SUBC(r0, r1, rn(reg));
1340     jit_unget_reg(reg);
1341 }
1342
1343 static void
1344 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1345 {
1346     jit_int32_t         reg;
1347     reg = jit_get_reg(jit_class_gpr);
1348     movi(rn(reg), i0);
1349     SUBE(r0, r1, rn(reg));
1350     jit_unget_reg(reg);
1351 }
1352
1353 static void
1354 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1355 {
1356     subi(r0, r1, i0);
1357     negr(r0, r0);
1358 }
1359
1360 static void
1361 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1362 {
1363     jit_int32_t         reg;
1364     if (can_sign_extend_short_p(i0))
1365         MULLI(r0, r1, i0);
1366     else {
1367         reg = jit_get_reg(jit_class_gpr);
1368         movi(rn(reg), i0);
1369         mulr(r0, r1, rn(reg));
1370         jit_unget_reg(reg);
1371     }
1372 }
1373
1374 static void
1375 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1376         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1377 {
1378     jit_int32_t         reg;
1379     if (r0 == r2 || r0 == r3) {
1380         reg = jit_get_reg(jit_class_gpr);
1381         mullr(rn(reg), r2, r3);
1382     }
1383     else
1384         mullr(r0, r2, r3);
1385     if (sign)
1386         mulhr(r1, r2, r3);
1387     else
1388         mulhr_u(r1, r2, r3);
1389     if (r0 == r2 || r0 == r3) {
1390         movr(r0, rn(reg));
1391         jit_unget_reg(reg);
1392     }
1393 }
1394
1395 static void
1396 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1397         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1398 {
1399     jit_int32_t         reg;
1400     reg = jit_get_reg(jit_class_gpr);
1401     movi(rn(reg), i0);
1402     iqmulr(r0, r1, r2, rn(reg), sign);
1403     jit_unget_reg(reg);
1404 }
1405
1406 static void
1407 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1408 {
1409     jit_int32_t         reg;
1410     reg = jit_get_reg(jit_class_gpr);
1411     movi(rn(reg), i0);
1412     divr(r0, r1, rn(reg));
1413     jit_unget_reg(reg);
1414 }
1415
1416 static void
1417 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1418 {
1419     jit_int32_t         reg;
1420     reg = jit_get_reg(jit_class_gpr);
1421     movi(rn(reg), i0);
1422     divr_u(r0, r1, rn(reg));
1423     jit_unget_reg(reg);
1424 }
1425
1426 static void
1427 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1428         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1429 {
1430     jit_int32_t         sv0, rg0;
1431     jit_int32_t         sv1, rg1;
1432
1433     if (r0 == r2 || r0 == r3) {
1434         sv0 = jit_get_reg(jit_class_gpr);
1435         rg0 = rn(sv0);
1436     }
1437     else
1438         rg0 = r0;
1439     if (r1 == r2 || r1 == r3) {
1440         sv1 = jit_get_reg(jit_class_gpr);
1441         rg1 = rn(sv1);
1442     }
1443     else
1444         rg1 = r1;
1445
1446     if (sign)
1447         divr(rg0, r2, r3);
1448     else
1449         divr_u(rg0, r2, r3);
1450     mulr(rg1, r3, rg0);
1451     subr(rg1, r2, rg1);
1452     if (rg0 != r0) {
1453         movr(r0, rg0);
1454         jit_unget_reg(sv0);
1455     }
1456     if (rg1 != r1) {
1457         movr(r1, rg1);
1458         jit_unget_reg(sv1);
1459     }
1460 }
1461
1462 static void
1463 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1464         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1465 {
1466     jit_int32_t         reg;
1467     reg = jit_get_reg(jit_class_gpr);
1468     movi(rn(reg), i0);
1469     iqdivr(r0, r1, r2, rn(reg), sign);
1470     jit_unget_reg(reg);
1471 }
1472
1473 static void
1474 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1475 {
1476     jit_int32_t         reg;
1477     if (r0 == r1 || r0 == r2) {
1478         reg = jit_get_reg(jit_class_gpr);
1479         divr(rn(reg), r1, r2);
1480         mulr(rn(reg), r2, rn(reg));
1481         subr(r0, r1, rn(reg));
1482         jit_unget_reg(reg);
1483     }
1484     else {
1485         divr(r0, r1, r2);
1486         mulr(r0, r2, r0);
1487         subr(r0, r1, r0);
1488     }
1489 }
1490
1491 static void
1492 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1493 {
1494     jit_int32_t         reg;
1495     reg = jit_get_reg(jit_class_gpr);
1496     movi(rn(reg), i0);
1497     remr(r0, r1, rn(reg));
1498     jit_unget_reg(reg);
1499 }
1500
1501 static void
1502 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1503 {
1504     jit_int32_t         reg;
1505     if (r0 == r1 || r0 == r2) {
1506         reg = jit_get_reg(jit_class_gpr);
1507         divr_u(rn(reg), r1, r2);
1508         mulr(rn(reg), r2, rn(reg));
1509         subr(r0, r1, rn(reg));
1510         jit_unget_reg(reg);
1511     }
1512     else {
1513         divr_u(r0, r1, r2);
1514         mulr(r0, r2, r0);
1515         subr(r0, r1, r0);
1516     }
1517 }
1518
1519 static void
1520 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1521 {
1522     jit_int32_t         reg;
1523     reg = jit_get_reg(jit_class_gpr);
1524     movi(rn(reg), i0);
1525     remr_u(r0, r1, rn(reg));
1526     jit_unget_reg(reg);
1527 }
1528
1529 #  define is_mask(im)           ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
1530
1531 static void
1532 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1533 {
1534     jit_int32_t         reg, offt;
1535     if (can_zero_extend_short_p(i0))
1536         ANDI_(r0, r1, i0);
1537     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1538         ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1539     else if (__WORDSIZE == 32 && is_mask(i0)) {
1540         offt = __builtin_ctzl(i0);
1541         RLWINM(r0, r1, 0, 32 - offt - __builtin_popcountl(i0), 31 - offt);
1542     } else if (__WORDSIZE == 32 && is_mask(~i0)) {
1543         offt = __builtin_ctzl(~i0);
1544         RLWINM(r0, r1, 0, 32 - offt, 31 - offt - __builtin_popcountl(~i0));
1545     } else {
1546         reg = jit_get_reg(jit_class_gpr);
1547         movi(rn(reg), i0);
1548         AND(r0, r1, rn(reg));
1549         jit_unget_reg(reg);
1550     }
1551 }
1552
1553 static void
1554 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1555 {
1556     jit_int32_t         reg;
1557     if (can_zero_extend_short_p(i0))
1558         ORI(r0, r1, i0);
1559     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1560         ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1561     else {
1562         reg = jit_get_reg(jit_class_gpr);
1563         movi(rn(reg), i0);
1564         OR(r0, r1, rn(reg));
1565         jit_unget_reg(reg);
1566     }
1567 }
1568
1569 static void
1570 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1571 {
1572     jit_int32_t         reg;
1573     if (can_zero_extend_short_p(i0))
1574         XORI(r0, r1, i0);
1575     else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1576         XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1577     else {
1578         reg = jit_get_reg(jit_class_gpr);
1579         movi(rn(reg), i0);
1580         XOR(r0, r1, rn(reg));
1581         jit_unget_reg(reg);
1582     }
1583 }
1584
1585 static void
1586 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1587 {
1588     if (i0 == 0)
1589         movr(r0, r1);
1590     else {
1591 #  if __WORDSIZE == 32
1592         SLWI(r0, r1, i0);
1593 #  else
1594         SLDI(r0, r1, i0);
1595 #  endif
1596     }
1597 }
1598
1599 static void
1600 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1601 {
1602     if (i0 == 0)
1603         movr(r0, r1);
1604     else {
1605 #  if __WORDSIZE == 32
1606         SRAWI(r0, r1, i0);
1607 #  else
1608         SRADI(r0, r1, i0);
1609 #  endif
1610     }
1611 }
1612
1613 static void
1614 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1615 {
1616     if (i0 == 0)
1617         movr(r0, r1);
1618     else {
1619 #  if __WORDSIZE == 32
1620         SRWI(r0, r1, i0);
1621 #  else
1622         SRDI(r0, r1, i0);
1623 #  endif
1624     }
1625 }
1626
1627 static void
1628 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1629 {
1630     CMPW(r1, r2);
1631     MFCR(r0);
1632     EXTRWI(r0, r0, 1, CR_LT);
1633 }
1634
1635 static void
1636 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1637 {
1638     jit_int32_t         reg;
1639     if (can_sign_extend_short_p(i0))
1640         CMPWI(r1, i0);
1641     else {
1642         reg = jit_get_reg(jit_class_gpr);
1643         movi(rn(reg), i0);
1644         CMPW(r1, rn(reg));
1645         jit_unget_reg(reg);
1646     }
1647     MFCR(r0);
1648     EXTRWI(r0, r0, 1, CR_LT);
1649 }
1650
1651 static void
1652 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1653 {
1654     CMPLW(r1, r2);
1655     MFCR(r0);
1656     EXTRWI(r0, r0, 1, CR_LT);
1657 }
1658
1659 static void
1660 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1661 {
1662     jit_int32_t         reg;
1663     if (can_zero_extend_short_p(i0))
1664         CMPLWI(r1, i0);
1665     else {
1666         reg = jit_get_reg(jit_class_gpr);
1667         movi(rn(reg), i0);
1668         CMPLW(r1, rn(reg));
1669         jit_unget_reg(reg);
1670     }
1671     MFCR(r0);
1672     EXTRWI(r0, r0, 1, CR_LT);
1673 }
1674
1675 static void
1676 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1677 {
1678     CMPW(r1, r2);
1679     CRNOT(CR_GT, CR_GT);
1680     MFCR(r0);
1681     EXTRWI(r0, r0, 1, CR_GT);
1682 }
1683
1684 static void
1685 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1686 {
1687     jit_int32_t         reg;
1688     if (can_sign_extend_short_p(i0))
1689         CMPWI(r1, i0);
1690     else {
1691         reg = jit_get_reg(jit_class_gpr);
1692         movi(rn(reg), i0);
1693         CMPW(r1, rn(reg));
1694         jit_unget_reg(reg);
1695     }
1696     CRNOT(CR_GT, CR_GT);
1697     MFCR(r0);
1698     EXTRWI(r0, r0, 1, CR_GT);
1699 }
1700
1701 static void
1702 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1703 {
1704     CMPLW(r1, r2);
1705     CRNOT(CR_GT, CR_GT);
1706     MFCR(r0);
1707     EXTRWI(r0, r0, 1, CR_GT);
1708 }
1709
1710 static void
1711 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1712 {
1713     jit_int32_t         reg;
1714     if (can_zero_extend_short_p(i0))
1715         CMPLWI(r1, i0);
1716     else {
1717         reg = jit_get_reg(jit_class_gpr);
1718         movi(rn(reg), i0);
1719         CMPLW(r1, rn(reg));
1720         jit_unget_reg(reg);
1721     }
1722     CRNOT(CR_GT, CR_GT);
1723     MFCR(r0);
1724     EXTRWI(r0, r0, 1, CR_GT);
1725 }
1726
1727 static void
1728 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1729 {
1730     CMPW(r1, r2);
1731     MFCR(r0);
1732     EXTRWI(r0, r0, 1, CR_EQ);
1733 }
1734
1735 static void
1736 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1737 {
1738     jit_int32_t         reg;
1739     if (can_sign_extend_short_p(i0))
1740         CMPWI(r1, i0);
1741     else if (can_zero_extend_short_p(i0))
1742         CMPLWI(r1, i0);
1743     else {
1744         reg = jit_get_reg(jit_class_gpr);
1745         movi(rn(reg), i0);
1746         CMPW(r1, rn(reg));
1747         jit_unget_reg(reg);
1748     }
1749     MFCR(r0);
1750     EXTRWI(r0, r0, 1, CR_EQ);
1751 }
1752
1753 static void
1754 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1755 {
1756     CMPW(r1, r2);
1757     CRNOT(CR_LT, CR_LT);
1758     MFCR(r0);
1759     EXTRWI(r0, r0, 1, CR_LT);
1760 }
1761
1762 static void
1763 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1764 {
1765     jit_int32_t         reg;
1766     if (can_sign_extend_short_p(i0))
1767         CMPWI(r1, i0);
1768     else {
1769         reg = jit_get_reg(jit_class_gpr);
1770         movi(rn(reg), i0);
1771         CMPW(r1, rn(reg));
1772         jit_unget_reg(reg);
1773     }
1774     CRNOT(CR_LT, CR_LT);
1775     MFCR(r0);
1776     EXTRWI(r0, r0, 1, CR_LT);
1777 }
1778
1779 static void
1780 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1781 {
1782     CMPLW(r1, r2);
1783     CRNOT(CR_LT, CR_LT);
1784     MFCR(r0);
1785     EXTRWI(r0, r0, 1, CR_LT);
1786 }
1787
1788 static void
1789 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1790 {
1791     jit_int32_t         reg;
1792     if (can_zero_extend_short_p(i0))
1793         CMPLWI(r1, i0);
1794     else {
1795         reg = jit_get_reg(jit_class_gpr);
1796         movi(rn(reg), i0);
1797         CMPLW(r1, rn(reg));
1798         jit_unget_reg(reg);
1799     }
1800     CRNOT(CR_LT, CR_LT);
1801     MFCR(r0);
1802     EXTRWI(r0, r0, 1, CR_LT);
1803 }
1804
1805 static void
1806 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1807 {
1808     CMPW(r1, r2);
1809     MFCR(r0);
1810     EXTRWI(r0, r0, 1, CR_GT);
1811 }
1812
1813 static void
1814 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1815 {
1816     jit_int32_t         reg;
1817     if (can_sign_extend_short_p(i0))
1818         CMPWI(r1, i0);
1819     else {
1820         reg = jit_get_reg(jit_class_gpr);
1821         movi(rn(reg), i0);
1822         CMPW(r1, rn(reg));
1823         jit_unget_reg(reg);
1824     }
1825     MFCR(r0);
1826     EXTRWI(r0, r0, 1, CR_GT);
1827 }
1828
1829 static void
1830 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1831 {
1832     CMPLW(r1, r2);
1833     MFCR(r0);
1834     EXTRWI(r0, r0, 1, CR_GT);
1835 }
1836
1837 static void
1838 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1839 {
1840     jit_int32_t         reg;
1841     if (can_zero_extend_short_p(i0))
1842         CMPLWI(r1, i0);
1843     else {
1844         reg = jit_get_reg(jit_class_gpr);
1845         movi(rn(reg), i0);
1846         CMPLW(r1, rn(reg));
1847         jit_unget_reg(reg);
1848     }
1849     MFCR(r0);
1850     EXTRWI(r0, r0, 1, CR_GT);
1851 }
1852
1853 static void
1854 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1855 {
1856     CMPW(r1, r2);
1857     CRNOT(CR_EQ, CR_EQ);
1858     MFCR(r0);
1859     EXTRWI(r0, r0, 1, CR_EQ);
1860 }
1861
1862 static void
1863 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1864 {
1865     jit_int32_t         reg;
1866     if (can_sign_extend_short_p(i0))
1867         CMPWI(r1, i0);
1868     else if (can_zero_extend_short_p(i0))
1869         CMPLWI(r1, i0);
1870     else {
1871         reg = jit_get_reg(jit_class_gpr);
1872         movi(rn(reg), i0);
1873         CMPW(r1, rn(reg));
1874         jit_unget_reg(reg);
1875     }
1876     CRNOT(CR_EQ, CR_EQ);
1877     MFCR(r0);
1878     EXTRWI(r0, r0, 1, CR_EQ);
1879 }
1880
1881 static jit_word_t
1882 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1883 {
1884     jit_word_t          d, w;
1885     CMPW(r0, r1);
1886     w = _jit->pc.w;
1887     d = (i0 - w) & ~3;
1888     BLT(d);
1889     return (w);
1890 }
1891
1892 static jit_word_t
1893 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1894 {
1895     jit_int32_t         reg;
1896     jit_word_t          d, w;
1897     if (can_sign_extend_short_p(i1))
1898         CMPWI(r0, i1);
1899     else {
1900         reg = jit_get_reg(jit_class_gpr);
1901         movi(rn(reg), i1);
1902         CMPW(r0, rn(reg));
1903         jit_unget_reg(reg);
1904     }
1905     w = _jit->pc.w;
1906     d = (i0 - w) & ~3;
1907     BLT(d);
1908     return (w);
1909 }
1910
1911 static jit_word_t
1912 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1913 {
1914     jit_word_t          d, w;
1915     CMPLW(r0, r1);
1916     w = _jit->pc.w;
1917     d = (i0 - w) & ~3;
1918     BLT(d);
1919     return (w);
1920 }
1921
1922 static jit_word_t
1923 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1924 {
1925     jit_int32_t         reg;
1926     jit_word_t          d, w;
1927     if (can_zero_extend_short_p(i1))
1928         CMPLWI(r0, i1);
1929     else {
1930         reg = jit_get_reg(jit_class_gpr);
1931         movi(rn(reg), i1);
1932         CMPLW(r0, rn(reg));
1933         jit_unget_reg(reg);
1934     }
1935     w = _jit->pc.w;
1936     d = (i0 - w) & ~3;
1937     BLT(d);
1938     return (w);
1939 }
1940
1941 static jit_word_t
1942 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1943 {
1944     jit_word_t          d, w;
1945     CMPW(r0, r1);
1946     w = _jit->pc.w;
1947     d = (i0 - w) & ~3;
1948     BLE(d);
1949     return (w);
1950 }
1951
1952 static jit_word_t
1953 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1954 {
1955     jit_int32_t         reg;
1956     jit_word_t          d, w;
1957     if (can_sign_extend_short_p(i1))
1958         CMPWI(r0, i1);
1959     else {
1960         reg = jit_get_reg(jit_class_gpr);
1961         movi(rn(reg), i1);
1962         CMPW(r0, rn(reg));
1963         jit_unget_reg(reg);
1964     }
1965     w = _jit->pc.w;
1966     d = (i0 - w) & ~3;
1967     BLE(d);
1968     return (w);
1969 }
1970
1971 static jit_word_t
1972 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1973 {
1974     jit_word_t          d, w;
1975     CMPLW(r0, r1);
1976     w = _jit->pc.w;
1977     d = (i0 - w) & ~3;
1978     BLE(d);
1979     return (w);
1980 }
1981
1982 static jit_word_t
1983 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1984 {
1985     jit_int32_t         reg;
1986     jit_word_t          d, w;
1987     if (can_zero_extend_short_p(i1))
1988         CMPLWI(r0, i1);
1989     else {
1990         reg = jit_get_reg(jit_class_gpr);
1991         movi(rn(reg), i1);
1992         CMPLW(r0, rn(reg));
1993         jit_unget_reg(reg);
1994     }
1995     w = _jit->pc.w;
1996     d = (i0 - w) & ~3;
1997     BLE(d);
1998     return (w);
1999 }
2000
2001 static jit_word_t
2002 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2003 {
2004     jit_word_t          d, w;
2005     CMPW(r0, r1);
2006     w = _jit->pc.w;
2007     d = (i0 - w) & ~3;
2008     BEQ(d);
2009     return (w);
2010 }
2011
2012 static jit_word_t
2013 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2014 {
2015     jit_int32_t         reg;
2016     jit_word_t          d, w;
2017     if (can_sign_extend_short_p(i1))
2018         CMPWI(r0, i1);
2019     else if (can_zero_extend_short_p(i1))
2020         CMPLWI(r0, i1);
2021     else {
2022         reg = jit_get_reg(jit_class_gpr);
2023         movi(rn(reg), i1);
2024         CMPW(r0, rn(reg));
2025         jit_unget_reg(reg);
2026     }
2027     w = _jit->pc.w;
2028     d = (i0 - w) & ~3;
2029     BEQ(d);
2030     return (w);
2031 }
2032
2033 static jit_word_t
2034 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2035 {
2036     jit_word_t          d, w;
2037     CMPW(r0, r1);
2038     w = _jit->pc.w;
2039     d = (i0 - w) & ~3;
2040     BGE(d);
2041     return (w);
2042 }
2043
2044 static jit_word_t
2045 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2046 {
2047     jit_int32_t         reg;
2048     jit_word_t          d, w;
2049     if (can_sign_extend_short_p(i1))
2050         CMPWI(r0, i1);
2051     else {
2052         reg = jit_get_reg(jit_class_gpr);
2053         movi(rn(reg), i1);
2054         CMPW(r0, rn(reg));
2055         jit_unget_reg(reg);
2056     }
2057     w = _jit->pc.w;
2058     d = (i0 - w) & ~3;
2059     BGE(d);
2060     return (w);
2061 }
2062
2063 static jit_word_t
2064 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2065 {
2066     jit_word_t          d, w;
2067     CMPLW(r0, r1);
2068     w = _jit->pc.w;
2069     d = (i0 - w) & ~3;
2070     BGE(d);
2071     return (w);
2072 }
2073
2074 static jit_word_t
2075 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2076 {
2077     jit_int32_t         reg;
2078     jit_word_t          d, w;
2079     if (can_zero_extend_short_p(i1))
2080         CMPLWI(r0, i1);
2081     else {
2082         reg = jit_get_reg(jit_class_gpr);
2083         movi(rn(reg), i1);
2084         CMPLW(r0, rn(reg));
2085         jit_unget_reg(reg);
2086     }
2087     w = _jit->pc.w;
2088     d = (i0 - w) & ~3;
2089     BGE(d);
2090     return (w);
2091 }
2092
2093 static jit_word_t
2094 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2095 {
2096     jit_word_t          d, w;
2097     CMPW(r0, r1);
2098     w = _jit->pc.w;
2099     d = (i0 - w) & ~3;
2100     BGT(d);
2101     return (w);
2102 }
2103
2104 static jit_word_t
2105 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2106 {
2107     jit_int32_t         reg;
2108     jit_word_t          d, w;
2109     if (can_sign_extend_short_p(i1))
2110         CMPWI(r0, i1);
2111     else {
2112         reg = jit_get_reg(jit_class_gpr);
2113         movi(rn(reg), i1);
2114         CMPW(r0, rn(reg));
2115         jit_unget_reg(reg);
2116     }
2117     w = _jit->pc.w;
2118     d = (i0 - w) & ~3;
2119     BGT(d);
2120     return (w);
2121 }
2122
2123 static jit_word_t
2124 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2125 {
2126     jit_word_t          d, w;
2127     CMPLW(r0, r1);
2128     w = _jit->pc.w;
2129     d = (i0 - w) & ~3;
2130     BGT(d);
2131     return (w);
2132 }
2133
2134 static jit_word_t
2135 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2136 {
2137     jit_int32_t         reg;
2138     jit_word_t          d, w;
2139     if (can_zero_extend_short_p(i1))
2140         CMPLWI(r0, i1);
2141     else {
2142         reg = jit_get_reg(jit_class_gpr);
2143         movi(rn(reg), i1);
2144         CMPLW(r0, rn(reg));
2145         jit_unget_reg(reg);
2146     }
2147     w = _jit->pc.w;
2148     d = (i0 - w) & ~3;
2149     BGT(d);
2150     return (w);
2151 }
2152
2153 static jit_word_t
2154 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2155 {
2156     jit_word_t          d, w;
2157     CMPW(r0, r1);
2158     w = _jit->pc.w;
2159     d = (i0 - w) & ~3;
2160     BNE(d);
2161     return (w);
2162 }
2163
2164 static jit_word_t
2165 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2166 {
2167     jit_int32_t         reg;
2168     jit_word_t          d, w;
2169     if (can_sign_extend_short_p(i1))
2170         CMPWI(r0, i1);
2171     else if (can_zero_extend_short_p(i1))
2172         CMPLWI(r0, i1);
2173     else {
2174         reg = jit_get_reg(jit_class_gpr);
2175         movi(rn(reg), i1);
2176         CMPW(r0, rn(reg));
2177         jit_unget_reg(reg);
2178     }
2179     w = _jit->pc.w;
2180     d = (i0 - w) & ~3;
2181     BNE(d);
2182     return (w);
2183 }
2184
2185 static jit_word_t
2186 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2187 {
2188     jit_word_t          w;
2189     jit_int32_t         reg;
2190     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2191     andr(rn(reg), r0, r1);
2192     w = bnei(i0, rn(reg), 0);
2193     jit_unget_reg(reg);
2194     return (w);
2195 }
2196
2197 static jit_word_t
2198 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2199 {
2200     jit_word_t          w;
2201     jit_int32_t         reg;
2202     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2203     andi(rn(reg), r0, i1);
2204     w = bnei(i0, rn(reg), 0);
2205     jit_unget_reg(reg);
2206     return (w);
2207 }
2208
2209 static jit_word_t
2210 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2211 {
2212     jit_word_t          w;
2213     jit_int32_t         reg;
2214     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2215     andr(rn(reg), r0, r1);
2216     w = beqi(i0, rn(reg), 0);
2217     jit_unget_reg(reg);
2218     return (w);
2219 }
2220
2221 static jit_word_t
2222 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2223 {
2224     jit_word_t          w;
2225     jit_int32_t         reg;
2226     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2227     andi(rn(reg), r0, i1);
2228     w = beqi(i0, rn(reg), 0);
2229     jit_unget_reg(reg);
2230     return (w);
2231 }
2232
2233 static jit_word_t
2234 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2235 {
2236     jit_word_t          d, w;
2237     ADDO(r0, r0, r1);
2238     MCRXR(CR_0);
2239     w = _jit->pc.w;
2240     d = (i0 - w) & ~3;
2241     BGT(d);                             /* GT = bit 1 of XER = OV */
2242     return (w);
2243 }
2244
2245 static jit_word_t
2246 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2247 {
2248     jit_word_t          w;
2249     jit_int32_t         reg;
2250     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2251     movi(rn(reg), i1);
2252     w = boaddr(i0, r0, rn(reg));
2253     jit_unget_reg(reg);
2254     return (w);
2255 }
2256
2257 static jit_word_t
2258 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2259 {
2260     jit_word_t          d, w;
2261     ADDO(r0, r0, r1);
2262     MCRXR(CR_0);
2263     w = _jit->pc.w;
2264     d = (i0 - w) & ~3;
2265     BLE(d);
2266     return (w);
2267 }
2268
2269 static jit_word_t
2270 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2271 {
2272     jit_word_t          w;
2273     jit_int32_t         reg;
2274     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2275     movi(rn(reg), i1);
2276     w = bxaddr(i0, r0, rn(reg));
2277     jit_unget_reg(reg);
2278     return (w);
2279 }
2280
2281 static jit_word_t
2282 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2283 {
2284     jit_word_t          d, w;
2285     SUBO(r0, r0, r1);
2286     MCRXR(CR_0);
2287     w = _jit->pc.w;
2288     d = (i0 - w) & ~3;
2289     BGT(d);
2290     return (w);
2291 }
2292
2293 static jit_word_t
2294 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2295 {
2296     jit_word_t          w;
2297     jit_int32_t         reg;
2298     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2299     movi(rn(reg), i1);
2300     w = bosubr(i0, r0, rn(reg));
2301     jit_unget_reg(reg);
2302     return (w);
2303 }
2304
2305 static jit_word_t
2306 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2307 {
2308     jit_word_t          d, w;
2309     SUBO(r0, r0, r1);
2310     MCRXR(CR_0);
2311     w = _jit->pc.w;
2312     d = (i0 - w) & ~3;
2313     BLE(d);
2314     return (w);
2315 }
2316
2317 static jit_word_t
2318 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2319 {
2320     jit_word_t          w;
2321     jit_int32_t         reg;
2322     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2323     movi(rn(reg), i1);
2324     w = bxsubr(i0, r0, rn(reg));
2325     jit_unget_reg(reg);
2326     return (w);
2327 }
2328
2329 static jit_word_t
2330 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2331 {
2332     jit_word_t          d, w;
2333     ADDC(r0, r0, r1);
2334     MCRXR(CR_0);
2335     w = _jit->pc.w;
2336     d = (i0 - w) & ~3;
2337     BEQ(d);                             /* EQ = bit 2 of XER = CA */
2338     return (w);
2339 }
2340
2341 static jit_word_t
2342 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2343 {
2344     jit_int32_t         reg;
2345     jit_word_t          d, w;
2346     if (can_sign_extend_short_p(i1)) {
2347         ADDIC(r0, r0, i1);
2348         MCRXR(CR_0);
2349         w = _jit->pc.w;
2350         d = (i0 - w) & ~3;
2351         BEQ(d);
2352         return (w);
2353     }
2354     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2355     movi(rn(reg), i1);
2356     w = boaddr_u(i0, r0, rn(reg));
2357     jit_unget_reg(reg);
2358     return (w);
2359 }
2360
2361 static jit_word_t
2362 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2363 {
2364     jit_word_t          d, w;
2365     ADDC(r0, r0, r1);
2366     MCRXR(CR_0);
2367     w = _jit->pc.w;
2368     d = (i0 - w) & ~3;
2369     BNE(d);
2370     return (w);
2371 }
2372
2373 static jit_word_t
2374 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2375 {
2376     jit_int32_t         reg;
2377     jit_word_t          d, w;
2378     if (can_sign_extend_short_p(i1)) {
2379         ADDIC(r0, r0, i1);
2380         MCRXR(CR_0);
2381         w = _jit->pc.w;
2382         d = (i0 - w) & ~3;
2383         BNE(d);
2384         return (w);
2385     }
2386     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2387     movi(rn(reg), i1);
2388     w = bxaddr_u(i0, r0, rn(reg));
2389     jit_unget_reg(reg);
2390     return (w);
2391 }
2392
2393 static jit_word_t
2394 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2395 {
2396     jit_word_t          d, w;
2397     SUBC(r0, r0, r1);
2398     MCRXR(CR_0);
2399     w = _jit->pc.w;
2400     d = (i0 - w) & ~3;
2401     BNE(d);                             /* PPC uses "carry" not "borrow" */
2402     return (w);
2403 }
2404
2405 static jit_word_t
2406 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2407 {
2408     jit_word_t          w;
2409     jit_int32_t         reg;
2410     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2411     movi(rn(reg), i1);
2412     w = bosubr_u(i0, r0, rn(reg));
2413     jit_unget_reg(reg);
2414     return (w);
2415 }
2416
2417 static jit_word_t
2418 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2419 {
2420     jit_word_t          d, w;
2421     SUBC(r0, r0, r1);
2422     MCRXR(CR_0);
2423     w = _jit->pc.w;
2424     d = (i0 - w) & ~3;
2425     BEQ(d);
2426     return (w);
2427 }
2428
2429 static jit_word_t
2430 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2431 {
2432     jit_word_t          w;
2433     jit_int32_t         reg;
2434     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2435     movi(rn(reg), i1);
2436     w = bxsubr_u(i0, r0, rn(reg));
2437     jit_unget_reg(reg);
2438     return (w);
2439 }
2440
2441 static void
2442 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2443 {
2444     ldr_uc(r0, r1);
2445     extr_c(r0, r0);
2446 }
2447
2448 static void
2449 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2450 {
2451     ldi_uc(r0, i0);
2452     extr_c(r0, r0);
2453 }
2454
2455 static void
2456 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2457 {
2458     ldxr_uc(r0, r1, r2);
2459     extr_c(r0, r0);
2460 }
2461
2462 static void
2463 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2464 {
2465     ldxi_uc(r0, r1, i0);
2466     extr_c(r0, r0);
2467 }
2468
2469 static void
2470 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2471 {
2472     jit_bool_t          inv;
2473     jit_int32_t         reg;
2474     jit_word_t          lo, hi;
2475     if (can_sign_extend_short_p(i0))
2476         LBZ(r0, _R0_REGNO, i0);
2477     else if (can_sign_extend_int_p(i0)) {
2478         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2479         lo = (jit_int16_t)(i0 - (hi << 16));
2480         reg = jit_get_reg(jit_class_gpr);
2481         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2482         LIS(rn(reg), hi);
2483         LBZ(r0, rn(reg), lo);
2484         jit_unget_reg(reg);
2485         if (inv)                        jit_unget_reg(_R0);
2486     }
2487     else {
2488         reg = jit_get_reg(jit_class_gpr);
2489         movi(rn(reg), i0);
2490         ldr_uc(r0, rn(reg));
2491         jit_unget_reg(reg);
2492     }
2493 }
2494
2495 static void
2496 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2497 {
2498     jit_int32_t         reg;
2499     if (r1 == _R0_REGNO) {
2500         if (r2 != _R0_REGNO)
2501             LBZX(r0, r2, r1);
2502         else {
2503             reg = jit_get_reg(jit_class_gpr);
2504             movr(rn(reg), r1);
2505             LBZX(r0, rn(reg), r2);
2506             jit_unget_reg(reg);
2507         }
2508     }
2509     else
2510         LBZX(r0, r1, r2);
2511 }
2512
2513 static void
2514 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2515 {
2516     jit_int32_t         reg;
2517     if (i0 == 0)
2518         ldr_uc(r0, r1);
2519     else if (can_sign_extend_short_p(i0)) {
2520         if (r1 == _R0_REGNO) {
2521             reg = jit_get_reg(jit_class_gpr);
2522             movr(rn(reg), r1);
2523             LBZ(r0, rn(reg), i0);
2524             jit_unget_reg(reg);
2525         }
2526         else
2527             LBZ(r0, r1, i0);
2528     }
2529     else {
2530         reg = jit_get_reg(jit_class_gpr);
2531         movi(rn(reg), i0);
2532         ldxr_uc(r0, r1, rn(reg));
2533         jit_unget_reg(reg);
2534     }
2535 }
2536
2537 static void
2538 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2539 {
2540     jit_bool_t          inv;
2541     jit_int32_t         reg;
2542     jit_word_t          lo, hi;
2543     if (can_sign_extend_short_p(i0))
2544         LHA(r0, _R0_REGNO, i0);
2545     else if (can_sign_extend_int_p(i0)) {
2546         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2547         lo = (jit_int16_t)(i0 - (hi << 16));
2548         reg = jit_get_reg(jit_class_gpr);
2549         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2550         LIS(rn(reg), hi);
2551         LHA(r0, rn(reg), lo);
2552         jit_unget_reg(reg);
2553         if (inv)                        jit_unget_reg(_R0);
2554     }
2555     else {
2556         reg = jit_get_reg(jit_class_gpr);
2557         movi(rn(reg), i0);
2558         ldr_s(r0, rn(reg));
2559         jit_unget_reg(reg);
2560     }
2561 }
2562
2563 static void
2564 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2565 {
2566     jit_int32_t         reg;
2567     if (r1 == _R0_REGNO) {
2568         if (r2 != _R0_REGNO)
2569             LHAX(r0, r2, r1);
2570         else {
2571             reg = jit_get_reg(jit_class_gpr);
2572             movr(rn(reg), r1);
2573             LHAX(r0, rn(reg), r2);
2574             jit_unget_reg(reg);
2575         }
2576     }
2577     else
2578         LHAX(r0, r1, r2);
2579 }
2580
2581 static void
2582 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2583 {
2584     jit_int32_t         reg;
2585     if (i0 == 0)
2586         ldr_s(r0, r1);
2587     else if (can_sign_extend_short_p(i0)) {
2588         if (r1 == _R0_REGNO) {
2589             reg = jit_get_reg(jit_class_gpr);
2590             movr(rn(reg), r1);
2591             LHA(r0, rn(reg), i0);
2592             jit_unget_reg(reg);
2593         }
2594         else
2595             LHA(r0, r1, i0);
2596     }
2597     else {
2598         reg = jit_get_reg(jit_class_gpr);
2599         movi(rn(reg), i0);
2600         ldxr_s(r0, r1, rn(reg));
2601         jit_unget_reg(reg);
2602     }
2603 }
2604
2605 static void
2606 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2607 {
2608     jit_bool_t          inv;
2609     jit_int32_t         reg;
2610     jit_word_t          lo, hi;
2611     if (can_sign_extend_short_p(i0))
2612         LHZ(r0, _R0_REGNO, i0);
2613     else if (can_sign_extend_int_p(i0)) {
2614         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2615         lo = (jit_int16_t)(i0 - (hi << 16));
2616         reg = jit_get_reg(jit_class_gpr);
2617         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2618         LIS(rn(reg), hi);
2619         LHZ(r0, rn(reg), lo);
2620         jit_unget_reg(reg);
2621         if (inv)                        jit_unget_reg(_R0);
2622     }
2623     else {
2624         reg = jit_get_reg(jit_class_gpr);
2625         movi(rn(reg), i0);
2626         ldr_us(r0, rn(reg));
2627         jit_unget_reg(reg);
2628     }
2629 }
2630
2631 static void
2632 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2633 {
2634     jit_int32_t         reg;
2635     if (r1 == _R0_REGNO) {
2636         if (r2 != _R0_REGNO)
2637             LHZX(r0, r2, r1);
2638         else {
2639             reg = jit_get_reg(jit_class_gpr);
2640             movr(rn(reg), r1);
2641             LHZX(r0, rn(reg), r2);
2642             jit_unget_reg(reg);
2643         }
2644     }
2645     else
2646         LHZX(r0, r1, r2);
2647 }
2648
2649 static void
2650 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2651 {
2652     jit_int32_t         reg;
2653     if (i0 == 0)
2654         ldr_us(r0, r1);
2655     else if (can_sign_extend_short_p(i0)) {
2656         if (r1 == _R0_REGNO) {
2657             reg = jit_get_reg(jit_class_gpr);
2658             movr(rn(reg), r1);
2659             LHZ(r0, rn(reg), i0);
2660             jit_unget_reg(reg);
2661         }
2662         else
2663             LHZ(r0, r1, i0);
2664     }
2665     else {
2666         reg = jit_get_reg(jit_class_gpr);
2667         movi(rn(reg), i0);
2668         ldxr_us(r0, r1, rn(reg));
2669         jit_unget_reg(reg);
2670     }
2671 }
2672
2673 #  if __WORDSIZE == 32
2674 static void
2675 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2676 {
2677     jit_bool_t          inv;
2678     jit_int32_t         reg;
2679     jit_word_t          lo, hi;
2680     if (can_sign_extend_short_p(i0))
2681         LWZ(r0, _R0_REGNO, i0);
2682     else if (can_sign_extend_int_p(i0)) {
2683         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2684         lo = (jit_int16_t)(i0 - (hi << 16));
2685         reg = jit_get_reg(jit_class_gpr);
2686         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2687         LIS(rn(reg), hi);
2688         LWZ(r0, rn(reg), lo);
2689         jit_unget_reg(reg);
2690         if (inv)                        jit_unget_reg(_R0);
2691     }
2692     else {
2693         reg = jit_get_reg(jit_class_gpr);
2694         movi(rn(reg), i0);
2695         ldr_i(r0, rn(reg));
2696         jit_unget_reg(reg);
2697     }
2698 }
2699
2700 static void
2701 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2702 {
2703     jit_int32_t         reg;
2704     if (r1 == _R0_REGNO) {
2705         if (r2 != _R0_REGNO)
2706             LWZX(r0, r2, r1);
2707         else {
2708             reg = jit_get_reg(jit_class_gpr);
2709             movr(rn(reg), r1);
2710             LWZX(r0, rn(reg), r2);
2711             jit_unget_reg(reg);
2712         }
2713     }
2714     else
2715         LWZX(r0, r1, r2);
2716 }
2717
2718 static void
2719 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2720 {
2721     jit_int32_t         reg;
2722     if (i0 == 0)
2723         ldr_i(r0, r1);
2724     else if (can_sign_extend_short_p(i0)) {
2725         if (r1 == _R0_REGNO) {
2726             reg = jit_get_reg(jit_class_gpr);
2727             movr(rn(reg), r1);
2728             LWZ(r0, rn(reg), i0);
2729             jit_unget_reg(reg);
2730         }
2731         else
2732             LWZ(r0, r1, i0);
2733     }
2734     else {
2735         reg = jit_get_reg(jit_class_gpr);
2736         movi(rn(reg), i0);
2737         ldxr_i(r0, r1, rn(reg));
2738         jit_unget_reg(reg);
2739     }
2740 }
2741
2742 #  else
2743 static void
2744 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2745 {
2746     jit_bool_t          inv;
2747     jit_int32_t         reg;
2748     jit_word_t          lo, hi;
2749     if (can_sign_extend_short_p(i0))
2750         LWA(r0, _R0_REGNO, i0);
2751     else if (can_sign_extend_int_p(i0)) {
2752         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2753         lo = (jit_int16_t)(i0 - (hi << 16));
2754         reg = jit_get_reg(jit_class_gpr);
2755         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2756         LIS(rn(reg), hi);
2757         LWA(r0, rn(reg), lo);
2758         jit_unget_reg(reg);
2759         if (inv)                        jit_unget_reg(_R0);
2760     }
2761     else {
2762         reg = jit_get_reg(jit_class_gpr);
2763         movi(rn(reg), i0);
2764         ldr_i(r0, rn(reg));
2765         jit_unget_reg(reg);
2766     }
2767 }
2768
2769 static void
2770 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2771 {
2772     jit_int32_t         reg;
2773     if (r1 == _R0_REGNO) {
2774         if (r2 != _R0_REGNO)
2775             LWZX(r0, r2, r1);
2776         else {
2777             reg = jit_get_reg(jit_class_gpr);
2778             movr(rn(reg), r1);
2779             LWAX(r0, rn(reg), r2);
2780             jit_unget_reg(reg);
2781         }
2782     }
2783     else
2784         LWZX(r0, r1, r2);
2785 }
2786
2787 static void
2788 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2789 {
2790     jit_int32_t         reg;
2791     if (i0 == 0)
2792         ldr_i(r0, r1);
2793     else if (can_sign_extend_short_p(i0)) {
2794         if (r1 == _R0_REGNO) {
2795             reg = jit_get_reg(jit_class_gpr);
2796             movr(rn(reg), r1);
2797             LWA(r0, rn(reg), i0);
2798             jit_unget_reg(reg);
2799         }
2800         else
2801             LWA(r0, r1, i0);
2802     }
2803     else {
2804         reg = jit_get_reg(jit_class_gpr);
2805         movi(rn(reg), i0);
2806         ldxr_i(r0, r1, rn(reg));
2807         jit_unget_reg(reg);
2808     }
2809 }
2810
2811 static void
2812 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2813 {
2814     jit_bool_t          inv;
2815     jit_int32_t         reg;
2816     jit_word_t          lo, hi;
2817     if (can_sign_extend_short_p(i0))
2818         LWZ(r0, _R0_REGNO, i0);
2819     else if (can_sign_extend_int_p(i0)) {
2820         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2821         lo = (jit_int16_t)(i0 - (hi << 16));
2822         reg = jit_get_reg(jit_class_gpr);
2823         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2824         LIS(rn(reg), hi);
2825         LWZ(r0, rn(reg), lo);
2826         jit_unget_reg(reg);
2827         if (inv)                        jit_unget_reg(_R0);
2828     }
2829     else {
2830         reg = jit_get_reg(jit_class_gpr);
2831         movi(rn(reg), i0);
2832         ldr_ui(r0, rn(reg));
2833         jit_unget_reg(reg);
2834     }
2835 }
2836
2837 static void
2838 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2839 {
2840     jit_int32_t         reg;
2841     if (r1 == _R0_REGNO) {
2842         if (r2 != _R0_REGNO)
2843             LWZX(r0, r2, r1);
2844         else {
2845             reg = jit_get_reg(jit_class_gpr);
2846             movr(rn(reg), r1);
2847             LWZX(r0, rn(reg), r2);
2848             jit_unget_reg(reg);
2849         }
2850     }
2851     else
2852         LWZX(r0, r1, r2);
2853 }
2854
2855 static void
2856 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2857 {
2858     jit_int32_t         reg;
2859     if (i0 == 0)
2860         ldr_i(r0, r1);
2861     else if (can_sign_extend_short_p(i0)) {
2862         if (r1 == _R0_REGNO) {
2863             reg = jit_get_reg(jit_class_gpr);
2864             movr(rn(reg), r1);
2865             LWZ(r0, rn(reg), i0);
2866             jit_unget_reg(reg);
2867         }
2868         else
2869             LWZ(r0, r1, i0);
2870     }
2871     else {
2872         reg = jit_get_reg(jit_class_gpr);
2873         movi(rn(reg), i0);
2874         ldxr_ui(r0, r1, rn(reg));
2875         jit_unget_reg(reg);
2876     }
2877 }
2878
2879 static void
2880 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2881 {
2882     jit_bool_t          inv;
2883     jit_int32_t         reg;
2884     jit_word_t          lo, hi;
2885     if (can_sign_extend_short_p(i0))
2886         LD(r0, _R0_REGNO, i0);
2887     else if (can_sign_extend_int_p(i0)) {
2888         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2889         lo = (jit_int16_t)(i0 - (hi << 16));
2890         reg = jit_get_reg(jit_class_gpr);
2891         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2892         LIS(rn(reg), hi);
2893         LD(r0, rn(reg), lo);
2894         jit_unget_reg(reg);
2895         if (inv)                        jit_unget_reg(_R0);
2896     }
2897     else {
2898         reg = jit_get_reg(jit_class_gpr);
2899         movi(rn(reg), i0);
2900         ldr_l(r0, rn(reg));
2901         jit_unget_reg(reg);
2902     }
2903 }
2904
2905 static void
2906 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2907 {
2908     jit_int32_t         reg;
2909     if (r1 == _R0_REGNO) {
2910         if (r2 != _R0_REGNO)
2911             LDX(r0, r2, r1);
2912         else {
2913             reg = jit_get_reg(jit_class_gpr);
2914             movr(rn(reg), r1);
2915             LDX(r0, rn(reg), r2);
2916             jit_unget_reg(reg);
2917         }
2918     }
2919     else
2920         LDX(r0, r1, r2);
2921 }
2922
2923 static void
2924 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2925 {
2926     jit_int32_t         reg;
2927     if (i0 == 0)
2928         ldr_l(r0, r1);
2929     else if (can_sign_extend_short_p(i0)) {
2930         if (r1 == _R0_REGNO) {
2931             reg = jit_get_reg(jit_class_gpr);
2932             movr(rn(reg), r1);
2933             LD(r0, rn(reg), i0);
2934             jit_unget_reg(reg);
2935         }
2936         else
2937             LD(r0, r1, i0);
2938     }
2939     else {
2940         reg = jit_get_reg(jit_class_gpr);
2941         movi(rn(reg), i0);
2942         ldxr_l(r0, r1, rn(reg));
2943         jit_unget_reg(reg);
2944     }
2945 }
2946 #  endif
2947
2948 static void
2949 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2950 {
2951     jit_bool_t          inv;
2952     jit_int32_t         reg;
2953     jit_word_t          lo, hi;
2954     if (can_sign_extend_short_p(i0))
2955         STB(r0, _R0_REGNO, i0);
2956     else if (can_sign_extend_int_p(i0)) {
2957         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2958         lo = (jit_int16_t)(i0 - (hi << 16));
2959         reg = jit_get_reg(jit_class_gpr);
2960         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
2961         LIS(rn(reg), hi);
2962         STB(r0, rn(reg), lo);
2963         jit_unget_reg(reg);
2964         if (inv)                        jit_unget_reg(_R0);
2965     }
2966     else {
2967         reg = jit_get_reg(jit_class_gpr);
2968         movi(rn(reg), i0);
2969         str_c(rn(reg), r0);
2970         jit_unget_reg(reg);
2971     }
2972 }
2973
2974 static void
2975 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2976 {
2977     jit_int32_t         reg;
2978     if (r0 == _R0_REGNO) {
2979         if (r1 != _R0_REGNO)
2980             STBX(r2, r1, r0);
2981         else {
2982             reg = jit_get_reg(jit_class_gpr);
2983             movr(rn(reg), r0);
2984             STBX(r2, rn(reg), r1);
2985             jit_unget_reg(reg);
2986         }
2987     }
2988     else
2989         STBX(r2, r0, r1);
2990 }
2991
2992 static void
2993 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2994 {
2995     jit_int32_t         reg;
2996     if (i0 == 0)
2997         str_c(r0, r1);
2998     else if (can_sign_extend_short_p(i0)) {
2999         if (r0 == _R0_REGNO) {
3000             reg = jit_get_reg(jit_class_gpr);
3001             movr(rn(reg), i0);
3002             STB(r1, rn(reg), i0);
3003             jit_unget_reg(reg);
3004         }
3005         else
3006             STB(r1, r0, i0);
3007     }
3008     else {
3009         reg = jit_get_reg(jit_class_gpr);
3010         movi(rn(reg), i0);
3011         stxr_c(rn(reg), r0, r1);
3012         jit_unget_reg(reg);
3013     }
3014 }
3015
3016 static void
3017 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3018 {
3019     jit_bool_t          inv;
3020     jit_int32_t         reg;
3021     jit_word_t          lo, hi;
3022     if (can_sign_extend_short_p(i0))
3023         STH(r0, _R0_REGNO, i0);
3024     else if (can_sign_extend_int_p(i0)) {
3025         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3026         lo = (jit_int16_t)(i0 - (hi << 16));
3027         reg = jit_get_reg(jit_class_gpr);
3028         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
3029         LIS(rn(reg), hi);
3030         STH(r0, rn(reg), lo);
3031         jit_unget_reg(reg);
3032         if (inv)                        jit_unget_reg(_R0);
3033     }
3034     else {
3035         reg = jit_get_reg(jit_class_gpr);
3036         movi(rn(reg), i0);
3037         str_s(rn(reg), r0);
3038         jit_unget_reg(reg);
3039     }
3040 }
3041
3042 static void
3043 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3044 {
3045     jit_int32_t         reg;
3046     if (r0 == _R0_REGNO) {
3047         if (r1 != _R0_REGNO)
3048             STHX(r2, r1, r0);
3049         else {
3050             reg = jit_get_reg(jit_class_gpr);
3051             movr(rn(reg), r0);
3052             STHX(r2, rn(reg), r1);
3053             jit_unget_reg(reg);
3054         }
3055     }
3056     else
3057         STHX(r2, r0, r1);
3058 }
3059
3060 static void
3061 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3062 {
3063     jit_int32_t         reg;
3064     if (i0 == 0)
3065         str_s(r0, r1);
3066     else if (can_sign_extend_short_p(i0)) {
3067         if (r0 == _R0_REGNO) {
3068             reg = jit_get_reg(jit_class_gpr);
3069             movr(rn(reg), i0);
3070             STH(r1, rn(reg), i0);
3071             jit_unget_reg(reg);
3072         }
3073         else
3074             STH(r1, r0, i0);
3075     }
3076     else {
3077         reg = jit_get_reg(jit_class_gpr);
3078         movi(rn(reg), i0);
3079         stxr_s(rn(reg), r0, r1);
3080         jit_unget_reg(reg);
3081     }
3082 }
3083
3084 static void
3085 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3086 {
3087     jit_bool_t          inv;
3088     jit_int32_t         reg;
3089     jit_word_t          lo, hi;
3090     if (can_sign_extend_short_p(i0))
3091         STW(r0, _R0_REGNO, i0);
3092     else if (can_sign_extend_int_p(i0)) {
3093         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3094         lo = (jit_int16_t)(i0 - (hi << 16));
3095         reg = jit_get_reg(jit_class_gpr);
3096         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
3097         LIS(rn(reg), hi);
3098         STW(r0, rn(reg), lo);
3099         jit_unget_reg(reg);
3100         if (inv)                        jit_unget_reg(_R0);
3101     }
3102     else {
3103         reg = jit_get_reg(jit_class_gpr);
3104         movi(rn(reg), i0);
3105         str_i(rn(reg), r0);
3106         jit_unget_reg(reg);
3107     }
3108 }
3109
3110 static void
3111 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3112 {
3113     jit_int32_t         reg;
3114     if (r0 == _R0_REGNO) {
3115         if (r1 != _R0_REGNO)
3116             STWX(r2, r1, r0);
3117         else {
3118             reg = jit_get_reg(jit_class_gpr);
3119             movr(rn(reg), r0);
3120             STWX(r2, rn(reg), r1);
3121             jit_unget_reg(reg);
3122         }
3123     }
3124     else
3125         STWX(r2, r0, r1);
3126 }
3127
3128 static void
3129 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3130 {
3131     jit_int32_t         reg;
3132     if (i0 == 0)
3133         str_i(r0, r1);
3134     else if (can_sign_extend_short_p(i0)) {
3135         if (r0 == _R0_REGNO) {
3136             reg = jit_get_reg(jit_class_gpr);
3137             movr(rn(reg), i0);
3138             STW(r1, rn(reg), i0);
3139             jit_unget_reg(reg);
3140         }
3141         else
3142             STW(r1, r0, i0);
3143     }
3144     else {
3145         reg = jit_get_reg(jit_class_gpr);
3146         movi(rn(reg), i0);
3147         stxr_i(rn(reg), r0, r1);
3148         jit_unget_reg(reg);
3149     }
3150 }
3151
3152 #  if __WORDSIZE == 64
3153 static void
3154 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3155 {
3156     jit_bool_t          inv;
3157     jit_int32_t         reg;
3158     jit_word_t          lo, hi;
3159     if (can_sign_extend_short_p(i0))
3160         STD(r0, _R0_REGNO, i0);
3161     else if (can_sign_extend_int_p(i0)) {
3162         hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3163         lo = (jit_int16_t)(i0 - (hi << 16));
3164         reg = jit_get_reg(jit_class_gpr);
3165         if ((inv = reg == _R0))         reg = jit_get_reg(jit_class_gpr);
3166         LIS(rn(reg), hi);
3167         STD(r0, rn(reg), lo);
3168         jit_unget_reg(reg);
3169         if (inv)                        jit_unget_reg(_R0);
3170     }
3171     else {
3172         reg = jit_get_reg(jit_class_gpr);
3173         movi(rn(reg), i0);
3174         str_l(rn(reg), r0);
3175         jit_unget_reg(reg);
3176     }
3177 }
3178
3179 static void
3180 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3181 {
3182     jit_int32_t         reg;
3183     if (r0 == _R0_REGNO) {
3184         if (r1 != _R0_REGNO)
3185             STDX(r2, r1, r0);
3186         else {
3187             reg = jit_get_reg(jit_class_gpr);
3188             movr(rn(reg), r0);
3189             STDX(r2, rn(reg), r1);
3190             jit_unget_reg(reg);
3191         }
3192     }
3193     else
3194         STDX(r2, r0, r1);
3195 }
3196
3197 static void
3198 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3199 {
3200     jit_int32_t         reg;
3201     if (i0 == 0)
3202         str_l(r0, r1);
3203     else if (can_sign_extend_short_p(i0)) {
3204         if (r0 == _R0_REGNO) {
3205             reg = jit_get_reg(jit_class_gpr);
3206             movr(rn(reg), i0);
3207             STD(r1, rn(reg), i0);
3208             jit_unget_reg(reg);
3209         }
3210         else
3211             STD(r1, r0, i0);
3212     }
3213     else {
3214         reg = jit_get_reg(jit_class_gpr);
3215         movi(rn(reg), i0);
3216         stxr_l(rn(reg), r0, r1);
3217         jit_unget_reg(reg);
3218     }
3219 }
3220 #  endif
3221
3222 static void
3223 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3224 {
3225 #if 0
3226     MTLR(r0);
3227     BLR();
3228 #else
3229     MTCTR(r0);
3230     BCTR();
3231 #endif
3232 }
3233
3234 /* pc relative jump */
3235 static jit_word_t
3236 _jmpi(jit_state_t *_jit, jit_word_t i0)
3237 {
3238     jit_int32_t         reg;
3239     jit_word_t          w, d;
3240     w = _jit->pc.w;
3241     d = (i0 - w) & ~3;
3242     if (can_sign_extend_jump_p(d))
3243         B(d);
3244     else {
3245         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3246         w = movi_p(rn(reg), i0);
3247         jmpr(rn(reg));
3248         jit_unget_reg(reg);
3249     }
3250     return (w);
3251 }
3252
3253 /* absolute jump */
3254 static jit_word_t
3255 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3256 {
3257     jit_word_t          w;
3258     jit_int32_t         reg;
3259     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3260     w = movi_p(rn(reg), i0);
3261     jmpr(rn(reg));
3262     jit_unget_reg(reg);
3263     return (w);
3264 }
3265
3266 static void
3267 _callr(jit_state_t *_jit, jit_int32_t r0
3268 #  if _CALL_SYSV
3269        , jit_int32_t varargs
3270 #  endif
3271        )
3272 {
3273 #  if _CALL_AIXDESC
3274     stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3275     /* FIXME Pretend to not know about r11? */
3276     if (r0 == _R0_REGNO) {
3277         movr(_R11_REGNO, _R0_REGNO);
3278         ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3279         ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3280     }
3281     else {
3282         ldxi(_R2_REGNO, r0, sizeof(void*));
3283         ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3284     }
3285     ldr(r0, r0);
3286 #  else
3287 #    if _CALL_SYSV
3288     /* Tell double arguments were passed in registers. */
3289     if (varargs)
3290         CREQV(6, 6, 6);
3291 #    endif
3292     movr(_R12_REGNO, r0);
3293 #  endif
3294
3295     MTCTR(r0);
3296     BCTRL();
3297
3298 #  if _CALL_AIXDESC
3299     ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3300 #  endif
3301 }
3302
3303 /* assume fixed address or reachable address */
3304 static void
3305 _calli(jit_state_t *_jit, jit_word_t i0
3306 #  if _CALL_SYSV
3307        , jit_int32_t varargs
3308 #  endif
3309        )
3310 {
3311 #  if _CALL_SYSV
3312     jit_word_t          d;
3313     d = (i0 - _jit->pc.w - !!varargs * 4) & ~3;
3314     if (can_sign_extend_jump_p(d)) {
3315         /* Tell double arguments were passed in registers. */
3316         if (varargs)
3317             CREQV(6, 6, 6);
3318         BL(d);
3319     } else
3320 #  endif
3321     {
3322         movi(_R12_REGNO, i0);
3323         callr(_R12_REGNO
3324 #  if _CALL_SYSV
3325               , varargs
3326 #  endif
3327               );
3328     }
3329 }
3330
3331 /* absolute jump */
3332 static jit_word_t
3333 _calli_p(jit_state_t *_jit, jit_word_t i0
3334 #  if _CALL_SYSV
3335        , jit_int32_t varargs
3336 #  endif
3337          )
3338 {
3339     jit_word_t          w;
3340     w = movi_p(_R12_REGNO, i0);
3341     callr(_R12_REGNO
3342 #  if _CALL_SYSV
3343           , varargs
3344 #  endif
3345           );
3346     return (w);
3347 }
3348
3349 /* order is not guaranteed to be sequential */
3350 static jit_int32_t save[] = {
3351     _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3352     _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3353 };
3354
3355 static void
3356 _prolog(jit_state_t *_jit, jit_node_t *node)
3357 {
3358     unsigned long       regno;
3359     jit_word_t          offset;
3360
3361     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3362         jit_int32_t     frame = -_jitc->function->frame;
3363         assert(_jitc->function->self.aoff >= frame);
3364         if (_jitc->function->assume_frame)
3365             return;
3366         _jitc->function->self.aoff = frame;
3367     }
3368     if (_jitc->function->allocar) {
3369         _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3370         _jitc->function->self.aoff &= -16;
3371     }
3372     _jitc->function->stack = ((_jitc->function->self.alen +
3373                               _jitc->function->self.size -
3374                               _jitc->function->self.aoff) + 15) & -16;
3375
3376     /* return address */
3377     MFLR(_R0_REGNO);
3378
3379     /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3380      * alloca <  %r31-80 */
3381
3382 #if _CALL_SYSV
3383     stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3384 #else
3385     stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3386 #endif
3387     offset = -gpr_save_area;
3388     for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3389         if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3390             stxi(offset, _SP_REGNO, rn(save[regno]));
3391     }
3392     for (offset = 0; offset < 8; offset++) {
3393         if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3394             stxi_d(-(gpr_save_area + 8 + offset * 8),
3395                    _SP_REGNO, rn(_F14 + offset));
3396     }
3397
3398     stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3399
3400     movr(_FP_REGNO, _SP_REGNO);
3401 #if __WORDSIZE == 32
3402     STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3403 #else
3404     STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3405 #endif
3406
3407     if (_jitc->function->allocar) {
3408         regno = jit_get_reg(jit_class_gpr);
3409         movi(rn(regno), _jitc->function->self.aoff);
3410         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3411         jit_unget_reg(regno);
3412     }
3413
3414 #if !_CALL_SYSV
3415     if (_jitc->function->self.call & jit_call_varargs) {
3416         for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3417             stxi(params_offset + regno * sizeof(jit_word_t),
3418                  _FP_REGNO, rn(JIT_RA0 - regno));
3419     }
3420 #else
3421     if (_jitc->function->self.call & jit_call_varargs) {
3422         for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3423             stxi(_jitc->function->vaoff + first_gp_offset +
3424                  regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3425         for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3426             stxi_d(_jitc->function->vaoff + first_fp_offset +
3427                    regno * va_fp_increment, _FP_REGNO,
3428                    rn(JIT_FA0 - regno));
3429     }
3430 #endif
3431 }
3432
3433 static void
3434 _epilog(jit_state_t *_jit, jit_node_t *node)
3435 {
3436     unsigned long       regno;
3437     jit_word_t          offset;
3438
3439     if (_jitc->function->assume_frame)
3440         return;
3441     if (_jitc->function->allocar)
3442         ldr(_SP_REGNO, _SP_REGNO);
3443     else
3444         addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3445 #if _CALL_SYSV
3446     ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3447 #else
3448     ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3449 #endif
3450     offset = -gpr_save_area;
3451     for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3452         if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3453             ldxi(rn(save[regno]), _SP_REGNO, offset);
3454     }
3455     for (offset = 0; offset < 8; offset++) {
3456         if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3457             ldxi_d(rn(_F14 + offset), _SP_REGNO,
3458                    -(gpr_save_area + 8 + offset * 8));
3459     }
3460
3461     MTLR(_R0_REGNO);
3462     ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3463
3464     BLR();
3465 }
3466
3467 static void
3468 _vastart(jit_state_t *_jit, jit_int32_t r0)
3469 {
3470 #if !_CALL_SYSV
3471     assert(_jitc->function->self.call & jit_call_varargs);
3472     /* Initialize stack pointer to the first stack argument. */
3473     addi(r0, _FP_REGNO, _jitc->function->self.size);
3474 #else
3475     jit_int32_t         reg;
3476     assert(_jitc->function->self.call & jit_call_varargs);
3477
3478     /* Return jit_va_list_t in the register argument */
3479     addi(r0, _FP_REGNO, _jitc->function->vaoff);
3480     reg = jit_get_reg(jit_class_gpr);
3481
3482     /* Initialize the gp counter. */
3483     movi(rn(reg), _jitc->function->vagp);
3484     stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3485
3486     /* Initialize the fp counter. */
3487     movi(rn(reg), _jitc->function->vafp);
3488     stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3489
3490     /* Initialize overflow pointer to the first stack argument. */
3491     addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3492     stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3493
3494     /* Initialize register save area pointer. */
3495     addi(rn(reg), r0, first_gp_offset);
3496     stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3497
3498     jit_unget_reg(reg);
3499 #endif
3500 }
3501
3502 static void
3503 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3504 {
3505 #if !_CALL_SYSV
3506     assert(_jitc->function->self.call & jit_call_varargs);
3507     /* Load argument. */
3508     ldr(r0, r1);
3509     /* Update va_list. */
3510     addi(r1, r1, sizeof(jit_word_t));
3511 #else
3512     jit_int32_t         rg0;
3513     jit_int32_t         rg1;
3514     jit_word_t          ge_code;
3515     jit_word_t          lt_code;
3516
3517     assert(_jitc->function->self.call & jit_call_varargs);
3518
3519     rg0 = jit_get_reg(jit_class_gpr);
3520     rg1 = jit_get_reg(jit_class_gpr);
3521
3522     /* Load the gp offset in save area in the first temporary. */
3523     ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3524
3525     /* Jump over if there are no remaining arguments in the save area. */
3526     ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3527
3528     /* Update the gp counter. */
3529     addi(rn(rg1), rn(rg0), 1);
3530     stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3531
3532     /* Load the save area pointer in the second temporary. */
3533     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3534
3535     /* Load the vararg argument in the first argument. */
3536     lshi(rn(rg0), rn(rg0), va_gp_shift);
3537     ldxr(r0, rn(rg1), rn(rg0));
3538
3539     /* Will only need one temporary register below. */
3540     jit_unget_reg(rg1);
3541
3542     /* Jump over overflow code. */
3543     lt_code = _jit->pc.w;
3544     B(0);
3545
3546     /* Where to land if argument is in overflow area. */
3547     patch_at(ge_code, _jit->pc.w);
3548
3549     /* Load overflow pointer. */
3550     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3551
3552     /* Load argument. */
3553     ldr(r0, rn(rg0));
3554
3555     /* Update overflow pointer. */
3556     addi(rn(rg0), rn(rg0), va_gp_increment);
3557     stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3558
3559     /* Where to land if argument is in save area. */
3560     patch_at(lt_code, _jit->pc.w);
3561
3562     jit_unget_reg(rg0);
3563 #endif
3564 }
3565
3566 static void
3567 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3568 {
3569 #if !_CALL_SYSV
3570     assert(_jitc->function->self.call & jit_call_varargs);
3571     /* Load argument. */
3572     ldr_d(r0, r1);
3573     /* Update va_list. */
3574     addi(r1, r1, sizeof(jit_float64_t));
3575 #else
3576     jit_int32_t         rg0;
3577     jit_int32_t         rg1;
3578     jit_word_t          ge_code;
3579     jit_word_t          lt_code;
3580
3581     assert(_jitc->function->self.call & jit_call_varargs);
3582
3583     rg0 = jit_get_reg(jit_class_gpr);
3584     rg1 = jit_get_reg(jit_class_gpr);
3585
3586     /* Load the fp offset in save area in the first temporary. */
3587     ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3588
3589     /* Jump over if there are no remaining arguments in the save area. */
3590     ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3591
3592     /* Update the fp counter. */
3593     addi(rn(rg1), rn(rg0), 1);
3594     stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3595
3596     /* Load the save area pointer in the second temporary. */
3597     ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3598
3599     /* Load the vararg argument in the first argument. */
3600     lshi(rn(rg0), rn(rg0), 3);
3601     addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3602          offsetof(jit_va_list_t, first_gp_argument));
3603     ldxr_d(r0, rn(rg1), rn(rg0));
3604
3605     /* Jump over overflow code. */
3606     lt_code = _jit->pc.w;
3607     B(0);
3608
3609     /* Where to land if argument is in overflow area. */
3610     patch_at(ge_code, _jit->pc.w);
3611
3612     /* Load overflow pointer. */
3613     ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3614
3615 #  if __WORDSIZE == 32
3616     /* Align if required. */
3617     andi(rn(rg1), rn(rg0), 7);
3618     addr(rn(rg0), rn(rg0), rn(rg1));
3619 #  endif
3620
3621     /* Load argument. */
3622     ldr_d(r0, rn(rg0));
3623
3624     /* Update overflow pointer. */
3625     addi(rn(rg0), rn(rg0), va_fp_increment);
3626     stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3627
3628     /* Where to land if argument is in save area. */
3629     patch_at(lt_code, _jit->pc.w);
3630
3631     jit_unget_reg(rg0);
3632     jit_unget_reg(rg1);
3633 #endif
3634 }
3635
3636 static void
3637 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3638 {
3639     jit_word_t           d;
3640     union {
3641         jit_int32_t     *i;
3642         jit_word_t       w;
3643     } u;
3644     u.w = instr;
3645     switch ((u.i[0] & 0xfc000000) >> 26) {
3646         case 16:                                        /* BCx */
3647             d = label - instr;
3648             assert(!(d & 3));
3649             if (!can_sign_extend_short_p(d)) {
3650                 /* use absolute address */
3651                 assert(can_sign_extend_short_p(label));
3652                 d |= 2;
3653             }
3654             u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3655             break;
3656         case 18:                                        /* Bx */
3657 #if _CALL_AIXDESC
3658             if (_jitc->jump && (!(u.i[0] & 1))) {       /* jmpi label */
3659                 /* zero is used for toc and env, so, quick check
3660                  * if this is a "jmpi main" like initial jit
3661                  * instruction */
3662                 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3663                     for (d = 0; d < _jitc->prolog.offset; d++) {
3664                         /* not so pretty, but hides powerpc
3665                          * specific abi intrinsics and/or
3666                          * implementation from user */
3667                         if (_jitc->prolog.ptr[d] == label) {
3668                             label += sizeof(void*) * 3;
3669                             break;
3670                         }
3671                     }
3672                 }
3673             }
3674 #endif
3675             d = label - instr;
3676             assert(!(d & 3));
3677             if (!can_sign_extend_jump_p(d)) {
3678                 /* use absolute address */
3679                 assert(can_sign_extend_jump_p(label));
3680                 d |= 2;
3681             }
3682             u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3683             break;
3684         case 15:                                        /* LI */
3685 #if __WORDSIZE == 32
3686 #  define MTCTR_OFF             2
3687 #  define BCTR_OFF              3
3688 #else
3689 #  define MTCTR_OFF             6
3690 #  define BCTR_OFF              7
3691 #endif
3692 #if _CALL_AIXDESC
3693             /* movi reg label; jmpr reg */
3694             if (_jitc->jump &&
3695 #if 0
3696                 /* check for MLTR(reg) */
3697                 (u.i[MTCTR_OFF] >> 26) == 31 &&
3698                 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3699                 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3700                 /* check for BLR */
3701                 u.i[BCTR_OFF] == 0x4e800020) {
3702 #else
3703                 /* check for MTCTR(reg) */
3704                 (u.i[MTCTR_OFF] >> 26) == 31 &&
3705                 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3706                 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3707                 /* check for BCTR */
3708                 u.i[BCTR_OFF] == 0x4e800420) {
3709 #endif
3710                 /* zero is used for toc and env, so, quick check
3711                  * if this is a "jmpi main" like initial jit
3712                  * instruction */
3713                 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3714                     for (d = 0; d < _jitc->prolog.offset; d++) {
3715                         /* not so pretty, but hides powerpc
3716                          * specific abi intrinsics and/or
3717                          * implementation from user */
3718                         if (_jitc->prolog.ptr[d] == label) {
3719                             label += sizeof(void*) * 3;
3720                             break;
3721                         }
3722                     }
3723                 }
3724             }
3725 #endif
3726 #undef BCTR_OFF
3727 #undef MTCTR_OFF
3728 #if __WORDSIZE == 32
3729             assert(!(u.i[0] & 0x1f0000));
3730             u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3731             assert((u.i[1] & 0xfc000000) >> 26 == 24);  /* ORI */
3732             assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3733             u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3734 #else
3735             assert(!(u.i[0] & 0x1f0000));
3736             u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3737             assert((u.i[1] & 0xfc000000) >> 26 == 24);  /* ORI */
3738             assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3739             u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3740             /* not fully validating SLDI */
3741             assert((u.i[2] & 0xfc000000) >> 26 == 30);  /* SLDI */
3742             assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3743             assert((u.i[3] & 0xfc000000) >> 26 == 24);  /* ORI */
3744             assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3745             u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3746             /* not fully validating SLDI */
3747             assert((u.i[4] & 0xfc000000) >> 26 == 30);  /* SLDI */
3748             assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3749             assert((u.i[5] & 0xfc000000) >> 26 == 24);  /* ORI */
3750             assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3751             u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3752 #endif
3753             break;
3754         default:
3755             assert(!"unhandled branch opcode");
3756     }
3757 }
3758 #endif