deps/lightning/lib/jit_ppc-cpu.c

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