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