deps/lightning/lib/jit_ppc-cpu.c

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