deps/lightning/lib/jit_ppc-cpu.c

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