deps/lightning/lib/jit_ppc-cpu.c

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