deps/lightning/lib/jit_mips-cpu.c

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