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