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