deps/lightning/lib/jit_mips-cpu.c

   1 /*
   2  * Copyright (C) 2012-2019  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 typedef union {
  22 #if __BYTE_ORDER == __LITTLE_ENDIAN
  23     struct {    jit_uint32_t _:26;      jit_uint32_t b :  6; } hc;
  24     struct {    jit_uint32_t _:21;      jit_uint32_t b :  5; } rs;
  25     struct {    jit_uint32_t _:21;      jit_uint32_t b :  5; } fm;
  26     struct {    jit_uint32_t _:16;      jit_uint32_t b :  5; } rt;
  27     struct {    jit_uint32_t _:16;      jit_uint32_t b :  5; } ft;
  28     struct {    jit_uint32_t _:11;      jit_uint32_t b :  5; } rd;
  29     struct {    jit_uint32_t _:11;      jit_uint32_t b :  5; } fs;
  30     struct {    jit_uint32_t _: 6;      jit_uint32_t b :  5; } ic;
  31     struct {    jit_uint32_t _: 6;      jit_uint32_t b :  5; } fd;
  32     struct {    jit_uint32_t _: 6;      jit_uint32_t b : 10; } tr;
  33     struct {    jit_uint32_t _: 6;      jit_uint32_t b : 20; } br;
  34     struct {                            jit_uint32_t b :  6; } tc;
  35     struct {                            jit_uint32_t b : 11; } cc;
  36     struct {                            jit_uint32_t b : 16; } is;
  37     struct {                            jit_uint32_t b : 26; } ii;
  38 #else
  39     struct {                            jit_uint32_t b :  6; } hc;
  40     struct {    jit_uint32_t _: 6;      jit_uint32_t b :  5; } rs;
  41     struct {    jit_uint32_t _: 6;      jit_uint32_t b :  5; } fm;
  42     struct {    jit_uint32_t _:11;      jit_uint32_t b :  5; } rt;
  43     struct {    jit_uint32_t _:11;      jit_uint32_t b :  5; } ft;
  44     struct {    jit_uint32_t _:16;      jit_uint32_t b :  5; } rd;
  45     struct {    jit_uint32_t _:16;      jit_uint32_t b :  5; } fs;
  46     struct {    jit_uint32_t _:21;      jit_uint32_t b :  5; } ic;
  47     struct {    jit_uint32_t _:21;      jit_uint32_t b :  5; } fd;
  48     struct {    jit_uint32_t _:21;      jit_uint32_t b : 10; } tr;
  49     struct {    jit_uint32_t _:21;      jit_uint32_t b : 20; } br;
  50     struct {    jit_uint32_t _:26;      jit_uint32_t b :  6; } tc;
  51     struct {    jit_uint32_t _:21;      jit_uint32_t b : 11; } cc;
  52     struct {    jit_uint32_t _:16;      jit_uint32_t b : 16; } is;
  53     struct {    jit_uint32_t _: 6;      jit_uint32_t b : 26; } ii;
  54 #endif
  55     int                                 op;
  56 } jit_instr_t;
  57 /* FIXME */
  58 #  define jit_mips2_p()                 0
  59 #  define _ZERO_REGNO                   0
  60 #  define _T0_REGNO                     0x08
  61 #  define _T1_REGNO                     0x09
  62 #  define _T2_REGNO                     0x0a
  63 #  define _T3_REGNO                     0x0b
  64 #  define _T4_REGNO                     0x0c
  65 #  define _T5_REGNO                     0x0d
  66 #  define _T6_REGNO                     0x0e
  67 #  define _T7_REGNO                     0x0f
  68 #  define _S0_REGNO                     0x10
  69 #  define _S1_REGNO                     0x11
  70 #  define _S2_REGNO                     0x12
  71 #  define _S3_REGNO                     0x13
  72 #  define _S4_REGNO                     0x14
  73 #  define _S5_REGNO                     0x15
  74 #  define _S6_REGNO                     0x16
  75 #  define _S7_REGNO                     0x17
  76 #  define _T8_REGNO                     0x18
  77 #  define _T9_REGNO                     0x19
  78 #  define _SP_REGNO                     0x1d
  79 #  define _BP_REGNO                     0x1e
  80 #  define _RA_REGNO                     0x1f
  81 #  define _F16_REGNO                    16
  82 #  define _F18_REGNO                    18
  83 #  define _F20_REGNO                    20
  84 #  define _F22_REGNO                    22
  85 #  define _F24_REGNO                    24
  86 #  define _F26_REGNO                    26
  87 #  define _F28_REGNO                    28
  88 #  define _F30_REGNO                    30
  89 #  if __WORDSIZE == 32
  90 #    if NEW_ABI
  91 #      define stack_framesize           144
  92 #    else
  93 #      define stack_framesize           112
  94 #    endif
  95 #    define ldr(u,v)                    ldr_i(u,v)
  96 #    define ldi(u,v)                    ldi_i(u,v)
  97 #    define ldxi(u,v,w)                 ldxi_i(u,v,w)
  98 #    define sti(u,v)                    sti_i(u,v)
  99 #    define stxi(u,v,w)                 stxi_i(u,v,w)
 100 #  else
 101 #    define stack_framesize             144
 102 #    define ldr(u,v)                    ldr_l(u,v)
 103 #    define ldi(u,v)                    ldi_l(u,v)
 104 #    define ldxi(u,v,w)                 ldxi_l(u,v,w)
 105 #    define sti(u,v)                    sti_l(u,v)
 106 #    define stxi(u,v,w)                 stxi_l(u,v,w)
 107 #  endif
 108 #  define can_sign_extend_short_p(im)   ((im) >= -32678 && (im) <= 32767)
 109 #  define can_zero_extend_short_p(im)   ((im) >= 0 && (im) <= 65535)
 110 #  define is_low_mask(im)               (((im) & 1) ? (__builtin_popcountl((im) + 1) == 1) : 0)
 111 #  define is_high_mask(im)              ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) == 0) : 0)
 112 #  define masked_bits_count(im)         __builtin_popcountl(im)
 113 #  define unmasked_bits_count(im)       (__WORDSIZE - masked_bits_count(im))
 114 #  if __WORDSIZE == 32
 115 #    define can_sign_extend_int_p(im)   1
 116 #    define can_zero_extend_int_p(im)   1
 117 #  else
 118 #    define can_sign_extend_int_p(im)                                   \
 119         (((im) >= 0 && (im) <=  0x7fffffffL) ||                         \
 120          ((im) <  0 && (im) >= -0x80000000L))
 121 #    define can_zero_extend_int_p(im)   ((im) >= 0 && (im) <= 0xffffffff)
 122 #  endif
 123 #  define MIPS_SPECIAL                  0x00
 124 #  define MIPS_REGIMM                   0x01
 125 #  define MIPS_J                        0x02
 126 #  define MIPS_SRL                      0x02
 127 #  define MIPS_JAL                      0x03
 128 #  define MIPS_SRA                      0x03
 129 #  define MIPS_BEQ                      0x04
 130 #  define MIPS_BNE                      0x05
 131 #  define MIPS_BLEZ                     0x06
 132 #  define MIPS_BGTZ                     0x07
 133 #  define MIPS_ADDI                     0x08
 134 #  define MIPS_ADDIU                    0x09
 135 #  define MIPS_SLTI                     0x0a
 136 #  define MIPS_SLTIU                    0x0b
 137 #  define MIPS_ANDI                     0x0c
 138 #  define MIPS_ORI                      0x0d
 139 #  define MIPS_XORI                     0x0e
 140 #  define MIPS_LUI                      0x0f
 141 #  define MIPS_COP0                     0x10
 142 #  define MIPS_COP1                     0x11
 143 #  define MIPS_COP2                     0x12
 144 #  define MIPS_COP1X                    0x13
 145 #  define MIPS_BEQL                     0x14
 146 #  define MIPS_BNEL                     0x15
 147 #  define MIPS_BLEZL                    0x16
 148 #  define MIPS_BGTZL                    0x17
 149 #  define MIPS_DADDI                    0x18
 150 #  define MIPS_DADDIU                   0x19
 151 #  define MIPS_LDL                      0x1a
 152 #  define MIPS_LDR                      0x1b
 153 #  define MIPS_SPECIAL2                 0x1c
 154 #  define MIPS_JALX                     0x1d
 155 #  define MIPS_SPECIAL3                 0x1f
 156 #  define MIPS_LB                       0x20
 157 #  define MIPS_LH                       0x21
 158 #  define MIPS_LWL                      0x22
 159 #  define MIPS_LW                       0x23
 160 #  define MIPS_LBU                      0x24
 161 #  define MIPS_LHU                      0x25
 162 #  define MIPS_LWR                      0x26
 163 #  define MIPS_LWU                      0x27
 164 #  define MIPS_SB                       0x28
 165 #  define MIPS_SH                       0x29
 166 #  define MIPS_SWL                      0x2a
 167 #  define MIPS_SW                       0x2b
 168 #  define MIPS_SWR                      0x2e
 169 #  define MIPS_CACHE                    0x2f
 170 #  define MIPS_LL                       0x30
 171 #  define MIPS_LWC1                     0x31
 172 #  define MIPS_LWC2                     0x32
 173 #  define MIPS_PREF                     0x33
 174 #  define MIPS_LLD                      0x34
 175 #  define MIPS_LDC1                     0x35
 176 #  define MIPS_LDC2                     0x36
 177 #  define MIPS_LD                       0x37
 178 #  define MIPS_SC                       0x38
 179 #  define MIPS_SCD                      0x3c
 180 #  define MIPS_SDC1                     0x3d
 181 #  define MIPS_SDC2                     0x3e
 182 #  define MIPS_SWC1                     0x39
 183 #  define MIPS_SWC2                     0x3a
 184 #  define MIPS_SD                       0x3f
 185 #  define MIPS_MF                       0x00
 186 #  define MIPS_DMF                      0x01
 187 #  define MIPS_CF                       0x02
 188 #  define MIPS_MFH                      0x03
 189 #  define MIPS_MT                       0x04
 190 #  define MIPS_DMT                      0x05
 191 #  define MIPS_CT                       0x06
 192 #  define MIPS_MTH                      0x07
 193 #  define MIPS_BC                       0x08
 194 #  define MIPS_WRPGPR                   0x0e
 195 #  define MIPS_BGZAL                    0x11
 196 #  define MIPS_MFMC0                    0x11
 197 #  define MIPS_BCF                      0x00
 198 #  define MIPS_BLTZ                     0x00
 199 #  define MIPS_BCT                      0x01
 200 #  define MIPS_BGEZ                     0x01
 201 #  define MIPS_BCFL                     0x02
 202 #  define MIPS_BLTZL                    0x02
 203 #  define MIPS_BCTL                     0x03
 204 #  define MIPS_BGEZL                    0x03
 205 #  define MIPS_TGEI                     0x08
 206 #  define MIPS_TGEIU                    0x09
 207 #  define MIPS_TLTI                     0x0a
 208 #  define MIPS_TLTIU                    0x0b
 209 #  define MIPS_TEQI                     0x0c
 210 #  define MIPS_TNEI                     0x0e
 211 #  define MIPS_BLTZAL                   0x10
 212 #  define MIPS_BGEZAL                   0x11
 213 #  define MIPS_BLTZALL                  0x12
 214 #  define MIPS_BGEZALL                  0x13
 215 #  define MIPS_SYNCI                    0x1f
 216 #  define MIPS_WSBH                     0x02
 217 #  define MIPS_DBSH                     0x02
 218 #  define MIPS_DSHD                     0x05
 219 #  define MIPS_SEB                      0x10
 220 #  define MIPS_SEH                      0x18
 221 #  define MIPS_MADD                     0x00
 222 #  define MIPS_SLL                      0x00
 223 #  define MIPS_EXT                      0x00
 224 #  define MIPS_DEXTM                    0x01
 225 #  define MIPS_MADDU                    0x01
 226 #  define MIPS_MOVFT                    0x01
 227 #  define MIPS_TLBR                     0x01
 228 #  define MIPS_MUL                      0x02
 229 #  define MIPS_DEXTU                    0x02
 230 #  define MIPS_TLBWI                    0x02
 231 #  define MIPS_DEXT                     0x03
 232 #  define MIPS_SLLV                     0x04
 233 #  define MIPS_INS                      0x04
 234 #  define MIPS_MSUB                     0x04
 235 #  define MIPS_DINSM                    0x05
 236 #  define MIPS_MSUBU                    0x05
 237 #  define MIPS_SRLV                     0x06
 238 #  define MIPS_DINSU                    0x06
 239 #  define MIPS_TLBWR                    0x06
 240 #  define MIPS_SRAV                     0x07
 241 #  define MIPS_DINS                     0x07
 242 #  define MIPS_JR                       0x08
 243 #  define MIPS_TLBP                     0x08
 244 #  define MIPS_JALR                     0x09
 245 #  define MIPS_MOVZ                     0x0a
 246 #  define MIPS_MOVN                     0x0b
 247 #  define MIPS_SYSCALL                  0x0c
 248 #  define MIPS_BREAK                    0x0d
 249 #  define MIPS_PREFX                    0x0f
 250 #  define MIPS_SYNC                     0x0f
 251 #  define MIPS_MFHI                     0x10
 252 #  define MIPS_MTHI                     0x11
 253 #  define MIPS_MFLO                     0x12
 254 #  define MIPS_MTLO                     0x13
 255 #  define MIPS_DSLLV                    0x14
 256 #  define MIPS_DSRLV                    0x16
 257 #  define MIPS_DSRAV                    0x17
 258 #  define MIPS_MULT                     0x18
 259 #  define MIPS_ERET                     0x18
 260 #  define MIPS_MULTU                    0x19
 261 #  define MIPS_DIV                      0x1a
 262 #  define MIPS_DIVU                     0x1b
 263 #  define MIPS_DMULT                    0x1c
 264 #  define MIPS_DMULTU                   0x1d
 265 #  define MIPS_DDIV                     0x1e
 266 #  define MIPS_DDIVU                    0x1f
 267 #  define MIPS_DERET                    0x1f
 268 #  define MIPS_ADD                      0x20
 269 #  define MIPS_CLZ                      0x20
 270 #  define MIPS_BSHFL                    0x20
 271 #  define MIPS_ADDU                     0x21
 272 #  define MIPS_CLO                      0x21
 273 #  define MIPS_SUB                      0x22
 274 #  define MIPS_SUBU                     0x23
 275 #  define MIPS_AND                      0x24
 276 #  define MIPS_DCLZ                     0x24
 277 #  define MIPS_DBSHFL                   0x24
 278 #  define MIPS_OR                       0x25
 279 #  define MIPS_DCLO                     0x25
 280 #  define MIPS_XOR                      0x26
 281 #  define MIPS_NOR                      0x27
 282 #  define MIPS_SLT                      0x2a
 283 #  define MIPS_SLTU                     0x2b
 284 #  define MIPS_DADD                     0x2c
 285 #  define MIPS_DADDU                    0x2d
 286 #  define MIPS_DSUB                     0x2e
 287 #  define MIPS_DSUBU                    0x2f
 288 #  define MIPS_TGE                      0x30
 289 #  define MIPS_TGEU                     0x31
 290 #  define MIPS_TLT                      0x32
 291 #  define MIPS_TLTU                     0x33
 292 #  define MIPS_TEQ                      0x34
 293 #  define MIPS_TNE                      0x36
 294 #  define MIPS_DSLL                     0x38
 295 #  define MIPS_DSRL                     0x3a
 296 #  define MIPS_DSRA                     0x3b
 297 #  define MIPS_DSLL32                   0x3c
 298 #  define MIPS_DSRL32                   0x3e
 299 #  define MIPS_DSRA32                   0x3f
 300 #  define MIPS_SDBPP                    0x3f
 301 #  define ii(i)                         *_jit->pc.ui++ = i
 302 static void
 303 _hrrrit(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
 304         jit_int32_t,jit_int32_t);
 305 #  define hrrrit(hc,rs,rt,rd,im,tc)     _hrrrit(_jit,hc,rs,rt,rd,im,tc)
 306 #  define hrrr_t(hc,rs,rt,rd,tc)        hrrrit(hc,rs,rt,rd,0,tc)
 307 #  define rrr_t(rs,rt,rd,tc)            hrrr_t(0,rs,rt,rd,tc)
 308 #  define hrri(hc,rs,rt,im)             _hrri(_jit,hc,rs,rt,im)
 309 static void _hrri(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 310 #  define hi(hc,im)                     _hi(_jit,hc,im)
 311 static void _hi(jit_state_t*,jit_int32_t,jit_int32_t);
 312 #  define NOP(i0)                       ii(0)
 313 #  define nop(i0)                       _nop(_jit,i0)
 314 static void _nop(jit_state_t*,jit_int32_t);
 315 #  define h_ri(hc,rt,im)                _hrri(_jit,hc,0,rt,im)
 316 #  define rrit(rt,rd,im,tc)             _hrrrit(_jit,0,0,rt,rd,im,tc)
 317 #  define LUI(rt,im)                    h_ri(MIPS_LUI,rt,im)
 318 #  define ADDU(rd,rs,rt)                rrr_t(rs,rt,rd,MIPS_ADDU)
 319 #  define DADDU(rd,rs,rt)               rrr_t(rs,rt,rd,MIPS_DADDU)
 320 #  define ADDIU(rt,rs,im)               hrri(MIPS_ADDIU,rs,rt,im)
 321 #  define DADDIU(rt,rs,im)              hrri(MIPS_DADDIU,rs,rt,im)
 322 #  define SUBU(rd,rs,rt)                rrr_t(rs,rt,rd,MIPS_SUBU)
 323 #  define DSUBU(rd,rs,rt)               rrr_t(rs,rt,rd,MIPS_DSUBU)
 324 #  define MULT(rs,rt)                   rrr_t(rs,rt,_ZERO_REGNO,MIPS_MULT)
 325 #  define MULTU(rs,rt)                  rrr_t(rs,rt,_ZERO_REGNO,MIPS_MULTU)
 326 #  define DMULT(rs,rt)                  rrr_t(rs,rt,_ZERO_REGNO,MIPS_DMULT)
 327 #  define DMULTU(rs,rt)                 rrr_t(rs,rt,_ZERO_REGNO,MIPS_DMULTU)
 328 #  define DIV(rs,rt)                    rrr_t(rs,rt,_ZERO_REGNO,MIPS_DIV)
 329 #  define DIVU(rs,rt)                   rrr_t(rs,rt,_ZERO_REGNO,MIPS_DIVU)
 330 #  define DDIV(rs,rt)                   rrr_t(rs,rt,_ZERO_REGNO,MIPS_DDIV)
 331 #  define DDIVU(rs,rt)                  rrr_t(rs,rt,_ZERO_REGNO,MIPS_DDIVU)
 332 #  define SLLV(rd,rt,rs)                rrr_t(rs,rt,rd,MIPS_SLLV)
 333 #  define SLL(rd,rt,sa)                 rrit(rt,rd,sa,MIPS_SLL)
 334 #  define DSLLV(rd,rt,rs)               rrr_t(rs,rt,rd,MIPS_DSLLV)
 335 #  define DSLL(rd,rt,sa)                rrit(rt,rd,sa,MIPS_DSLL)
 336 #  define DSLL32(rd,rt,sa)              rrit(rt,rd,sa,MIPS_DSLL32)
 337 #  define SRAV(rd,rt,rs)                rrr_t(rs,rt,rd,MIPS_SRAV)
 338 #  define SRA(rd,rt,sa)                 rrit(rt,rd,sa,MIPS_SRA)
 339 #  define SRLV(rd,rt,rs)                rrr_t(rs,rt,rd,MIPS_SRLV)
 340 #  define SRL(rd,rt,sa)                 rrit(rt,rd,sa,MIPS_SRL)
 341 #  define DSRAV(rd,rt,rs)               rrr_t(rs,rt,rd,MIPS_DSRAV)
 342 #  define DSRA(rd,rt,sa)                rrit(rt,rd,sa,MIPS_DSRA)
 343 #  define DSRA32(rd,rt,sa)              rrit(rt,rd,sa,MIPS_DSRA32)
 344 #  define DSRLV(rd,rt,rs)               rrr_t(rs,rt,rd,MIPS_DSRLV)
 345 #  define DSRL(rd,rt,sa)                rrit(rt,rd,sa,MIPS_DSRL)
 346 #  define DSRL32(rd,rt,sa)              rrit(rt,rd,sa,MIPS_DSRL32)
 347 #  define INS(rt,rs,pos,size)           hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-1,pos,MIPS_INS)
 348 #  define DINS(rt,rs,pos,size)          hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-1,pos,MIPS_DINS)
 349 #  define EXT(rt,rs,pos,size)           hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos,MIPS_EXT)
 350 #  define DEXT(rt,rs,pos,size)          hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos,MIPS_DEXT)
 351 #  define ROTR(rd,rt,sa)                hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_SRL)
 352 #  define DROTR(rd,rt,sa)               hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_DSRL)
 353 #  define MFHI(rd)                      rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFHI)
 354 #  define MFLO(rd)                      rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFLO)
 355 #  define MTHI(rs)                      rrr_t(rs,_ZERO_REGNO,_ZERO_REGNO,MIPS_MTHI)
 356 #  define MTLO(rs)                      rrr_t(rs,_ZERO_REGNO,_ZERO_REGNO,MIPS_MTLO)
 357 #  define AND(rd,rs,rt)                 rrr_t(rs,rt,rd,MIPS_AND)
 358 #  define ANDI(rt,rs,im)                hrri(MIPS_ANDI,rs,rt,im)
 359 #  define OR(rd,rs,rt)                  rrr_t(rs,rt,rd,MIPS_OR)
 360 #  define ORI(rt,rs,im)                 hrri(MIPS_ORI,rs,rt,im)
 361 #  define XOR(rd,rs,rt)                 rrr_t(rs,rt,rd,MIPS_XOR)
 362 #  define XORI(rt,rs,im)                hrri(MIPS_XORI,rs,rt,im)
 363 #  define LB(rt,of,rb)                  hrri(MIPS_LB,rb,rt,of)
 364 #  define LBU(rt,of,rb)                 hrri(MIPS_LBU,rb,rt,of)
 365 #  define LH(rt,of,rb)                  hrri(MIPS_LH,rb,rt,of)
 366 #  define LHU(rt,of,rb)                 hrri(MIPS_LHU,rb,rt,of)
 367 #  define LW(rt,of,rb)                  hrri(MIPS_LW,rb,rt,of)
 368 #  define LWU(rt,of,rb)                 hrri(MIPS_LWU,rb,rt,of)
 369 #  define LD(rt,of,rb)                  hrri(MIPS_LD,rb,rt,of)
 370 #  define SB(rt,of,rb)                  hrri(MIPS_SB,rb,rt,of)
 371 #  define SH(rt,of,rb)                  hrri(MIPS_SH,rb,rt,of)
 372 #  define SW(rt,of,rb)                  hrri(MIPS_SW,rb,rt,of)
 373 #  define SD(rt,of,rb)                  hrri(MIPS_SD,rb,rt,of)
 374 #  define WSBH(rd,rt)                   hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_WSBH,MIPS_BSHFL)
 375 #  define SEB(rd,rt)                    hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEB,MIPS_BSHFL)
 376 #  define SEH(rd,rt)                    hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEH,MIPS_BSHFL)
 377 #  define SLT(rd,rs,rt)                 rrr_t(rs,rt,rd,MIPS_SLT)
 378 #  define SLTU(rd,rs,rt)                rrr_t(rs,rt,rd,MIPS_SLTU)
 379 #  define SLTI(rt,rs,im)                hrri(MIPS_SLTI,rs,rt,im)
 380 #  define SLTIU(rt,rs,im)               hrri(MIPS_SLTIU,rs,rt,im)
 381 #  define BLTZ(rs,im)                   hrri(MIPS_REGIMM,rs,MIPS_BLTZ,im)
 382 #  define BLEZ(rs,im)                   hrri(MIPS_BLEZ,rs,_ZERO_REGNO,im)
 383 #  define BEQ(rs,rt,im)                 hrri(MIPS_BEQ,rs,rt,im)
 384 #  define BGEZ(rs,im)                   hrri(MIPS_REGIMM,rs,MIPS_BGEZ,im)
 385 #  define BGTZ(rs,im)                   hrri(MIPS_BGTZ,rs,_ZERO_REGNO,im)
 386 #  define BNE(rs,rt,im)                 hrri(MIPS_BNE,rs,rt,im)
 387 #  define JALR(r0)                      hrrrit(MIPS_SPECIAL,r0,0,_RA_REGNO,0,MIPS_JALR)
 388 #  if 1 /* supports MIPS32 R6 */
 389 #   define JR(r0)                       hrrrit(MIPS_SPECIAL,r0,0,0,0,MIPS_JALR)
 390 #  else /* does not support MIPS32 R6 */
 391 #   define JR(r0)                       hrrrit(MIPS_SPECIAL,r0,0,0,0,MIPS_JR)
 392 #  endif
 393 #  define J(i0)                         hi(MIPS_J,i0)
 394 #  define MOVZ(rd,rs,rt)                hrrrit(0,rs,rt,rd,0,MIPS_MOVZ)
 395 #  define comr(r0,r1)                   xori(r0,r1,-1)
 396 #  define negr(r0,r1)                   subr(r0,_ZERO_REGNO,r1)
 397 #  if __WORDSIZE == 32
 398 #    define addr(rd,rs,rt)              ADDU(rd,rs,rt)
 399 #    define addiu(r0,r1,i0)             ADDIU(r0,r1,i0)
 400 #    define subr(rd,rs,rt)              SUBU(rd,rs,rt)
 401 #    define mult(rs,rt)                 MULT(rs,rt)
 402 #    define multu(rs,rt)                MULTU(rs,rt)
 403 #    define div(rs,rt)                  DIV(rs,rt)
 404 #    define divu(rs,rt)                 DIVU(rs,rt)
 405 #  else
 406 #    define addr(rd,rs,rt)              DADDU(rd,rs,rt)
 407 #    define addiu(r0,r1,i0)             DADDIU(r0,r1,i0)
 408 #    define subr(rd,rs,rt)              DSUBU(rd,rs,rt)
 409 #    define mult(rs,rt)                 DMULT(rs,rt)
 410 #    define multu(rs,rt)                DMULTU(rs,rt)
 411 #    define div(rs,rt)                  DDIV(rs,rt)
 412 #    define divu(rs,rt)                 DDIVU(rs,rt)
 413 #  endif
 414 #  define addi(r0,r1,i0)                _addi(_jit,r0,r1,i0)
 415 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 416 #define addcr(r0,r1,r2)                 _addcr(_jit,r0,r1,r2)
 417 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 418 #define addci(r0,r1,i0)                 _addci(_jit,r0,r1,i0)
 419 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 420 #  define addxr(r0,r1,r2)               _addxr(_jit,r0,r1,r2)
 421 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 422 #  define addxi(r0,r1,i0)               _addxi(_jit,r0,r1,i0)
 423 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 424 #  define subi(r0,r1,i0)                _subi(_jit,r0,r1,i0)
 425 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 426 #  define subcr(r0,r1,r2)               _subcr(_jit,r0,r1,r2)
 427 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 428 #  define subci(r0,r1,i0)               _subci(_jit,r0,r1,i0)
 429 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 430 #  define subxr(r0,r1,r2)               _subxr(_jit,r0,r1,r2)
 431 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 432 #  define subxi(r0,r1,i0)               _subxi(_jit,r0,r1,i0)
 433 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 434 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
 435 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 436 #  define mulr(r0,r1,r2)                _mulr(_jit,r0,r1,r2)
 437 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 438 #  define muli(r0,r1,i0)                _muli(_jit,r0,r1,i0)
 439 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 440 #  define qmulr(r0,r1,r2,r3)            iqmulr(r0,r1,r2,r3,1)
 441 #  define qmulr_u(r0,r1,r2,r3)          iqmulr(r0,r1,r2,r3,0)
 442 #  define iqmulr(r0,r1,r2,r3,cc)        _iqmulr(_jit,r0,r1,r2,r3,cc)
 443 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
 444                     jit_int32_t,jit_int32_t,jit_bool_t);
 445 #  define qmuli(r0,r1,r2,i0)            iqmuli(r0,r1,r2,i0,1)
 446 #  define qmuli_u(r0,r1,r2,i0)          iqmuli(r0,r1,r2,i0,0)
 447 #  define iqmuli(r0,r1,r2,i0,cc)        _iqmuli(_jit,r0,r1,r2,i0,cc)
 448 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
 449                     jit_int32_t,jit_word_t,jit_bool_t);
 450 #  define divr(r0,r1,r2)                _divr(_jit,r0,r1,r2)
 451 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 452 #  define divi(r0,r1,i0)                _divi(_jit,r0,r1,i0)
 453 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 454 #  define divr_u(r0,r1,r2)              _divr_u(_jit,r0,r1,r2)
 455 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 456 #  define divi_u(r0,r1,i0)              _divi_u(_jit,r0,r1,i0)
 457 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 458 #  define qdivr(r0,r1,r2,r3)            iqdivr(r0,r1,r2,r3,1)
 459 #  define qdivr_u(r0,r1,r2,r3)          iqdivr(r0,r1,r2,r3,0)
 460 #  define iqdivr(r0,r1,r2,r3,cc)        _iqdivr(_jit,r0,r1,r2,r3,cc)
 461 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
 462                     jit_int32_t,jit_int32_t,jit_bool_t);
 463 #  define qdivi(r0,r1,r2,i0)            iqdivi(r0,r1,r2,i0,1)
 464 #  define qdivi_u(r0,r1,r2,i0)          iqdivi(r0,r1,r2,i0,0)
 465 #  define iqdivi(r0,r1,r2,i0,cc)        _iqdivi(_jit,r0,r1,r2,i0,cc)
 466 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
 467                     jit_int32_t,jit_word_t,jit_bool_t);
 468 #  define remr(r0,r1,r2)                _remr(_jit,r0,r1,r2)
 469 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 470 #  define remi(r0,r1,i0)                _remi(_jit,r0,r1,i0)
 471 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 472 #  define remr_u(r0,r1,r2)              _remr_u(_jit,r0,r1,r2)
 473 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 474 #  define remi_u(r0,r1,i0)              _remi_u(_jit,r0,r1,i0)
 475 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 476 #  if __WORDSIZE == 32
 477 #    define lshr(r0,r1,r2)              SLLV(r0,r1,r2)
 478 #    define lshi(r0,r1,i0)              SLL(r0,r1,i0)
 479 #    define rshr(r0,r1,r2)              SRAV(r0,r1,r2)
 480 #    define rshi(r0,r1,i0)              SRA(r0,r1,i0)
 481 #    define rshr_u(r0,r1,r2)            SRLV(r0,r1,r2)
 482 #    define rshi_u(r0,r1,i0)            SRL(r0,r1,i0)
 483 #  else
 484 #    define lshr(r0,r1,r2)              DSLLV(r0,r1,r2)
 485 #    define lshi(r0,r1,i0)              _lshi(_jit,r0,r1,i0)
 486 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 487 #    define rshr(r0,r1,r2)              DSRAV(r0,r1,r2)
 488 #    define rshi(r0,r1,i0)              _rshi(_jit,r0,r1,i0)
 489 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 490 #    define rshr_u(r0,r1,r2)            DSRLV(r0,r1,r2)
 491 #    define rshi_u(r0,r1,i0)            _rshi_u(_jit,r0,r1,i0)
 492 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 493 #  endif
 494 #  define andr(r0,r1,r2)                AND(r0,r1,r2)
 495 #  define andi(r0,r1,i0)                _andi(_jit,r0,r1,i0)
 496 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 497 #  define orr(r0,r1,r2)                 OR(r0,r1,r2)
 498 #  define ori(r0,r1,i0)                 _ori(_jit,r0,r1,i0)
 499 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 500 #  define xorr(r0,r1,r2)                XOR(r0,r1,r2)
 501 #  define xori(r0,r1,i0)                _xori(_jit,r0,r1,i0)
 502 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 503 #  define movr(r0,r1)                   _movr(_jit,r0,r1)
 504 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
 505 #  define movi(r0,i0)                   _movi(_jit,r0,i0)
 506 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
 507 #  define movi_p(r0,i0)                 _movi_p(_jit,r0,i0)
 508 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 509 #  define ldr_c(r0,r1)                  LB(r0,0,r1)
 510 #  define ldi_c(r0,i0)                  _ldi_c(_jit,r0,i0)
 511 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
 512 #  define ldr_uc(r0,r1)                 LBU(r0,0,r1)
 513 #  define ldi_uc(r0,i0)                 _ldi_uc(_jit,r0,i0)
 514 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
 515 #  define ldr_s(r0,r1)                  LH(r0,0,r1)
 516 #  define ldi_s(r0,i0)                  _ldi_s(_jit,r0,i0)
 517 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
 518 #  define ldr_us(r0,r1)                 LHU(r0,0,r1)
 519 #  define ldi_us(r0,i0)                 _ldi_us(_jit,r0,i0)
 520 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
 521 #  define ldr_i(r0,r1)                  LW(r0,0,r1)
 522 #  define ldi_i(r0,i0)                  _ldi_i(_jit,r0,i0)
 523 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
 524 #  if __WORDSIZE == 64
 525 #    define ldr_ui(r0,r1)               LWU(r0,0,r1)
 526 #    define ldi_ui(r0,i0)               _ldi_ui(_jit,r0,i0)
 527 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
 528 #    define ldr_l(r0,r1)                LD(r0,0,r1)
 529 #    define ldi_l(r0,i0)                _ldi_l(_jit,r0,i0)
 530 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
 531 #  endif
 532 #  define ldxr_c(r0,r1,r2)              _ldxr_c(_jit,r0,r1,r2)
 533 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 534 #  define ldxi_c(r0,r1,i0)              _ldxi_c(_jit,r0,r1,i0)
 535 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 536 #  define ldxr_uc(r0,r1,r2)             _ldxr_uc(_jit,r0,r1,r2)
 537 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 538 #  define ldxi_uc(r0,r1,i0)             _ldxi_uc(_jit,r0,r1,i0)
 539 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 540 #  define ldxr_s(r0,r1,r2)              _ldxr_s(_jit,r0,r1,r2)
 541 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 542 #  define ldxi_s(r0,r1,i0)              _ldxi_s(_jit,r0,r1,i0)
 543 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 544 #  define ldxr_us(r0,r1,r2)             _ldxr_us(_jit,r0,r1,r2)
 545 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 546 #  define ldxi_us(r0,r1,i0)             _ldxi_us(_jit,r0,r1,i0)
 547 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 548 #  define ldxr_i(r0,r1,r2)              _ldxr_i(_jit,r0,r1,r2)
 549 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 550 #  define ldxi_i(r0,r1,i0)              _ldxi_i(_jit,r0,r1,i0)
 551 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 552 #  if __WORDSIZE == 64
 553 #    define ldxr_ui(r0,r1,r2)           _ldxr_ui(_jit,r0,r1,r2)
 554 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 555 #    define ldxi_ui(r0,r1,i0)           _ldxi_ui(_jit,r0,r1,i0)
 556 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 557 #    define ldxr_l(r0,r1,r2)            _ldxr_l(_jit,r0,r1,r2)
 558 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 559 #    define ldxi_l(r0,r1,i0)            _ldxi_l(_jit,r0,r1,i0)
 560 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 561 #  endif
 562 #  define str_c(r0,r1)                  SB(r1,0,r0)
 563 #  define sti_c(i0,r0)                  _sti_c(_jit,i0,r0)
 564 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
 565 #  define str_s(r0,r1)                  SH(r1,0,r0)
 566 #  define sti_s(i0,r0)                  _sti_s(_jit,i0,r0)
 567 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
 568 #  define str_i(r0,r1)                  SW(r1,0,r0)
 569 #  define sti_i(i0,r0)                  _sti_i(_jit,i0,r0)
 570 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
 571 #  if __WORDSIZE == 64
 572 #    define str_l(r0,r1)                SD(r1,0,r0)
 573 #    define sti_l(i0,r0)                _sti_l(_jit,i0,r0)
 574 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
 575 #  endif
 576 #  define stxr_c(r0,r1,r2)              _stxr_c(_jit,r0,r1,r2)
 577 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 578 #  define stxi_c(i0,r0,r1)              _stxi_c(_jit,i0,r0,r1)
 579 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 580 #  define stxr_s(r0,r1,r2)              _stxr_s(_jit,r0,r1,r2)
 581 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 582 #  define stxi_s(i0,r0,r1)              _stxi_s(_jit,i0,r0,r1)
 583 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 584 #  define stxr_i(r0,r1,r2)              _stxr_i(_jit,r0,r1,r2)
 585 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 586 #  define stxi_i(i0,r0,r1)              _stxi_i(_jit,i0,r0,r1)
 587 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 588 #  if __WORDSIZE == 64
 589 #    define stxr_l(r0,r1,r2)            _stxr_l(_jit,r0,r1,r2)
 590 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 591 #    define stxi_l(i0,r0,r1)            _stxi_l(_jit,i0,r0,r1)
 592 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 593 #  endif
 594 #  if __BYTE_ORDER == __LITTLE_ENDIAN
 595 #    define htonr_us(r0,r1)             _htonr_us(_jit,r0,r1)
 596 static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
 597 #    define htonr_ui(r0,r1)             _htonr_ui(_jit,r0,r1)
 598 static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 599 #    if __WORDSIZE == 64
 600 #      define htonr_ul(r0,r1)           _htonr_ul(_jit,r0,r1)
 601 static void _htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
 602 #    endif
 603 #  else
 604 #    define htonr_us(r0,r1)             extr_us(r0,r1)
 605 #    if __WORDSIZE == 32
 606 #      define htonr_ui(r0,r1)           movr(r0,r1)
 607 #    else
 608 #      define htonr_ui(r0,r1)           extr_ui(r0,r1)
 609 #      define htonr_ul(r0,r1)           movr(r0,r1)
 610 #    endif
 611 #  endif
 612 #  define extr_c(r0,r1)                 _extr_c(_jit,r0,r1)
 613 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
 614 #  define extr_uc(r0,r1)                ANDI(r0,r1,0xff)
 615 #  define extr_s(r0,r1)                 _extr_s(_jit,r0,r1)
 616 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
 617 #  define extr_us(r0,r1)                ANDI(r0,r1,0xffff)
 618 #  if __WORDSIZE == 64
 619 #    define extr_i(r0,r1)               SLL(r0,r1,0)
 620 #    define extr_ui(r0,r1)              _extr_ui(_jit,r0,r1)
 621 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 622 #  endif
 623 #  define ltr(r0,r1,r2)                 SLT(r0,r1,r2)
 624 #  define lti(r0,r1,i0)                 _lti(_jit,r0,r1,i0)
 625 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 626 #  define ltr_u(r0,r1,r2)               SLTU(r0,r1,r2)
 627 #  define lti_u(r0,r1,i0)               _lti_u(_jit,r0,r1,i0)
 628 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 629 #define ler(r0,r1,r2)                   _ler(_jit,r0,r1,r2)
 630 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 631 #define lei(r0,r1,i0)                   _lei(_jit,r0,r1,i0)
 632 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 633 #define ler_u(r0,r1,r2)                 _ler_u(_jit,r0,r1,r2)
 634 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 635 #define lei_u(r0,r1,i0)                 _lei_u(_jit,r0,r1,i0)
 636 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 637 #define eqr(r0,r1,r2)                   _eqr(_jit,r0,r1,r2)
 638 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 639 #define eqi(r0,r1,i0)                   _eqi(_jit,r0,r1,i0)
 640 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 641 #define ger(r0,r1,r2)                   _ger(_jit,r0,r1,r2)
 642 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 643 #define gei(r0,r1,i0)                   _gei(_jit,r0,r1,i0)
 644 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 645 #define ger_u(r0,r1,i0)                 _ger_u(_jit,r0,r1,i0)
 646 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 647 #define gei_u(r0,r1,i0)                 _gei_u(_jit,r0,r1,i0)
 648 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 649 #  define gtr(r0,r1,r2)                 SLT(r0,r2,r1)
 650 #define gti(r0,r1,i0)                   _gti(_jit,r0,r1,i0)
 651 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 652 #  define gtr_u(r0,r1,r2)               SLTU(r0,r2,r1)
 653 #  define gti_u(r0,r1,i0)               _gti_u(_jit,r0,r1,i0)
 654 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 655 #define ner(r0,r1,r2)                   _ner(_jit,r0,r1,r2)
 656 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 657 #define nei(r0,r1,i0)                   _nei(_jit,r0,r1,i0)
 658 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 659 #define bltr(i0,r0,r1)                  _bltr(_jit,i0,r0,r1)
 660 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 661 #define bltr_u(i0,r0,r1)                _bltr_u(_jit,i0,r0,r1)
 662 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 663 #define blti(i0,r0,i1)                  _blti(_jit,i0,r0,i1)
 664 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 665 #define blti_u(i0,r0,i1)                _blti_u(_jit,i0,r0,i1)
 666 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 667 #define bler(i0,r0,r1)                  _bler(_jit,i0,r0,r1)
 668 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 669 #define bler_u(i0,r0,r1)                _bler_u(_jit,i0,r0,r1)
 670 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 671 #define blei(i0,r0,i1)                  _blei(_jit,i0,r0,i1)
 672 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 673 #define blei_u(i0,r0,i1)                _blei_u(_jit,i0,r0,i1)
 674 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 675 #define beqr(i0,r0,r1)                  _beqr(_jit,i0,r0,r1)
 676 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 677 #define beqi(i0,r0,i1)                  _beqi(_jit,i0,r0,i1)
 678 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 679 #define bger(i0,r0,r1)                  _bger(_jit,i0,r0,r1)
 680 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 681 #define bger_u(i0,r0,r1)                _bger_u(_jit,i0,r0,r1)
 682 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 683 #define bgei(i0,r0,i1)                  _bgei(_jit,i0,r0,i1)
 684 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 685 #define bgei_u(i0,r0,i1)                _bgei_u(_jit,i0,r0,i1)
 686 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 687 #define bgtr(i0,r0,r1)                  _bgtr(_jit,i0,r0,r1)
 688 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 689 #define bgtr_u(i0,r0,r1)                _bgtr_u(_jit,i0,r0,r1)
 690 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 691 #define bgti(i0,r0,i1)                  _bgti(_jit,i0,r0,i1)
 692 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 693 #define bgti_u(i0,r0,i1)                _bgti_u(_jit,i0,r0,i1)
 694 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 695 #define bner(i0,r0,r1)                  _bner(_jit,i0,r0,r1)
 696 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 697 #define bnei(i0,r0,i1)                  _bnei(_jit,i0,r0,i1)
 698 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 699 #  define jmpr(r0)                      _jmpr(_jit,r0)
 700 static void _jmpr(jit_state_t*,jit_int32_t);
 701 #  define jmpi(i0)                      _jmpi(_jit,i0)
 702 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
 703 #  define boaddr(i0,r0,r1)              _boaddr(_jit,i0,r0,r1)
 704 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 705 #  define boaddi(i0,r0,i1)              _boaddi(_jit,i0,r0,i1)
 706 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 707 #  define boaddr_u(i0,r0,r1)            _boaddr_u(_jit,i0,r0,r1)
 708 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 709 #  define boaddi_u(i0,r0,i1)            _boaddi_u(_jit,i0,r0,i1)
 710 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 711 #  define bxaddr(i0,r0,r1)              _bxaddr(_jit,i0,r0,r1)
 712 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 713 #  define bxaddi(i0,r0,i1)              _bxaddi(_jit,i0,r0,i1)
 714 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 715 #  define bxaddr_u(i0,r0,r1)            _bxaddr_u(_jit,i0,r0,r1)
 716 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 717 #  define bxaddi_u(i0,r0,i1)            _bxaddi_u(_jit,i0,r0,i1)
 718 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 719 #  define bosubr(i0,r0,r1)              _bosubr(_jit,i0,r0,r1)
 720 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 721 #  define bosubi(i0,r0,i1)              _bosubi(_jit,i0,r0,i1)
 722 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 723 #  define bosubr_u(i0,r0,r1)            _bosubr_u(_jit,i0,r0,r1)
 724 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 725 #  define bosubi_u(i0,r0,i1)            _bosubi_u(_jit,i0,r0,i1)
 726 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 727 #  define bxsubr(i0,r0,r1)              _bxsubr(_jit,i0,r0,r1)
 728 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 729 #  define bxsubi(i0,r0,i1)              _bxsubi(_jit,i0,r0,i1)
 730 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 731 #  define bxsubr_u(i0,r0,r1)            _bxsubr_u(_jit,i0,r0,r1)
 732 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 733 #  define bxsubi_u(i0,r0,i1)            _bxsubi_u(_jit,i0,r0,i1)
 734 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 735 #  define bmsr(i0,r0,r1)                _bmsr(_jit,i0,r0,r1)
 736 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 737 #  define bmsi(i0,r0,i1)                _bmsi(_jit,i0,r0,i1)
 738 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 739 #  define bmcr(i0,r0,r1)                _bmcr(_jit,i0,r0,r1)
 740 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 741 #  define bmci(i0,r0,i1)                _bmci(_jit,i0,r0,i1)
 742 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 743 #  define callr(r0)                     _callr(_jit,r0)
 744 static void _callr(jit_state_t*,jit_int32_t);
 745 #  define calli(i0)                     _calli(_jit,i0)
 746 static void _calli(jit_state_t*,jit_word_t);
 747 #  define calli_p(i0)                   _calli_p(_jit,i0)
 748 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 749 #  define prolog(node)                  _prolog(_jit,node)
 750 static void _prolog(jit_state_t*,jit_node_t*);
 751 #  define epilog(node)                  _epilog(_jit,node)
 752 static void _epilog(jit_state_t*,jit_node_t*);
 753 #  define vastart(r0)                   _vastart(_jit, r0)
 754 static void _vastart(jit_state_t*, jit_int32_t);
 755 #  define vaarg(r0, r1)                 _vaarg(_jit, r0, r1)
 756 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 757 #define patch_abs(instr,label)          _patch_abs(_jit,instr,label)
 758 static void _patch_abs(jit_state_t*,jit_word_t,jit_word_t);
 759 #define patch_at(jump,label)            _patch_at(_jit,jump,label)
 760 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 761 #endif
 762
 763 #if CODE
 764 static void
 765 _hrrrit(jit_state_t *_jit,jit_int32_t hc,
 766         jit_int32_t rs, jit_int32_t rt, jit_int32_t rd,
 767         jit_int32_t ic, jit_int32_t tc)
 768 {
 769     jit_instr_t         i;
 770     i.tc.b = tc;
 771     i.ic.b = ic;
 772     i.rd.b = rd;
 773     i.rt.b = rt;
 774     i.rs.b = rs;
 775     i.hc.b = hc;
 776     ii(i.op);
 777 }
 778
 779 static void
 780 _hrri(jit_state_t *_jit, jit_int32_t hc,
 781       jit_int32_t rs, jit_int32_t rt, jit_int32_t im)
 782 {
 783     jit_instr_t         i;
 784     i.op = 0;
 785     i.is.b = im;
 786     i.rt.b = rt;
 787     i.rs.b = rs;
 788     i.hc.b = hc;
 789     ii(i.op);
 790 }
 791
 792 static void
 793 _hi(jit_state_t *_jit, jit_int32_t hc, jit_int32_t im)
 794 {
 795     jit_instr_t         i;
 796     i.ii.b = im;
 797     i.hc.b = hc;
 798     ii(i.op);
 799 }
 800
 801 static void
 802 _nop(jit_state_t *_jit, jit_int32_t i0)
 803 {
 804     for (; i0 > 0; i0 -= 4)
 805         NOP();
 806     assert(i0 == 0);
 807 }
 808
 809 static void
 810 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 811 {
 812     jit_int32_t         reg;
 813     if (i0 == 0)
 814         movr(r0, r1);
 815     else if (can_sign_extend_short_p(i0))
 816         addiu(r0, r1, i0);
 817     else {
 818         reg = jit_get_reg(jit_class_gpr);
 819         movi(rn(reg), i0);
 820         addr(r0, r1, rn(reg));
 821         jit_unget_reg(reg);
 822     }
 823 }
 824
 825 static void
 826 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 827 {
 828     jit_int32_t         t0;
 829
 830     if (jit_carry == _NOREG)
 831         jit_carry = jit_get_reg(jit_class_gpr);
 832     if (r0 == r1) {
 833         t0 = jit_get_reg(jit_class_gpr);
 834         addr(rn(t0), r1, r2);
 835         SLTU(rn(jit_carry), rn(t0), r1);
 836         movr(r0, rn(t0));
 837         jit_unget_reg(t0);
 838     }
 839     else {
 840         addr(r0, r1, r2);
 841         SLTU(rn(jit_carry), r0, r1);
 842     }
 843 }
 844
 845 static void
 846 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 847 {
 848     jit_int32_t         t0;
 849
 850     if (jit_carry == _NOREG)
 851         jit_carry = jit_get_reg(jit_class_gpr);
 852     t0 = jit_get_reg(jit_class_gpr);
 853     if (r0 == r1) {
 854         if (can_sign_extend_short_p(i0))
 855             addiu(rn(t0), r1, i0);
 856         else {
 857             movi(rn(t0), i0);
 858             addr(rn(t0), r1, rn(t0));
 859         }
 860         SLTU(rn(jit_carry), rn(t0), r1);
 861         movr(r0, rn(t0));
 862     }
 863     else {
 864         if (can_sign_extend_short_p(i0))
 865             addiu(r0, r1, i0);
 866         else {
 867             movi(rn(t0), i0);
 868             addr(r0, r1, rn(t0));
 869         }
 870         SLTU(rn(jit_carry), r0, r1);
 871     }
 872     jit_unget_reg(t0);
 873 }
 874
 875 static void
 876 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 877 {
 878     jit_int32_t         t0;
 879
 880     assert(jit_carry != _NOREG);
 881     t0 = jit_get_reg(jit_class_gpr);
 882     movr(rn(t0), rn(jit_carry));
 883     addcr(r0, r1, r2);
 884     addcr(r0, r0, rn(t0));
 885     jit_unget_reg(t0);
 886 }
 887
 888 static void
 889 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 890 {
 891     jit_int32_t         t0;
 892
 893     assert(jit_carry != _NOREG);
 894     t0 = jit_get_reg(jit_class_gpr);
 895     movr(rn(t0), rn(jit_carry));
 896     addci(r0, r1, i0);
 897     addcr(r0, r0, rn(t0));
 898     jit_unget_reg(t0);
 899 }
 900
 901 static void
 902 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 903 {
 904     jit_int32_t         reg;
 905     if (i0 == 0)
 906         movr(r0, r1);
 907     else if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
 908         addiu(r0, r1, -i0);
 909     else {
 910         reg = jit_get_reg(jit_class_gpr);
 911         movi(rn(reg), i0);
 912         subr(r0, r1, rn(reg));
 913         jit_unget_reg(reg);
 914     }
 915 }
 916
 917 static void
 918 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 919 {
 920     jit_int32_t         t0;
 921
 922     if (jit_carry == _NOREG)
 923         jit_carry = jit_get_reg(jit_class_gpr);
 924     if (r0 == r1) {
 925         t0 = jit_get_reg(jit_class_gpr);
 926         subr(rn(t0), r1, r2);
 927         SLTU(rn(jit_carry), r1, rn(t0));
 928         movr(r0, rn(t0));
 929         jit_unget_reg(t0);
 930     }
 931     else {
 932         subr(r0, r1, r2);
 933         SLTU(rn(jit_carry), r1, r0);
 934     }
 935 }
 936
 937 static void
 938 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 939 {
 940     jit_int32_t         t0;
 941
 942     if (jit_carry == _NOREG)
 943         jit_carry = jit_get_reg(jit_class_gpr);
 944     t0 = jit_get_reg(jit_class_gpr);
 945     if (r0 == r1) {
 946         if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
 947             addiu(rn(t0), r1, -i0);
 948         else {
 949             movi(rn(t0), i0);
 950             subr(rn(t0), r1, rn(t0));
 951         }
 952         SLTU(rn(jit_carry), r1, rn(t0));
 953         movr(r0, rn(t0));
 954     }
 955     else {
 956         if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
 957             addiu(r0, r1, -i0);
 958         else {
 959             movi(rn(t0), i0);
 960             subr(r0, r1, rn(t0));
 961         }
 962         SLTU(rn(jit_carry), r1, r0);
 963     }
 964     jit_unget_reg(t0);
 965 }
 966
 967 static void
 968 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 969 {
 970     jit_int32_t         t0;
 971
 972     assert(jit_carry != _NOREG);
 973     t0 = jit_get_reg(jit_class_gpr);
 974     movr(rn(t0), rn(jit_carry));
 975     subcr(r0, r1, r2);
 976     subcr(r0, r0, rn(t0));
 977     jit_unget_reg(t0);
 978 }
 979
 980 static void
 981 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 982 {
 983     jit_int32_t         t0;
 984
 985     assert(jit_carry != _NOREG);
 986     t0 = jit_get_reg(jit_class_gpr);
 987     movr(rn(t0), rn(jit_carry));
 988     subci(r0, r1, i0);
 989     subcr(r0, r0, rn(t0));
 990     jit_unget_reg(t0);
 991 }
 992
 993 static void
 994 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 995 {
 996     subi(r0, r1, i0);
 997     negr(r0, r0);
 998 }
 999
1000 static void
1001 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1002 {
1003     multu(r1, r2);
1004     MFLO(r0);
1005 }
1006
1007 static void
1008 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1009 {
1010     jit_int32_t         reg;
1011
1012     reg = jit_get_reg(jit_class_gpr);
1013     movi(rn(reg), i0);
1014     mulr(r0, r1, rn(reg));
1015     jit_unget_reg(reg);
1016 }
1017
1018 static void
1019 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1020         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1021 {
1022     if (sign)
1023         mult(r2, r3);
1024     else
1025         multu(r2, r3);
1026     MFLO(r0);
1027     MFHI(r1);
1028 }
1029
1030 static void
1031 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1032         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1033 {
1034     jit_int32_t         reg;
1035     reg = jit_get_reg(jit_class_gpr);
1036     movi(rn(reg), i0);
1037     iqmulr(r0, r1, r2, rn(reg), sign);
1038     jit_unget_reg(reg);
1039 }
1040
1041 static void
1042 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1043 {
1044     div(r1, r2);
1045     MFLO(r0);
1046 }
1047
1048 static void
1049 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1050 {
1051     jit_int32_t         reg;
1052     reg = jit_get_reg(jit_class_gpr);
1053     movi(rn(reg), i0);
1054     divr(r0, r1, rn(reg));
1055     jit_unget_reg(reg);
1056 }
1057
1058 static void
1059 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1060 {
1061     divu(r1, r2);
1062     MFLO(r0);
1063 }
1064
1065 static void
1066 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1067 {
1068     jit_int32_t         reg;
1069     reg = jit_get_reg(jit_class_gpr);
1070     movi(rn(reg), i0);
1071     divr_u(r0, r1, rn(reg));
1072     jit_unget_reg(reg);
1073 }
1074
1075 static void
1076 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1077        jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1078 {
1079     if (sign)
1080         div(r2, r3);
1081     else
1082         divu(r2, r3);
1083     MFLO(r0);
1084     MFHI(r1);
1085 }
1086
1087 static void
1088 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1089         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1090 {
1091     jit_int32_t         reg;
1092     reg = jit_get_reg(jit_class_gpr);
1093     movi(rn(reg), i0);
1094     iqdivr(r0, r1, r2, rn(reg), sign);
1095     jit_unget_reg(reg);
1096 }
1097
1098 static void
1099 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1100 {
1101     div(r1, r2);
1102     MFHI(r0);
1103 }
1104
1105 static void
1106 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1107 {
1108     jit_int32_t         reg;
1109     reg = jit_get_reg(jit_class_gpr);
1110     movi(rn(reg), i0);
1111     remr(r0, r1, rn(reg));
1112     jit_unget_reg(reg);
1113 }
1114
1115 static void
1116 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1117 {
1118     divu(r1, r2);
1119     MFHI(r0);
1120 }
1121
1122 static void
1123 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1124 {
1125     jit_int32_t         reg;
1126     reg = jit_get_reg(jit_class_gpr);
1127     movi(rn(reg), i0);
1128     remr_u(r0, r1, rn(reg));
1129     jit_unget_reg(reg);
1130 }
1131
1132 #if __WORDSIZE == 64
1133 static void
1134 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1135 {
1136     assert(i0 >= 0 && i0 <= 63);
1137     if (i0 < 32)
1138         DSLL(r0, r1, i0);
1139     else
1140         DSLL32(r0, r1, i0 - 32);
1141 }
1142
1143 static void
1144 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1145 {
1146     assert(i0 >= 0 && i0 <= 63);
1147     if (i0 < 32)
1148         DSRA(r0, r1, i0);
1149     else
1150         DSRA32(r0, r1, i0 - 32);
1151 }
1152
1153 static void
1154 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1155 {
1156     assert(i0 >= 0 && i0 <= 63);
1157     if (i0 < 32)
1158         DSRL(r0, r1, i0);
1159     else
1160         DSRL32(r0, r1, i0 - 32);
1161 }
1162 #endif
1163
1164 static void
1165 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1166 {
1167     jit_int32_t         reg;
1168     if (can_zero_extend_short_p(i0))
1169         ANDI(r0, r1, i0);
1170     else if (is_low_mask(i0)) {
1171 #if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
1172         if (masked_bits_count(i0) <= 32)
1173             EXT(r0, r1, 0, masked_bits_count(i0));
1174         else
1175 #endif
1176         {
1177                 lshi(r0, r1, unmasked_bits_count(i0));
1178                 rshi_u(r0, r0, unmasked_bits_count(i0));
1179         }
1180     } else if (is_high_mask(i0)) {
1181         rshi(r0, r1, unmasked_bits_count(i0));
1182         lshi(r0, r0, unmasked_bits_count(i0));
1183     } else {
1184         reg = jit_get_reg(jit_class_gpr);
1185         movi(rn(reg), i0);
1186         AND(r0, r1, rn(reg));
1187         jit_unget_reg(reg);
1188     }
1189 }
1190
1191 static void
1192 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1193 {
1194     jit_int32_t         reg;
1195     if (can_zero_extend_short_p(i0))
1196         ORI(r0, r1, i0);
1197     else {
1198         reg = jit_get_reg(jit_class_gpr);
1199         movi(rn(reg), i0);
1200         OR(r0, r1, rn(reg));
1201         jit_unget_reg(reg);
1202     }
1203 }
1204
1205 static void
1206 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1207 {
1208     jit_int32_t         reg;
1209     if (can_zero_extend_short_p(i0))
1210         XORI(r0, r1, i0);
1211     else {
1212         reg = jit_get_reg(jit_class_gpr);
1213         movi(rn(reg), i0);
1214         XOR(r0, r1, rn(reg));
1215         jit_unget_reg(reg);
1216     }
1217 }
1218
1219 static void
1220 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1221 {
1222     if (r0 != r1)
1223         orr(r0, r1, _ZERO_REGNO);
1224 }
1225
1226 static void
1227 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1228 {
1229     if (i0 == 0)
1230         OR(r0, _ZERO_REGNO, _ZERO_REGNO);
1231     else if (can_sign_extend_short_p(i0))
1232         addiu(r0, _ZERO_REGNO, i0);
1233     else if (can_zero_extend_short_p(i0))
1234         ORI(r0, _ZERO_REGNO, i0);
1235     else {
1236         if (can_sign_extend_int_p(i0))
1237             LUI(r0, i0 >> 16);
1238         else if (can_zero_extend_int_p(i0)) {
1239             if (i0 & 0xffff0000) {
1240                 ORI(r0, _ZERO_REGNO, i0 >> 16);
1241                 lshi(r0, r0, 16);
1242             }
1243         }
1244 #  if __WORDSIZE == 64
1245         else {
1246             movi(r0, (jit_uword_t)i0 >> 32);
1247             if (i0 & 0xffff0000) {
1248                 lshi(r0, r0, 16);
1249                 ORI(r0, r0, i0 >> 16);
1250                 lshi(r0, r0, 16);
1251             }
1252             else
1253                 lshi(r0, r0, 32);
1254         }
1255 #  endif
1256         if (i0 & 0xffff)
1257             ORI(r0, r0, i0);
1258     }
1259 }
1260
1261 static jit_word_t
1262 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1263 {
1264     jit_word_t          w;
1265
1266     w = _jit->pc.w;
1267 #  if __WORDSIZE == 32
1268     LUI(r0, i0 >> 16);
1269     ORI(r0, r0, i0);
1270 #  else
1271     LUI(r0, i0 >> 48);
1272     ORI(r0, r0, i0 >> 32);
1273     lshi(r0, r0, 16);
1274     ORI(r0, r0, i0 >> 16);
1275     lshi(r0, r0, 16);
1276     ORI(r0, r0, i0);
1277 #  endif
1278
1279     return (w);
1280 }
1281
1282 static void
1283 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1284 {
1285     jit_int32_t         reg;
1286     if (can_sign_extend_short_p(i0))
1287         LB(r0, i0, _ZERO_REGNO);
1288     else {
1289         reg = jit_get_reg(jit_class_gpr);
1290         movi(rn(reg), i0);
1291         ldr_c(r0, rn(reg));
1292         jit_unget_reg(reg);
1293     }
1294 }
1295
1296 static void
1297 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1298 {
1299     jit_int32_t         reg;
1300     if (can_sign_extend_short_p(i0))
1301         LBU(r0, i0, _ZERO_REGNO);
1302     else {
1303         reg = jit_get_reg(jit_class_gpr);
1304         movi(rn(reg), i0);
1305         ldr_uc(r0, rn(reg));
1306         jit_unget_reg(reg);
1307     }
1308 }
1309
1310 static void
1311 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1312 {
1313     jit_int32_t         reg;
1314     if (can_sign_extend_short_p(i0))
1315         LH(r0, i0, _ZERO_REGNO);
1316     else {
1317         reg = jit_get_reg(jit_class_gpr);
1318         movi(rn(reg), i0);
1319         ldr_s(r0, rn(reg));
1320         jit_unget_reg(reg);
1321     }
1322 }
1323
1324 static void
1325 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1326 {
1327     jit_int32_t         reg;
1328     if (can_sign_extend_short_p(i0))
1329         LHU(r0, i0, _ZERO_REGNO);
1330     else {
1331         reg = jit_get_reg(jit_class_gpr);
1332         movi(rn(reg), i0);
1333         ldr_us(r0, rn(reg));
1334         jit_unget_reg(reg);
1335     }
1336 }
1337
1338 static void
1339 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1340 {
1341     jit_int32_t         reg;
1342     if (can_sign_extend_short_p(i0))
1343         LW(r0, i0, _ZERO_REGNO);
1344     else {
1345         reg = jit_get_reg(jit_class_gpr);
1346         movi(rn(reg), i0);
1347         ldr_i(r0, rn(reg));
1348         jit_unget_reg(reg);
1349     }
1350 }
1351
1352 #if __WORDSIZE == 64
1353 static void
1354 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1355 {
1356     jit_int32_t         reg;
1357     if (can_sign_extend_short_p(i0))
1358         LWU(r0, i0, _ZERO_REGNO);
1359     else {
1360         reg = jit_get_reg(jit_class_gpr);
1361         movi(rn(reg), i0);
1362         ldr_ui(r0, rn(reg));
1363         jit_unget_reg(reg);
1364     }
1365 }
1366
1367 static void
1368 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1369 {
1370     jit_int32_t         reg;
1371     if (can_sign_extend_short_p(i0))
1372         LD(r0, i0, _ZERO_REGNO);
1373     else {
1374         reg = jit_get_reg(jit_class_gpr);
1375         movi(rn(reg), i0);
1376         ldr_l(r0, rn(reg));
1377         jit_unget_reg(reg);
1378     }
1379 }
1380 #endif
1381
1382 static void
1383 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1384 {
1385     jit_int32_t         reg;
1386     reg = jit_get_reg(jit_class_gpr);
1387     addr(rn(reg), r1, r2);
1388     ldr_c(r0, rn(reg));
1389     jit_unget_reg(reg);
1390 }
1391
1392 static void
1393 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1394 {
1395     jit_int32_t         reg;
1396     if (can_sign_extend_short_p(i0))
1397         LB(r0, i0, r1);
1398     else {
1399         reg = jit_get_reg(jit_class_gpr);
1400         addi(rn(reg), r1, i0);
1401         ldr_c(r0, rn(reg));
1402         jit_unget_reg(reg);
1403     }
1404 }
1405
1406 static void
1407 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1408 {
1409     jit_int32_t         reg;
1410     reg = jit_get_reg(jit_class_gpr);
1411     addr(rn(reg), r1, r2);
1412     ldr_uc(r0, rn(reg));
1413     jit_unget_reg(reg);
1414 }
1415
1416 static void
1417 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1418 {
1419     jit_int32_t         reg;
1420     if (can_sign_extend_short_p(i0))
1421         LBU(r0, i0, r1);
1422     else {
1423         reg = jit_get_reg(jit_class_gpr);
1424         addi(rn(reg), r1, i0);
1425         ldr_uc(r0, rn(reg));
1426         jit_unget_reg(reg);
1427     }
1428 }
1429
1430 static void
1431 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1432 {
1433     jit_int32_t         reg;
1434     reg = jit_get_reg(jit_class_gpr);
1435     addr(rn(reg), r1, r2);
1436     ldr_s(r0, rn(reg));
1437     jit_unget_reg(reg);
1438 }
1439
1440 static void
1441 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1442 {
1443     jit_int32_t         reg;
1444     if (can_sign_extend_short_p(i0))
1445         LH(r0, i0, r1);
1446     else {
1447         reg = jit_get_reg(jit_class_gpr);
1448         addi(rn(reg), r1, i0);
1449         ldr_s(r0, rn(reg));
1450         jit_unget_reg(reg);
1451     }
1452 }
1453
1454 static void
1455 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1456 {
1457     jit_int32_t         reg;
1458     reg = jit_get_reg(jit_class_gpr);
1459     addr(rn(reg), r1, r2);
1460     ldr_us(r0, rn(reg));
1461     jit_unget_reg(reg);
1462 }
1463
1464 static void
1465 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1466 {
1467     jit_int32_t         reg;
1468     if (can_sign_extend_short_p(i0))
1469         LHU(r0, i0, r1);
1470     else {
1471         reg = jit_get_reg(jit_class_gpr);
1472         addi(rn(reg), r1, i0);
1473         ldr_us(r0, rn(reg));
1474         jit_unget_reg(reg);
1475     }
1476 }
1477
1478 static void
1479 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1480 {
1481     jit_int32_t         reg;
1482     reg = jit_get_reg(jit_class_gpr);
1483     addr(rn(reg), r1, r2);
1484     ldr_i(r0, rn(reg));
1485     jit_unget_reg(reg);
1486 }
1487
1488 static void
1489 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1490 {
1491     jit_int32_t         reg;
1492     if (can_sign_extend_short_p(i0))
1493         LW(r0, i0, r1);
1494     else {
1495         reg = jit_get_reg(jit_class_gpr);
1496         addi(rn(reg), r1, i0);
1497         ldr_i(r0, rn(reg));
1498         jit_unget_reg(reg);
1499     }
1500 }
1501
1502 #if __WORDSIZE == 64
1503 static void
1504 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1505 {
1506     jit_int32_t         reg;
1507     reg = jit_get_reg(jit_class_gpr);
1508     addr(rn(reg), r1, r2);
1509     ldr_ui(r0, rn(reg));
1510     jit_unget_reg(reg);
1511 }
1512
1513 static void
1514 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1515 {
1516     jit_int32_t         reg;
1517     if (can_sign_extend_short_p(i0))
1518         LWU(r0, i0, r1);
1519     else {
1520         reg = jit_get_reg(jit_class_gpr);
1521         addi(rn(reg), r1, i0);
1522         ldr_ui(r0, rn(reg));
1523         jit_unget_reg(reg);
1524     }
1525 }
1526
1527 static void
1528 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1529 {
1530     jit_int32_t         reg;
1531     reg = jit_get_reg(jit_class_gpr);
1532     addr(rn(reg), r1, r2);
1533     ldr_l(r0, rn(reg));
1534     jit_unget_reg(reg);
1535 }
1536
1537 static void
1538 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1539 {
1540     jit_int32_t         reg;
1541     if (can_sign_extend_short_p(i0))
1542         LD(r0, i0, r1);
1543     else {
1544         reg = jit_get_reg(jit_class_gpr);
1545         addi(rn(reg), r1, i0);
1546         ldr_l(r0, rn(reg));
1547         jit_unget_reg(reg);
1548     }
1549 }
1550 #endif
1551
1552 static void
1553 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1554 {
1555     jit_int32_t         reg;
1556     if (can_sign_extend_short_p(i0))
1557         SB(r0, i0, _ZERO_REGNO);
1558     else {
1559         reg = jit_get_reg(jit_class_gpr);
1560         movi(rn(reg), i0);
1561         str_c(rn(reg), r0);
1562         jit_unget_reg(reg);
1563     }
1564 }
1565
1566 static void
1567 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1568 {
1569     jit_int32_t         reg;
1570     if (can_sign_extend_short_p(i0))
1571         SH(r0, i0, _ZERO_REGNO);
1572     else {
1573         reg = jit_get_reg(jit_class_gpr);
1574         movi(rn(reg), i0);
1575         str_s(rn(reg), r0);
1576         jit_unget_reg(reg);
1577     }
1578 }
1579
1580 static void
1581 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1582 {
1583     jit_int32_t         reg;
1584     if (can_sign_extend_short_p(i0))
1585         SW(r0, i0, _ZERO_REGNO);
1586     else {
1587         reg = jit_get_reg(jit_class_gpr);
1588         movi(rn(reg), i0);
1589         str_i(rn(reg), r0);
1590         jit_unget_reg(reg);
1591     }
1592 }
1593
1594 #if __WORDSIZE == 64
1595 static void
1596 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1597 {
1598     jit_int32_t         reg;
1599     if (can_sign_extend_short_p(i0))
1600         SD(r0, i0, _ZERO_REGNO);
1601     else {
1602         reg = jit_get_reg(jit_class_gpr);
1603         movi(rn(reg), i0);
1604         str_l(rn(reg), r0);
1605         jit_unget_reg(reg);
1606     }
1607 }
1608 #endif
1609
1610 static void
1611 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1612 {
1613     jit_int32_t         reg;
1614     reg = jit_get_reg(jit_class_gpr);
1615     addr(rn(reg), r0, r1);
1616     str_c(rn(reg), r2);
1617     jit_unget_reg(reg);
1618 }
1619
1620 static void
1621 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1622 {
1623     jit_int32_t         reg;
1624     if (can_sign_extend_short_p(i0))
1625         SB(r1, i0, r0);
1626     else {
1627         reg = jit_get_reg(jit_class_gpr);
1628         addi(rn(reg), r0, i0);
1629         str_c(rn(reg), r1);
1630         jit_unget_reg(reg);
1631     }
1632 }
1633
1634 static void
1635 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1636 {
1637     jit_int32_t         reg;
1638     reg = jit_get_reg(jit_class_gpr);
1639     addr(rn(reg), r0, r1);
1640     str_s(rn(reg), r2);
1641     jit_unget_reg(reg);
1642 }
1643
1644 static void
1645 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1646 {
1647     jit_int32_t         reg;
1648     if (can_sign_extend_short_p(i0))
1649         SH(r1, i0, r0);
1650     else {
1651         reg = jit_get_reg(jit_class_gpr);
1652         addi(rn(reg), r0, i0);
1653         str_s(rn(reg), r1);
1654         jit_unget_reg(reg);
1655     }
1656 }
1657
1658 static void
1659 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1660 {
1661     jit_int32_t         reg;
1662     reg = jit_get_reg(jit_class_gpr);
1663     addr(rn(reg), r0, r1);
1664     str_i(rn(reg), r2);
1665     jit_unget_reg(reg);
1666 }
1667
1668 static void
1669 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1670 {
1671     jit_int32_t         reg;
1672     if (can_sign_extend_short_p(i0))
1673         SW(r1, i0, r0);
1674     else {
1675         reg = jit_get_reg(jit_class_gpr);
1676         addi(rn(reg), r0, i0);
1677         str_i(rn(reg), r1);
1678         jit_unget_reg(reg);
1679     }
1680 }
1681
1682 #if __WORDSIZE == 64
1683 static void
1684 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1685 {
1686     jit_int32_t         reg;
1687     reg = jit_get_reg(jit_class_gpr);
1688     addr(rn(reg), r0, r1);
1689     str_l(rn(reg), r2);
1690     jit_unget_reg(reg);
1691 }
1692
1693 static void
1694 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1695 {
1696     jit_int32_t         reg;
1697     if (can_sign_extend_short_p(i0))
1698         SD(r1, i0, r0);
1699     else {
1700         reg = jit_get_reg(jit_class_gpr);
1701         addi(rn(reg), r0, i0);
1702         str_l(rn(reg), r1);
1703         jit_unget_reg(reg);
1704     }
1705 }
1706 #endif
1707
1708 #  if __BYTE_ORDER == __LITTLE_ENDIAN
1709 static void
1710 _htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1711 {
1712     jit_int32_t         t0;
1713     t0 = jit_get_reg(jit_class_gpr);
1714     rshi(rn(t0), r1, 8);
1715     andi(r0, r1, 0xff);
1716     andi(rn(t0), rn(t0), 0xff);
1717     lshi(r0, r0, 8);
1718     orr(r0, r0, rn(t0));
1719     jit_unget_reg(t0);
1720 }
1721
1722 static void
1723 _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1724 {
1725     jit_int32_t         t0;
1726     jit_int32_t         t1;
1727     jit_int32_t         t2;
1728     t0 = jit_get_reg(jit_class_gpr);
1729     t1 = jit_get_reg(jit_class_gpr);
1730     t2 = jit_get_reg(jit_class_gpr);
1731     rshi(rn(t0), r1, 24);
1732     rshi(rn(t1), r1, 16);
1733     rshi(rn(t2), r1,  8);
1734     andi(rn(t0), rn(t0), 0xff);
1735     andi(rn(t1), rn(t1), 0xff);
1736     andi(rn(t2), rn(t2), 0xff);
1737     andi(r0, r1, 0xff);
1738     lshi(r0, r0, 24);
1739     lshi(rn(t1), rn(t1), 8);
1740     orr(r0, r0, rn(t0));
1741     lshi(rn(t2), rn(t2), 16);
1742     orr(r0, r0, rn(t1));
1743     orr(r0, r0, rn(t2));
1744     jit_unget_reg(t2);
1745     jit_unget_reg(t1);
1746     jit_unget_reg(t0);
1747 }
1748
1749 static void
1750 _htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1751 {
1752     jit_int32_t         reg;
1753     reg = jit_get_reg(jit_class_gpr);
1754     rshi_u(rn(reg), r1, 32);
1755     htonr_ui(r0, r1);
1756     htonr_ui(rn(reg), rn(reg));
1757     lshi(r0, r0, 32);
1758     orr(r0, r0, rn(reg));
1759     jit_unget_reg(reg);
1760 }
1761 #  endif
1762
1763 static void
1764 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1765 {
1766     if (jit_mips2_p())
1767         SEB(r0, r1);
1768     else {
1769         lshi(r0, r1, __WORDSIZE - 8);
1770         rshi(r0, r0, __WORDSIZE - 8);
1771     }
1772 }
1773
1774 static void
1775 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1776 {
1777     if (jit_mips2_p())
1778         SEH(r0, r1);
1779     else {
1780         lshi(r0, r1, __WORDSIZE - 16);
1781         rshi(r0, r0, __WORDSIZE - 16);
1782     }
1783 }
1784
1785 #  if __WORDSIZE == 64
1786 static void
1787 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1788 {
1789     lshi(r0, r1, 32);
1790     rshi_u(r0, r0, 32);
1791 }
1792 #  endif
1793
1794 static void
1795 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1796 {
1797     jit_int32_t         reg;
1798
1799     if (can_sign_extend_short_p(i0))
1800         SLTI(r0, r1, i0);
1801     else {
1802         reg = jit_get_reg(jit_class_gpr);
1803         movi(rn(reg), i0);
1804         ltr(r0, r1, rn(reg));
1805         jit_unget_reg(reg);
1806     }
1807 }
1808
1809 static void
1810 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1811 {
1812     jit_int32_t         reg;
1813
1814     if (can_sign_extend_short_p(i0))
1815         SLTIU(r0, r1, i0);
1816     else {
1817         reg = jit_get_reg(jit_class_gpr);
1818         movi(rn(reg), i0);
1819         ltr_u(r0, r1, rn(reg));
1820         jit_unget_reg(reg);
1821     }
1822 }
1823
1824 static void
1825 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1826 {
1827     SLT(r0, r2, r1);
1828     XORI(r0, r0, 1);
1829 }
1830
1831 static void
1832 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1833 {
1834     jit_int32_t         reg;
1835
1836     if (i0 == 0) {
1837         SLT(r0, _ZERO_REGNO, r1);
1838         XORI(r0, r0, 1);
1839     }
1840     else {
1841         reg = jit_get_reg(jit_class_gpr);
1842         movi(rn(reg), i0);
1843         ler(r0, r1, rn(reg));
1844         jit_unget_reg(reg);
1845     }
1846 }
1847
1848 static void
1849 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1850 {
1851     SLTU(r0, r2, r1);
1852     XORI(r0, r0, 1);
1853 }
1854
1855 static void
1856 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1857 {
1858     jit_int32_t         reg;
1859
1860     if (i0 == 0) {
1861         SLTU(r0, _ZERO_REGNO, r1);
1862         XORI(r0, r0, 1);
1863     }
1864     else {
1865         reg = jit_get_reg(jit_class_gpr);
1866         movi(rn(reg), i0);
1867         ler_u(r0, r1, rn(reg));
1868         jit_unget_reg(reg);
1869     }
1870 }
1871
1872 static void
1873 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1874 {
1875     subr(r0, r1, r2);
1876     SLTU(r0, _ZERO_REGNO, r0);
1877     XORI(r0, r0, 1);
1878 }
1879
1880 static void
1881 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1882 {
1883     if (i0) {
1884         subi(r0, r1, i0);
1885         SLTU(r0, _ZERO_REGNO, r0);
1886     }
1887     else
1888         SLTU(r0, _ZERO_REGNO, r1);
1889     XORI(r0, r0, 1);
1890 }
1891
1892 static void
1893 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1894 {
1895     SLT(r0, r1, r2);
1896     XORI(r0, r0, 1);
1897 }
1898
1899 static void
1900 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1901 {
1902     jit_int32_t         reg;
1903
1904     reg = jit_get_reg(jit_class_gpr);
1905     movi(rn(reg), i0);
1906     ger(r0, r1, rn(reg));
1907     jit_unget_reg(reg);
1908 }
1909
1910 static void
1911 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1912 {
1913     SLTU(r0, r1, r2);
1914     XORI(r0, r0, 1);
1915 }
1916
1917 static void
1918 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1919 {
1920     jit_int32_t         reg;
1921
1922     reg = jit_get_reg(jit_class_gpr);
1923     movi(rn(reg), i0);
1924     ger_u(r0, r1, rn(reg));
1925     jit_unget_reg(reg);
1926 }
1927
1928 static void
1929 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1930 {
1931     jit_int32_t         reg;
1932
1933     if (i0 == 0)
1934         SLT(r0, _ZERO_REGNO, r1);
1935     else {
1936         reg = jit_get_reg(jit_class_gpr);
1937         movi(rn(reg), i0);
1938         SLT(r0, rn(reg), r1);
1939         jit_unget_reg(reg);
1940     }
1941 }
1942
1943 static void
1944 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1945 {
1946     jit_int32_t         reg;
1947
1948     if (i0 == 0)
1949         SLTU(r0, _ZERO_REGNO, r1);
1950     else {
1951         reg = jit_get_reg(jit_class_gpr);
1952         movi(rn(reg), i0);
1953         SLTU(r0, rn(reg), r1);
1954         jit_unget_reg(reg);
1955     }
1956 }
1957
1958 static void
1959 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1960 {
1961     subr(r0, r1, r2);
1962     SLTU(r0, _ZERO_REGNO, r0);
1963 }
1964
1965 static void
1966 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1967 {
1968     if (i0) {
1969         subi(r0, r1, i0);
1970         SLTU(r0, _ZERO_REGNO, r0);
1971     }
1972     else
1973         SLTU(r0, _ZERO_REGNO, r1);
1974 }
1975
1976 static jit_word_t
1977 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1978 {
1979     jit_word_t          w;
1980     jit_int32_t         reg;
1981
1982     reg = jit_get_reg(jit_class_gpr);
1983     SLT(rn(reg), r0, r1);
1984     w = _jit->pc.w;
1985     BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
1986     NOP(1);
1987     jit_unget_reg(reg);
1988
1989     return (w);
1990 }
1991
1992 static jit_word_t
1993 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1994 {
1995     jit_word_t          w;
1996     jit_int32_t         reg;
1997
1998     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1999     SLTU(rn(reg), r0, r1);
2000     w = _jit->pc.w;
2001     BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2002     NOP(1);
2003     jit_unget_reg(reg);
2004
2005     return (w);
2006 }
2007
2008 static jit_word_t
2009 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2010 {
2011     jit_word_t          w;
2012     jit_word_t          d;
2013     jit_int32_t         reg;
2014     jit_bool_t          zero_p;
2015
2016     if (!(zero_p = i1 == 0))
2017         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2018     if (can_sign_extend_short_p(i1)) {
2019         if (!zero_p)
2020             SLTI(rn(reg), r0, i1);
2021         w = _jit->pc.w;
2022         d = ((i0 - w) >> 2) - 1;
2023         if (!zero_p)
2024             BNE(rn(reg), _ZERO_REGNO, d);
2025         else
2026             BLTZ(r0, d);
2027         NOP(1);
2028     }
2029     else {
2030         movi(rn(reg), i1);
2031         w = bltr(i0, r0, rn(reg));
2032     }
2033     if (!zero_p)
2034         jit_unget_reg(reg);
2035
2036     return (w);
2037 }
2038
2039 static jit_word_t
2040 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2041 {
2042     jit_word_t          w;
2043     jit_int32_t         reg;
2044
2045     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2046     if (can_sign_extend_short_p(i1)) {
2047         SLTIU(rn(reg), r0, i1);
2048         w = _jit->pc.w;
2049         BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2050         NOP(1);
2051     }
2052     else {
2053         movi(rn(reg), i1);
2054         w = bltr_u(i0, r0, rn(reg));
2055     }
2056     jit_unget_reg(reg);
2057
2058     return (w);
2059 }
2060
2061 static jit_word_t
2062 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2063 {
2064     jit_word_t          w;
2065     jit_int32_t         reg;
2066
2067     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2068     SLT(rn(reg), r1, r0);
2069     w = _jit->pc.w;
2070     BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2071     NOP(1);
2072     jit_unget_reg(reg);
2073
2074     return (w);
2075 }
2076
2077 static jit_word_t
2078 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2079 {
2080     jit_word_t          w;
2081     jit_int32_t         reg;
2082
2083     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2084     SLTU(rn(reg), r1, r0);
2085     w = _jit->pc.w;
2086     BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2087     NOP(1);
2088     jit_unget_reg(reg);
2089
2090     return (w);
2091 }
2092
2093 static jit_word_t
2094 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2095 {
2096     jit_word_t          w;
2097     jit_int32_t         reg;
2098
2099     if (i1 == 0) {
2100         w = _jit->pc.w;
2101         BLEZ(r0, ((i0 - w) >> 2) - 1);
2102         NOP(1);
2103     }
2104     else {
2105         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2106         movi(rn(reg), i1);
2107         w = bler(i0, r0, rn(reg));
2108         jit_unget_reg(reg);
2109     }
2110
2111     return (w);
2112 }
2113
2114 static jit_word_t
2115 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2116 {
2117     jit_word_t          w;
2118     jit_int32_t         reg;
2119
2120     if (i1 == 0) {
2121         w = _jit->pc.w;
2122         BEQ(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2123         NOP(1);
2124     }
2125     else {
2126         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2127         movi(rn(reg), i1);
2128         w = bler_u(i0, r0, rn(reg));
2129         jit_unget_reg(reg);
2130     }
2131
2132     return (w);
2133 }
2134
2135 static jit_word_t
2136 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2137 {
2138     jit_word_t          w;
2139
2140     w = _jit->pc.w;
2141     BEQ(r0, r1, ((i0 - w) >> 2) - 1);
2142     NOP(1);
2143
2144     return (w);
2145 }
2146
2147 static jit_word_t
2148 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2149 {
2150     jit_word_t          w;
2151     jit_int32_t         reg;
2152
2153     if (i1 == 0) {
2154         w = _jit->pc.w;
2155         BEQ(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2156         NOP(1);
2157     }
2158     else {
2159         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2160         movi(rn(reg), i1);
2161         w = beqr(i0, r0, rn(reg));
2162         jit_unget_reg(reg);
2163     }
2164
2165     return (w);
2166 }
2167
2168 static jit_word_t
2169 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2170 {
2171     jit_word_t          w;
2172     jit_int32_t         reg;
2173
2174     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2175     SLT(rn(reg), r0, r1);
2176     w = _jit->pc.w;
2177     BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2178     NOP(1);
2179     jit_unget_reg(reg);
2180
2181     return (w);
2182 }
2183
2184 static jit_word_t
2185 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2186 {
2187     jit_word_t          w;
2188     jit_int32_t         reg;
2189
2190     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2191     SLTU(rn(reg), r0, r1);
2192     w = _jit->pc.w;
2193     BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2194     NOP(1);
2195     jit_unget_reg(reg);
2196
2197     return (w);
2198 }
2199
2200 static jit_word_t
2201 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2202 {
2203     jit_word_t          w;
2204     jit_word_t          d;
2205     jit_int32_t         reg;
2206     jit_bool_t          zero_p;
2207
2208     if (!(zero_p = i1 == 0))
2209         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2210     if (can_sign_extend_short_p(i1)) {
2211         if (!zero_p)
2212             SLTI(rn(reg), r0, i1);
2213         w = _jit->pc.w;
2214         d = ((i0 - w) >> 2) - 1;
2215         if (!zero_p)
2216             BEQ(rn(reg), _ZERO_REGNO, d);
2217         else
2218             BGEZ(r0, d);
2219         NOP(1);
2220     }
2221     else {
2222         movi(rn(reg), i1);
2223         w = bger(i0, r0, rn(reg));
2224     }
2225     if (!zero_p)
2226         jit_unget_reg(reg);
2227
2228     return (w);
2229 }
2230
2231 static jit_word_t
2232 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2233 {
2234     jit_word_t          w;
2235     jit_int32_t         reg;
2236
2237     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2238     if (can_sign_extend_short_p(i1)) {
2239         SLTIU(rn(reg), r0, i1);
2240         w = _jit->pc.w;
2241         BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2242         NOP(1);
2243     }
2244     else {
2245         movi(rn(reg), i1);
2246         w = bger_u(i0, r0, rn(reg));
2247     }
2248     jit_unget_reg(reg);
2249
2250     return (w);
2251 }
2252
2253 static jit_word_t
2254 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2255 {
2256     jit_word_t          w;
2257     jit_int32_t         reg;
2258
2259     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2260     SLT(rn(reg), r1, r0);
2261     w = _jit->pc.w;
2262     BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2263     NOP(1);
2264     jit_unget_reg(reg);
2265
2266     return (w);
2267 }
2268
2269 static jit_word_t
2270 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2271 {
2272     jit_word_t          w;
2273     jit_int32_t         reg;
2274
2275     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2276     SLTU(rn(reg), r1, r0);
2277     w = _jit->pc.w;
2278     BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2279     NOP(1);
2280     jit_unget_reg(reg);
2281
2282     return (w);
2283 }
2284
2285 static jit_word_t
2286 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2287 {
2288     jit_word_t          w;
2289     jit_int32_t         reg;
2290
2291     if (i1 == 0) {
2292         w = _jit->pc.w;
2293         BGTZ(r0, ((i0 - w) >> 2) - 1);
2294         NOP(1);
2295     }
2296     else {
2297         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2298         movi(rn(reg), i1);
2299         w = bgtr(i0, r0, rn(reg));
2300         jit_unget_reg(reg);
2301     }
2302
2303     return (w);
2304 }
2305
2306 static jit_word_t
2307 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2308 {
2309     jit_word_t          w;
2310     jit_int32_t         reg;
2311
2312     if (i1 == 0) {
2313         w = _jit->pc.w;
2314         BNE(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2315         NOP(1);
2316     }
2317     else {
2318         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2319         movi(rn(reg), i1);
2320         w = bgtr_u(i0, r0, rn(reg));
2321         jit_unget_reg(reg);
2322     }
2323
2324     return (w);
2325 }
2326
2327 static jit_word_t
2328 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2329 {
2330     jit_word_t          w;
2331
2332     w = _jit->pc.w;
2333     BNE(r0, r1, ((i0 - w) >> 2) - 1);
2334     NOP(1);
2335
2336     return (w);
2337 }
2338
2339 static jit_word_t
2340 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2341 {
2342     jit_word_t          w;
2343     jit_int32_t         reg;
2344
2345     if (i1 == 0) {
2346         w = _jit->pc.w;
2347         BNE(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2348         NOP(1);
2349     }
2350     else {
2351         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2352         movi(rn(reg), i1);
2353         w = bner(i0, r0, rn(reg));
2354         jit_unget_reg(reg);
2355     }
2356
2357     return (w);
2358 }
2359
2360 static void
2361 _jmpr(jit_state_t *_jit, jit_int32_t r0)
2362 {
2363     JR(r0);
2364     NOP(1);
2365 }
2366
2367 static jit_word_t
2368 _jmpi(jit_state_t *_jit, jit_word_t i0)
2369 {
2370     jit_word_t          w;
2371     jit_int32_t         reg;
2372
2373     w = _jit->pc.w;
2374     if (((w + sizeof(jit_int32_t)) & 0xf0000000) == (i0 & 0xf0000000)) {
2375         J((i0 & ~0xf0000000) >> 2);
2376         NOP(1);
2377     }
2378     else {
2379         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2380         movi_p(rn(reg), i0);
2381         jmpr(rn(reg));
2382         jit_unget_reg(reg);
2383     }
2384
2385     return (w);
2386 }
2387
2388 static jit_word_t
2389 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2390 {
2391     jit_word_t          w;
2392     jit_int32_t         t0;
2393     jit_int32_t         t1;
2394     jit_int32_t         t2;
2395
2396     /* t1 = r0 + r1;    overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
2397     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2398     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2399     t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2400     SLT(rn(t0), r1, _ZERO_REGNO);       /* t0 = r1 < 0 */
2401     addr(rn(t1), r0, r1);               /* t1 = r0 + r1 */
2402     SLT(rn(t2), rn(t1), r0);            /* t2 = t1 < r0 */
2403     SLT(rn(t1), r0, rn(t1));            /* t1 = r0 < t1 */
2404     MOVZ(rn(t1), rn(t2), rn(t0));       /* if (r0 == 0) t1 = t2 */
2405     w = _jit->pc.w;
2406     BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2407     /* delay slot */
2408     addr(r0, r0, r1);
2409     jit_unget_reg(t2);
2410     jit_unget_reg(t1);
2411     jit_unget_reg(t0);
2412
2413     return (w);
2414 }
2415
2416 static jit_word_t
2417 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2418 {
2419     jit_word_t          w;
2420     jit_int32_t         t0;
2421     jit_int32_t         t1;
2422     jit_int32_t         t2;
2423
2424     if (can_sign_extend_short_p(i1)) {
2425         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2426         t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2427         t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2428         SLTI(rn(t0), _ZERO_REGNO, i1);
2429         addiu(rn(t1), r0, i1);
2430         SLT(rn(t2), r0, rn(t1));
2431         SLT(rn(t1), rn(t1), r0);
2432         MOVZ(rn(t1), rn(t2), rn(t0));
2433         w = _jit->pc.w;
2434         BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2435         /* delay slot */
2436         addiu(r0, r0, i1);
2437         jit_unget_reg(t2);
2438         jit_unget_reg(t1);
2439         jit_unget_reg(t0);
2440     }
2441     else {
2442         t0 = jit_get_reg(jit_class_gpr);
2443         movi(rn(t0), i1);
2444         w = boaddr(i0, r0, rn(t0));
2445         jit_unget_reg(t0);
2446     }
2447     return (w);
2448 }
2449
2450 static jit_word_t
2451 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2452 {
2453     jit_word_t          w;
2454     jit_int32_t         t0;
2455     jit_int32_t         t1;
2456
2457     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2458     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2459     addr(rn(t0), r0, r1);
2460     SLTU(rn(t1), rn(t0), r0);
2461     w = _jit->pc.w;
2462     BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2463     /* delay slot */
2464     movr(r0, rn(t0));
2465     jit_unget_reg(t1);
2466     jit_unget_reg(t0);
2467     return (w);
2468 }
2469
2470 static jit_word_t
2471 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2472 {
2473     jit_word_t          w;
2474     jit_int32_t         t0;
2475     jit_int32_t         t1;
2476
2477     if (can_sign_extend_short_p(i0)) {
2478         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2479         t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2480         addiu(rn(t0), r0, i1);
2481         SLTU(rn(t1), rn(t0), r0);
2482         w = _jit->pc.w;
2483         BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2484         /* delay slot */
2485         movr(r0, rn(t0));
2486         jit_unget_reg(t1);
2487         jit_unget_reg(t0);
2488     }
2489     else {
2490         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2491         movi(rn(t0), i1);
2492         w = boaddr_u(i0, r0, rn(t0));
2493         jit_unget_reg(t0);
2494     }
2495     return (w);
2496 }
2497
2498 static jit_word_t
2499 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2500 {
2501     jit_word_t          w;
2502     jit_int32_t         t0;
2503     jit_int32_t         t1;
2504     jit_int32_t         t2;
2505
2506     /* t1 = r0 + r1;    overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
2507     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2508     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2509     t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2510     SLT(rn(t0), r1, _ZERO_REGNO);       /* t0 = r1 < 0 */
2511     addr(rn(t1), r0, r1);               /* t1 = r0 + r1 */
2512     SLT(rn(t2), rn(t1), r0);            /* t2 = t1 < r0 */
2513     SLT(rn(t1), r0, rn(t1));            /* t1 = r0 < t1 */
2514     MOVZ(rn(t1), rn(t2), rn(t0));       /* if (r0 == 0) t1 = t2 */
2515     w = _jit->pc.w;
2516     BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2517     /* delay slot */
2518     addr(r0, r0, r1);
2519     jit_unget_reg(t2);
2520     jit_unget_reg(t1);
2521     jit_unget_reg(t0);
2522
2523     return (w);
2524 }
2525
2526 static jit_word_t
2527 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2528 {
2529     jit_word_t          w;
2530     jit_int32_t         t0;
2531     jit_int32_t         t1;
2532     jit_int32_t         t2;
2533
2534     if (can_sign_extend_short_p(i1)) {
2535         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2536         t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2537         t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2538         SLTI(rn(t0), _ZERO_REGNO, i1);
2539         addiu(rn(t1), r0, i1);
2540         SLT(rn(t2), r0, rn(t1));
2541         SLT(rn(t1), rn(t1), r0);
2542         MOVZ(rn(t1), rn(t2), rn(t0));
2543         w = _jit->pc.w;
2544         BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2545         /* delay slot */
2546         addiu(r0, r0, i1);
2547         jit_unget_reg(t2);
2548         jit_unget_reg(t1);
2549         jit_unget_reg(t0);
2550     }
2551     else {
2552         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2553         movi(rn(t0), i1);
2554         w = bxaddr(i0, r0, rn(t0));
2555         jit_unget_reg(t0);
2556     }
2557     return (w);
2558 }
2559
2560 static jit_word_t
2561 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2562 {
2563     jit_word_t          w;
2564     jit_int32_t         t0;
2565     jit_int32_t         t1;
2566
2567     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2568     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2569     addr(rn(t0), r0, r1);
2570     SLTU(rn(t1), rn(t0), r0);
2571     w = _jit->pc.w;
2572     BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2573     /* delay slot */
2574     movr(r0, rn(t0));
2575     jit_unget_reg(t1);
2576     jit_unget_reg(t0);
2577     return (w);
2578 }
2579
2580 static jit_word_t
2581 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2582 {
2583     jit_word_t          w;
2584     jit_int32_t         t0;
2585     jit_int32_t         t1;
2586
2587     if (can_sign_extend_short_p(i0)) {
2588         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2589         t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2590         addiu(rn(t0), r0, i1);
2591         SLTU(rn(t1), rn(t0), r0);
2592         w = _jit->pc.w;
2593         BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2594         /* delay slot */
2595         movr(r0, rn(t0));
2596         jit_unget_reg(t1);
2597         jit_unget_reg(t0);
2598     }
2599     else {
2600         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2601         movi(rn(t0), i1);
2602         w = bxaddr_u(i0, r0, rn(t0));
2603         jit_unget_reg(t0);
2604     }
2605     return (w);
2606 }
2607
2608 static jit_word_t
2609 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2610 {
2611     jit_word_t          w;
2612     jit_int32_t         t0;
2613     jit_int32_t         t1;
2614     jit_int32_t         t2;
2615
2616     /* t1 = r0 - r1;    overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
2617     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2618     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2619     t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2620     SLT(rn(t0), _ZERO_REGNO, r1);       /* t0 = 0 < r1 */
2621     subr(rn(t1), r0, r1);               /* t1 = r0 - r1 */
2622     SLT(rn(t2), rn(t1), r0);            /* t2 = t1 < r0 */
2623     SLT(rn(t1), r0, rn(t1));            /* t1 = r0 < t1 */
2624     MOVZ(rn(t1), rn(t2), rn(t0));       /* if (r0 == 0) t1 = t2 */
2625     w = _jit->pc.w;
2626     BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2627     /* delay slot */
2628     subr(r0, r0, r1);
2629     jit_unget_reg(t2);
2630     jit_unget_reg(t1);
2631     jit_unget_reg(t0);
2632
2633     return (w);
2634 }
2635
2636 static jit_word_t
2637 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2638 {
2639     jit_word_t          w;
2640     jit_int32_t         t0;
2641     jit_int32_t         t1;
2642     jit_int32_t         t2;
2643
2644     if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
2645         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2646         t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2647         t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2648         SLTI(rn(t0), _ZERO_REGNO, i1);
2649         addiu(rn(t1), r0, -i1);
2650         SLT(rn(t2), rn(t1), r0);
2651         SLT(rn(t1), r0, rn(t1));
2652         MOVZ(rn(t1), rn(t2), rn(t0));
2653         w = _jit->pc.w;
2654         BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2655         /* delay slot */
2656         addiu(r0, r0, -i1);
2657         jit_unget_reg(t2);
2658         jit_unget_reg(t1);
2659         jit_unget_reg(t0);
2660     }
2661     else {
2662         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2663         movi(rn(t0), i1);
2664         w = bosubr(i0, r0, rn(t0));
2665         jit_unget_reg(t0);
2666     }
2667     return (w);
2668 }
2669
2670 static jit_word_t
2671 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2672 {
2673     jit_word_t          w;
2674     jit_int32_t         t0;
2675     jit_int32_t         t1;
2676
2677     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2678     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2679     subr(rn(t0), r0, r1);
2680     SLTU(rn(t1), r0, rn(t0));
2681     w = _jit->pc.w;
2682     BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2683     /* delay slot */
2684     movr(r0, rn(t0));
2685     jit_unget_reg(t1);
2686     jit_unget_reg(t0);
2687     return (w);
2688 }
2689
2690 static jit_word_t
2691 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2692 {
2693     jit_word_t          w;
2694     jit_int32_t         t0;
2695     jit_int32_t         t1;
2696
2697     if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
2698         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2699         t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2700         addiu(rn(t0), r0, -i1);
2701         SLTU(rn(t1), r0, rn(t0));
2702         w = _jit->pc.w;
2703         BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2704         /* delay slot */
2705         movr(r0, rn(t0));
2706         jit_unget_reg(t1);
2707         jit_unget_reg(t0);
2708     }
2709     else {
2710         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2711         movi(rn(t0), i1);
2712         w = bosubr_u(i0, r0, rn(t0));
2713         jit_unget_reg(t0);
2714     }
2715     return (w);
2716 }
2717
2718 static jit_word_t
2719 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2720 {
2721     jit_word_t          w;
2722     jit_int32_t         t0;
2723     jit_int32_t         t1;
2724     jit_int32_t         t2;
2725
2726     /* t1 = r0 - r1;    overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
2727     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2728     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2729     t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2730     SLT(rn(t0), _ZERO_REGNO, r1);       /* t0 = 0 < r1 */
2731     subr(rn(t1), r0, r1);               /* t1 = r0 - r1 */
2732     SLT(rn(t2), rn(t1), r0);            /* t2 = t1 < r0 */
2733     SLT(rn(t1), r0, rn(t1));            /* t1 = r0 < t1 */
2734     MOVZ(rn(t1), rn(t2), rn(t0));       /* if (t0 == 0) t1 = t2 */
2735     w = _jit->pc.w;
2736     BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2737     /* delay slot */
2738     subr(r0, r0, r1);
2739     jit_unget_reg(t2);
2740     jit_unget_reg(t1);
2741     jit_unget_reg(t0);
2742
2743     return (w);
2744 }
2745
2746 static jit_word_t
2747 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2748 {
2749     jit_word_t          w;
2750     jit_int32_t         t0;
2751     jit_int32_t         t1;
2752     jit_int32_t         t2;
2753
2754     if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
2755         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2756         t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2757         t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2758         SLTI(rn(t0), _ZERO_REGNO, i1);
2759         addiu(rn(t1), r0, -i1);
2760         SLT(rn(t2), rn(t1), r0);
2761         SLT(rn(t1), r0, rn(t1));
2762         MOVZ(rn(t1), rn(t2), rn(t0));
2763         w = _jit->pc.w;
2764         BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2765         /* delay slot */
2766         addiu(r0, r0, -i1);
2767         jit_unget_reg(t2);
2768         jit_unget_reg(t1);
2769         jit_unget_reg(t0);
2770     }
2771     else {
2772         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2773         movi(rn(t0), i1);
2774         w = bxsubr(i0, r0, rn(t0));
2775         jit_unget_reg(t0);
2776     }
2777     return (w);
2778 }
2779
2780 static jit_word_t
2781 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2782 {
2783     jit_word_t          w;
2784     jit_int32_t         t0;
2785     jit_int32_t         t1;
2786
2787     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2788     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2789     subr(rn(t0), r0, r1);
2790     SLTU(rn(t1), r0, rn(t0));
2791     w = _jit->pc.w;
2792     BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2793     /* delay slot */
2794     movr(r0, rn(t0));
2795     jit_unget_reg(t1);
2796     jit_unget_reg(t0);
2797     return (w);
2798 }
2799
2800 static jit_word_t
2801 _bxsubi_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         t0;
2805     jit_int32_t         t1;
2806
2807     if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
2808         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2809         t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2810         addiu(rn(t0), r0, -i1);
2811         SLTU(rn(t1), r0, rn(t0));
2812         w = _jit->pc.w;
2813         BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2814         /* delay slot */
2815         movr(r0, rn(t0));
2816         jit_unget_reg(t1);
2817         jit_unget_reg(t0);
2818     }
2819     else {
2820         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2821         movi(rn(t0), i1);
2822         w = bxsubr_u(i0, r0, rn(t0));
2823         jit_unget_reg(t0);
2824     }
2825     return (w);
2826 }
2827
2828 static jit_word_t
2829 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2830 {
2831     jit_word_t          w;
2832     jit_int32_t         t0;
2833     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2834     AND(rn(t0), r0, r1);
2835     w = _jit->pc.w;
2836     BNE(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2837     NOP(1);
2838     jit_unget_reg(t0);
2839     return (w);
2840 }
2841
2842 static jit_word_t
2843 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2844 {
2845     jit_word_t          w;
2846     jit_int32_t         t0;
2847     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2848     if (can_zero_extend_short_p(i1)) {
2849         ANDI(rn(t0), r0, i1);
2850         w = _jit->pc.w;
2851         BNE(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2852         NOP(1);
2853     }
2854     else {
2855         movi(rn(t0), i1);
2856         w = bmsr(i0, r0, rn(t0));
2857     }
2858     jit_unget_reg(t0);
2859     return (w);
2860 }
2861
2862 static jit_word_t
2863 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2864 {
2865     jit_word_t          w;
2866     jit_int32_t         t0;
2867     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2868     AND(rn(t0), r0, r1);
2869     w = _jit->pc.w;
2870     BEQ(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2871     NOP(1);
2872     jit_unget_reg(t0);
2873     return (w);
2874 }
2875
2876 static jit_word_t
2877 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2878 {
2879     jit_word_t          w;
2880     jit_int32_t         t0;
2881     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2882     if (can_zero_extend_short_p(i1)) {
2883         ANDI(rn(t0), r0, i1);
2884         w = _jit->pc.w;
2885         BEQ(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2886         NOP(1);
2887     }
2888     else {
2889         movi(rn(t0), i1);
2890         w = bmcr(i0, r0, rn(t0));
2891     }
2892     jit_unget_reg(t0);
2893     return (w);
2894 }
2895
2896 static void
2897 _callr(jit_state_t *_jit, jit_int32_t r0)
2898 {
2899     JALR(r0);
2900     if (r0 != _T9_REGNO)
2901         movr(_T9_REGNO, r0);
2902     else
2903         NOP(1);
2904 }
2905
2906 static void
2907 _calli(jit_state_t *_jit, jit_word_t i0)
2908 {
2909     movi(_T9_REGNO, i0);
2910     JALR(_T9_REGNO);
2911     NOP(1);
2912 }
2913
2914 static jit_word_t
2915 _calli_p(jit_state_t *_jit, jit_word_t i0)
2916 {
2917     jit_word_t          word;
2918
2919     word = _jit->pc.w;
2920     movi_p(_T9_REGNO, i0);
2921     JALR(_T9_REGNO);
2922     NOP(1);
2923
2924     return (word);
2925 }
2926
2927 static jit_int32_t fregs[] = {
2928     _F30, _F28, _F26, _F24, _F22, _F20,
2929 #if !NEW_ABI
2930     _F18, _F16,
2931 #endif
2932 };
2933
2934 static jit_int32_t iregs[] = {
2935     _S7, _S6, _S5, _S4, _S3, _S2, _S1, _S0,
2936 };
2937
2938 static void
2939 _prolog(jit_state_t *_jit, jit_node_t *node)
2940 {
2941     jit_int32_t         index;
2942     jit_int32_t         offset;
2943     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2944         jit_int32_t     frame = -_jitc->function->frame;
2945         assert(_jitc->function->self.aoff >= frame);
2946         if (_jitc->function->assume_frame)
2947             return;
2948         _jitc->function->self.aoff = frame;
2949     }
2950     if (_jitc->function->allocar)
2951         _jitc->function->self.aoff &= -8;
2952 #if NEW_ABI
2953     _jitc->function->stack = ((_jitc->function->self.alen -
2954                               /* align stack at 16 bytes */
2955                                _jitc->function->self.aoff) + 15) & -16;
2956 #else
2957     _jitc->function->stack = ((/* first 16 bytes must be allocated */
2958                               (_jitc->function->self.alen > 16 ?
2959                                _jitc->function->self.alen : 16) -
2960                               /* align stack at 8 bytes */
2961                               _jitc->function->self.aoff) + 7) & -8;
2962 #endif
2963     /* callee save registers */
2964 #if NEW_ABI
2965     if ((_jitc->function->self.call & jit_call_varargs) &&
2966         jit_arg_reg_p(_jitc->function->vagp))
2967         subi(_SP_REGNO, _SP_REGNO, stack_framesize + 64);
2968     else
2969 #endif
2970         subi(_SP_REGNO, _SP_REGNO, stack_framesize);
2971     offset = stack_framesize - (sizeof(jit_word_t) << 1);
2972     for (index = 0; index < jit_size(fregs); index++, offset -= 8) {
2973         if (jit_regset_tstbit(&_jitc->function->regset, fregs[index]))
2974             stxi_d(offset, _SP_REGNO, rn(fregs[index]));
2975     }
2976     for (index = 0; index < jit_size(iregs);
2977          index++, offset -= sizeof(jit_word_t)) {
2978         if (jit_regset_tstbit(&_jitc->function->regset, iregs[index]))
2979             stxi(offset, _SP_REGNO, rn(iregs[index]));
2980     }
2981     assert(offset >= sizeof(jit_word_t));
2982     stxi(offset, _SP_REGNO, _RA_REGNO);
2983     stxi(0, _SP_REGNO, _BP_REGNO);
2984     movr(_BP_REGNO, _SP_REGNO);
2985
2986     /* alloca */
2987     if (_jitc->function->stack)
2988         subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
2989     if (_jitc->function->allocar) {
2990         index = jit_get_reg(jit_class_gpr);
2991         movi(rn(index), _jitc->function->self.aoff);
2992         stxi_i(_jitc->function->aoffoff, _BP_REGNO, rn(index));
2993         jit_unget_reg(index);
2994     }
2995
2996     if (_jitc->function->self.call & jit_call_varargs) {
2997 #if NEW_ABI
2998         index = _jitc->function->vagp;
2999 #else
3000         index = (_jitc->function->self.size - stack_framesize) >> STACK_SHIFT;
3001 #endif
3002         offset = stack_framesize + index * STACK_SLOT;
3003         for (; jit_arg_reg_p(index); ++index, offset += STACK_SLOT) {
3004 #if NEW_ABI
3005             SD(rn(_A0 - index), offset, _BP_REGNO);
3006 #else
3007             stxi(offset +  WORD_ADJUST, _BP_REGNO, rn(_A0 - index));
3008 #endif
3009         }
3010     }
3011 }
3012
3013 static void
3014 _epilog(jit_state_t *_jit, jit_node_t *node)
3015 {
3016     jit_int32_t         index;
3017     jit_int32_t         offset;
3018     if (_jitc->function->assume_frame)
3019         return;
3020     /* callee save registers */
3021     movr(_SP_REGNO, _BP_REGNO);
3022     offset = stack_framesize - (sizeof(jit_word_t) << 1);
3023     for (index = 0; index < jit_size(fregs); index++, offset -= 8) {
3024         if (jit_regset_tstbit(&_jitc->function->regset, fregs[index]))
3025             ldxi_d(rn(fregs[index]), _SP_REGNO, offset);
3026     }
3027     for (index = 0; index < jit_size(iregs);
3028          index++, offset -= sizeof(jit_word_t)) {
3029         if (jit_regset_tstbit(&_jitc->function->regset, iregs[index]))
3030             ldxi(rn(iregs[index]), _SP_REGNO, offset);
3031     }
3032     assert(offset >= sizeof(jit_word_t));
3033     ldxi(_RA_REGNO, _SP_REGNO, offset);
3034     ldxi(_BP_REGNO, _SP_REGNO, 0);
3035     JR(_RA_REGNO);
3036     /* delay slot */
3037 #if NEW_ABI
3038     if ((_jitc->function->self.call & jit_call_varargs) &&
3039         jit_arg_reg_p(_jitc->function->vagp))
3040         addi(_SP_REGNO, _SP_REGNO, stack_framesize + 64);
3041     else
3042 #endif
3043         addi(_SP_REGNO, _SP_REGNO, stack_framesize);
3044 }
3045
3046 static void
3047 _vastart(jit_state_t *_jit, jit_int32_t r0)
3048 {
3049     assert(_jitc->function->self.call & jit_call_varargs);
3050     /* Initialize va_list to the first stack argument. */
3051 #if NEW_ABI
3052     if (jit_arg_reg_p(_jitc->function->vagp))
3053         addi(r0, _BP_REGNO, stack_framesize + _jitc->function->vagp *
3054              sizeof(jit_int64_t));
3055     else
3056 #endif
3057         addi(r0, _BP_REGNO, _jitc->function->self.size);
3058 }
3059
3060 static void
3061 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3062 {
3063     /* Load argument. */
3064 #if WORD_ADJUST
3065     ldxi(r0, r1, WORD_ADJUST);
3066 #else
3067     ldr(r0, r1);
3068 #endif
3069
3070     /* Update va_list. */
3071     addi(r1, r1, STACK_SLOT);
3072 }
3073
3074 static void
3075 _patch_abs(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3076 {
3077     jit_instr_t         i;
3078     union {
3079         jit_int32_t     *i;
3080         jit_word_t       w;
3081     } u;
3082
3083     u.w = instr;
3084 #if __WORDSIZE == 32
3085     i.op = u.i[0];
3086     assert(i.hc.b == MIPS_LUI);
3087     i.is.b = label >> 16;
3088     u.i[0] = i.op;
3089     i.op = u.i[1];
3090     assert(i.hc.b == MIPS_ORI);
3091     i.is.b = label;
3092     u.i[1] = i.op;
3093 #else
3094     i.op = u.i[0];
3095     assert(i.hc.b == MIPS_LUI);
3096     i.is.b = label >> 48;
3097     u.i[0] = i.op;
3098     i.op = u.i[1];
3099     assert(i.hc.b == MIPS_ORI);
3100     i.is.b = label >> 32;
3101     u.i[1] = i.op;
3102     /* lshi */
3103     i.op = u.i[3];
3104     assert(i.hc.b == MIPS_ORI);
3105     i.is.b = label >> 16;
3106     u.i[3] = i.op;
3107     /* lshi */
3108     i.op = u.i[5];
3109     assert(i.hc.b == MIPS_ORI);
3110     i.is.b = label;
3111     u.i[5] = i.op;
3112 #endif
3113 }
3114
3115 static void
3116 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3117 {
3118     jit_instr_t         i;
3119     union {
3120         jit_int32_t     *i;
3121         jit_word_t       w;
3122     } u;
3123
3124     u.w = instr;
3125     i.op = u.i[0];
3126     switch (i.hc.b) {
3127         /* 16 bit immediate opcodes */
3128         case MIPS_REGIMM:
3129             switch (i.rt.b) {
3130                 case MIPS_BLTZ:         case MIPS_BLTZL:
3131                 case MIPS_BLTZAL:       case MIPS_BLTZALL:
3132                 case MIPS_BGEZ:         case MIPS_BGEZAL:
3133                 case MIPS_BGEZALL:      case MIPS_BGEZL:
3134                 case MIPS_TEQI:         case MIPS_TGEI:
3135                 case MIPS_TGEIU:        case MIPS_TLTI:
3136                 case MIPS_TLTIU:        case MIPS_TNEI:
3137                     i.is.b = ((label - instr) >> 2) - 1;
3138                     u.i[0] = i.op;
3139                     break;
3140                 default:
3141                     assert(!"unhandled branch opcode");
3142                     break;
3143             }
3144             break;
3145
3146         case MIPS_COP1:                 case MIPS_COP2:
3147             assert(i.rs.b == MIPS_BC);
3148             switch (i.rt.b) {
3149                 case MIPS_BCF:          case MIPS_BCFL:
3150                 case MIPS_BCT:          case MIPS_BCTL:
3151                     i.is.b = ((label - instr) >> 2) - 1;
3152                     u.i[0] = i.op;
3153                     break;
3154                 default:
3155                     assert(!"unhandled branch opcode");
3156                     break;
3157             }
3158             break;
3159
3160         case MIPS_BLEZ:                 case MIPS_BLEZL:
3161         case MIPS_BEQ:                  case MIPS_BEQL:
3162         case MIPS_BGTZ:                 case MIPS_BGTZL:
3163         case MIPS_BNE:                  case MIPS_BNEL:
3164             i.is.b = ((label - instr) >> 2) - 1;
3165             u.i[0] = i.op;
3166             break;
3167
3168         case MIPS_LUI:
3169             patch_abs(instr, label);
3170             break;
3171
3172         case MIPS_J:                    case MIPS_JAL:
3173         case MIPS_JALX:
3174             assert(((instr + sizeof(jit_int32_t)) & 0xf0000000) ==
3175                    (label & 0xf0000000));
3176             i.ii.b = (label & ~0xf0000000) >> 2;
3177             u.i[0] = i.op;
3178             break;
3179
3180         default:
3181             assert(!"unhandled branch opcode");
3182             break;
3183     }
3184 }
3185 #endif