deps/lightning/lib/jit_mips-cpu.c

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