deps/lightning/lib/jit_loongarch-cpu.c

   1 /*
   2  * Copyright (C) 2022  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 # define ii(i)                          *_jit->pc.ui++ = (i)
  22 # define can_sign_extend_si12_p(s12)    ((s12) <= 2047 && (s12) >= -2048)
  23 # define can_zero_extend_u12_p(u12)     ((u12) <= 4095 && (u12) >= 0)
  24 # define can_sign_extend_si16_p(s16)    ((s16) <= 32767 && (s16) >= -32768)
  25 # define can_sign_extend_si21_p(s21)    ((s21) <= 1048575 && (s21) >= -1048576)
  26 # define can_sign_extend_si26_p(s26)                                    \
  27         ((s26) <= 33554431 && (s26) >= -33554432)
  28 # define can_sign_extend_si32_p(s32)                                    \
  29         ((s32) <= 2147483647LL && (s32) >= -2147483648LL)
  30 # define _ZERO_REGNO                    0
  31 # define _RA_REGNO                      1
  32 # define _SP_REGNO                      3
  33 # define _FP_REGNO                      22
  34 # define stack_framesize                160
  35 # define ldr(u, v)                      ldr_l(u, v)
  36 # define ldi(u, v)                      ldi_l(u, v)
  37 # define ldxi(u, v, w)                  ldxi_l(u, v, w)
  38 # define sti(u, v)                      sti_l(u, v)
  39 # define stxi(u, v, w)                  stxi_l(u, v, w)
  40 # define orrr(op, rk, rj, rd)           _orrr(_jit, op, rk, rj, rd)
  41 # define ou5rr(op, i5, rj, rd)          _orrr(_jit, op, i5, rj, rd)
  42 # define orru5(op, rk, rj, i5)          _orrr(_jit, op, rk, rj, i5)
  43 static void _orrr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  44 # define ou2rrr(op, i2, rk, rj, rd)     _ou2rrr(_jit, op, i2, rk, rj, rd)
  45 static void _ou2rrr(jit_state_t*,jit_int32_t,
  46                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  47 # define ou3rrr(op, u3, rk, rj, rd)     _ou3rrr(_jit, op, u3, rk, rj, rd)
  48 static void _ou3rrr(jit_state_t*,jit_int32_t,
  49                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  50 # define ou6rr(op, u6, rj, rd)          _ou6rr(_jit, op, u6, rj, rd)
  51 static void _ou6rr(jit_state_t*,jit_int32_t,
  52                    jit_int32_t,jit_int32_t,jit_int32_t);
  53 # define ou5u1u5rr(op,m5,u1,l5,rj,rd)   _ou5u1u5rr(_jit,op,m5,u1,l5,rj,rd)
  54 static void _ou5u1u5rr(jit_state_t*,jit_int32_t,jit_int32_t,
  55                        jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  56 # define ou6u6rr(op, m6, l6, rj, rd)    _ou6u6rr(_jit, op, m6, l6, rj, rd)
  57 static void _ou6u6rr(jit_state_t*,jit_int32_t,
  58                      jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  59 # define o5r23(op, i5, rj, i2, rd)      _o5r23(_jit, op, i5, rj, i2, rd)
  60 static void _o5r23(jit_state_t*,
  61                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  62 # define o523r(op, i5, i2, rj, i3)      _o523r(_jit, op, i5, i2, rj, i3)
  63 static void _o523r(jit_state_t*,
  64                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  65 # define os12rr(op, i12, rj, rd)        _os12rr(_jit, op, i12, rj, rd)
  66 # define os12ru5(op, i12, rj, u5)       _os12rr(_jit, op, i12, rj, u5)
  67 static void _os12rr(jit_state_t*,
  68                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  69 # define ou12rr(op, u12, rj, rd)        _ou12rr(_jit, op, u12, rj, rd)
  70 static void _ou12rr(jit_state_t*,
  71                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  72 # define ou14u5r(op, u14, u5, rd)       _ou14u5r(_jit, op, u14, u5, rd)
  73 static void _osu14u5r(jit_state_t*,
  74                       jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  75 # define os14rr(op, s14, rj, rd)        _os14rr(_jit, op, s14, rj, rd)
  76 static void _os14rr(jit_state_t*,
  77                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  78 # define ou8rr(op, u8, rd, rj)          _ou8rr(_jit, op, u8, rd, rj)
  79 # define ou8u5r(op, u8, u5, rj)         _ou8rr(_jit, op, u8, u5, rj)
  80 static void _ou8rr(jit_state_t*,jit_int32_t,
  81                    jit_int32_t,jit_int32_t,jit_int32_t);
  82 # define ou15(op, u15)                  _ou15(_jit, op, u15)
  83 static void _ou15(jit_state_t*, jit_int32_t,jit_int32_t);
  84 # define orrrr(op, ra, rk, rj, rd)      _orrrr(_jit, op, ra, rk, rj, rd)
  85 static void _orrrr(jit_state_t*,
  86                    jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  87 # define ou5rru2u3(op,u5,rj,rk,u2,u3)   _ou5rru2u3(_jit, op, u5, rj, rk, u2, u3)
  88 static void _ou5rru2u3(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,
  89                        jit_int32_t,jit_int32_t,jit_int32_t);
  90 # define os16rr(op, s16, rj, rd)        _os16rr(_jit, op, s16, rj, rd)
  91 static void _os16rr(jit_state_t*,
  92                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
  93 # define os20r(op, s20, rd)             _os20r(_jit, op, s20, rd)
  94 static void _os20r(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
  95 # define orj21(op, rj, j21)             _orj21(_jit, op, rj, j21)
  96 static void _orj21(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
  97 # define ou2u3j21(op, u2, u3, j21)      _ou2u3j21(_jit, op, u2, u3, j21)
  98 static void _o2cj21(jit_state_t*,
  99                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 100 # define oj16rr(op, j16, rj, rd)        _oj16rr(_jit, op, j16, rj, rd)
 101 static void _oj16rr(jit_state_t*,
 102                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 103 # define oj26(op, j26)                  _oj26(_jit, op, j26)
 104 static void _oj26(jit_state_t*, jit_int32_t,jit_int32_t);
 105 # define       CLO_W(rd, rj)             ou5rr(0x000,        0x04,    rj,    rd)
 106 # define       CLZ_W(rd, rj)             ou5rr(0x000,        0x05,    rj,    rd)
 107 # define       CTO_W(rd, rj)             ou5rr(0x000,        0x06,    rj,    rd)
 108 # define       CTZ_W(rd, rj)             ou5rr(0x000,        0x07,    rj,    rd)
 109 # define       CLO_D(rd, rj)             ou5rr(0x000,        0x08,    rj,    rd)
 110 # define       CLZ_D(rd, rj)             ou5rr(0x000,        0x09,    rj,    rd)
 111 # define       CTO_D(rd, rj)             ou5rr(0x000,        0x0a,    rj,    rd)
 112 # define       CTZ_D(rd, rj)             ou5rr(0x000,        0x0b,    rj,    rd)
 113 # define     REVB_2H(rd, rj)             ou5rr(0x000,        0x0c,    rj,    rd)
 114 # define     REVB_4H(rd, rj)             ou5rr(0x000,        0x0d,    rj,    rd)
 115 # define     REVB_2W(rd, rj)             ou5rr(0x000,        0x0e,    rj,    rd)
 116 # define      REVB_D(rd, rj)             ou5rr(0x000,        0x0f,    rj,    rd)
 117 # define     REVH_2W(rd, rj)             ou5rr(0x000,        0x10,    rj,    rd)
 118 # define      REVH_D(rd, rj)             ou5rr(0x000,        0x11,    rj,    rd)
 119 # define   BITREV_4B(rd, rj)             ou5rr(0x000,        0x12,    rj,    rd)
 120 # define   BITREV_8B(rd, rj)             ou5rr(0x000,        0x13,    rj,    rd)
 121 # define    BITREV_W(rd, rj)             ou5rr(0x000,        0x14,    rj,    rd)
 122 # define    BITREV_D(rd, rj)             ou5rr(0x000,        0x15,    rj,    rd)
 123 # define     EXT_W_H(rd, rj)             ou5rr(0x000,        0x16,    rj,    rd)
 124 # define     EXT_W_B(rd, rj)             ou5rr(0x000,        0x17,    rj,    rd)
 125 # define   RDTIMEL_W(rd, rj)             ou5rr(0x000,        0x18,    rj,    rd)
 126 # define   RDTIMEH_W(rd, rj)             ou5rr(0x000,        0x19,    rj,    rd)
 127 # define    RDTIME_D(rd, rj)             ou5rr(0x000,        0x20,    rj,    rd)
 128 # define      CPUCFG(rd, rj)             ou5rr(0x000,        0x21,    rj,    rd)
 129 # define    ASRTLE_D(    rj, rk)         orru5(0x002,          rk,    rj,  0x00)
 130 # define    ASRTGT_D(    rj, rk)         orru5(0x003,          rk,    rj,  0x00)
 131 # define      ALSL_W(rd, rj, rk, sa2)   ou2rrr(0x002,     sa2, rk,    rj,    rd)
 132 # define     ALSL_WU(rd, rj, rk, sa2)   ou2rrr(0x003,     sa2, rk,    rj,    rd)
 133 # define  BYTEPICK_W(rd, rj, rk, sa2)   ou2rrr(0x004,     sa2, rk,    rj,    rd)
 134 # define  BYTEPICK_D(rd, rj, rk, sa3)   ou3rrr(0x003,     sa3, rk,    rj,    rd)
 135 # define       ADD_W(rd, rj, rk)          orrr(0x020,          rk,    rj,    rd)
 136 # define       ADD_D(rd, rj, rk)          orrr(0x021,          rk,    rj,    rd)
 137 # define       SUB_W(rd, rj, rk)          orrr(0x022,          rk,    rj,    rd)
 138 # define       SUB_D(rd, rj, rk)          orrr(0x023,          rk,    rj,    rd)
 139 # define         SLT(rd, rj, rk)          orrr(0x024,          rk,    rj,    rd)
 140 # define        SLTU(rd, rj, rk)          orrr(0x025,          rk,    rj,    rd)
 141 # define     MASKEQZ(rd, rj, rk)          orrr(0x026,          rk,    rj,    rd)
 142 # define     MASKNEZ(rd, rj, rk)          orrr(0x027,          rk,    rj,    rd)
 143 # define         NOR(rd, rj, rk)          orrr(0x028,          rk,    rj,    rd)
 144 # define         AND(rd, rj, rk)          orrr(0x029,          rk,    rj,    rd)
 145 # define          OR(rd, rj, rk)          orrr(0x02a,          rk,    rj,    rd)
 146 # define         XOR(rd, rj, rk)          orrr(0x02b,          rk,    rj,    rd)
 147 # define         ORN(rd, rj, rk)          orrr(0x02c,          rk,    rj,    rd)
 148 # define        ANDN(rd, rj, rk)          orrr(0x02d,          rk,    rj,    rd)
 149 # define       SLL_W(rd, rj, rk)          orrr(0x02e,          rk,    rj,    rd)
 150 # define       SRL_W(rd, rj, rk)          orrr(0x02f,          rk,    rj,    rd)
 151 # define       SRA_W(rd, rj, rk)          orrr(0x030,          rk,    rj,    rd)
 152 # define       SLL_D(rd, rj, rk)          orrr(0x031,          rk,    rj,    rd)
 153 # define       SRL_D(rd, rj, rk)          orrr(0x032,          rk,    rj,    rd)
 154 # define       SRA_D(rd, rj, rk)          orrr(0x033,          rk,    rj,    rd)
 155 # define      ROTR_W(rd, rj, rk)          orrr(0x036,          rk,    rj,    rd)
 156 # define      ROTR_D(rd, rj, rk)          orrr(0x037,          rk,    rj,    rd)
 157 # define       MUL_W(rd, rj, rk)          orrr(0x038,          rk,    rj,    rd)
 158 # define      MULH_W(rd, rj, rk)          orrr(0x039,          rk,    rj,    rd)
 159 # define     MULH_WU(rd, rj, rk)          orrr(0x03a,          rk,    rj,    rd)
 160 # define       MUL_D(rd, rj, rk)          orrr(0x03b,          rk,    rj,    rd)
 161 # define      MULH_D(rd, rj, rk)          orrr(0x03c,          rk,    rj,    rd)
 162 # define     MULH_DU(rd, rj, rk)          orrr(0x03d,          rk,    rj,    rd)
 163 # define    MULW_D_W(rd, rj, rk)          orrr(0x03e,          rk,    rj,    rd)
 164 # define   MULW_D_WU(rd, rj, rk)          orrr(0x03f,          rk,    rj,    rd)
 165 # define       DIV_W(rd, rj, rk)          orrr(0x040,          rk,    rj,    rd)
 166 # define       MOD_W(rd, rj, rk)          orrr(0x041,          rk,    rj,    rd)
 167 # define      DIV_WU(rd, rj, rk)          orrr(0x042,          rk,    rj,    rd)
 168 # define      MOD_WU(rd, rj, rk)          orrr(0x043,          rk,    rj,    rd)
 169 # define       DIV_D(rd, rj, rk)          orrr(0x044,          rk,    rj,    rd)
 170 # define       MOD_D(rd, rj, rk)          orrr(0x045,          rk,    rj,    rd)
 171 # define      DIV_DU(rd, rj, rk)          orrr(0x046,          rk,    rj,    rd)
 172 # define      MOD_DU(rd, rj, rk)          orrr(0x047,          rk,    rj,    rd)
 173 # define   CRC_W_B_W(rd, rj, rk)          orrr(0x048,          rk,    rj,    rd)
 174 # define   CRC_W_H_W(rd, rj, rk)          orrr(0x049,          rk,    rj,    rd)
 175 # define   CRC_W_W_W(rd, rj, rk)          orrr(0x04a,          rk,    rj,    rd)
 176 # define   CRC_W_D_W(rd, rj, rk)          orrr(0x04b,          rk,    rj,    rd)
 177 # define  CRCC_W_B_W(rd, rj, rk)          orrr(0x04c,          rk,    rj,    rd)
 178 # define  CRCC_W_H_W(rd, rj, rk)          orrr(0x04d,          rk,    rj,    rd)
 179 # define  CCRC_W_W_W(rd, rj, rk)          orrr(0x04e,          rk,    rj,    rd)
 180 # define  CCRC_W_D_W(rd, rj, rk)          orrr(0x04f,          rk,    rj,    rd)
 181 # define       BREAK(code)                ou15(0x054,                      code)
 182 # define        DBCL(code)                ou15(0x055,                      code)
 183 # define     SYSCALL(code)                ou15(0x056,                      code)
 184 # define      ALSL_D(rd, rj, rk, sa2)   ou2rrr(0x016,     sa2, rk,    rj,    rd)
 185 # define      SLLI_W(rd, rj, ui5)        ou5rr(0x081,         ui5,    rj,    rd)
 186 # define      SLLI_D(rd, rj, ui6)        ou6rr(0x041,         ui6,    rj,    rd)
 187 # define      SRLI_W(rd, rj, ui5)        ou5rr(0x089,         ui5,    rj,    rd)
 188 # define      SRLI_D(rd, rj, ui6)        ou6rr(0x045,         ui6,    rj,    rd)
 189 # define      SRAI_W(rd, rj, ui5)        ou5rr(0x091,         ui5,    rj,    rd)
 190 # define      SRAI_D(rd, rj, ui6)        ou6rr(0x049,         ui6,    rj,    rd)
 191 # define     ROTRI_W(rd, rj, ui5)        ou5rr(0x099,         ui5,    rj,    rd)
 192 # define     ROTRI_D(rd, rj, ui6)        ou6rr(0x04d,         ui6,    rj,    rd)
 193 # define   BSTRINS_W(rd, rj, m5, l5) ou5u1u5rr(0x003, m5, 0x0, l5,    rj,    rd)
 194 # define  BSTRPICK_W(rd, rj, m5, l5) ou5u1u5rr(0x003, m5, 0x1, l5,    rj,    rd)
 195 # define   BSTRINS_D(rd, rj, m6, l6)   ou6u6rr(0x002, m6,      l6,    rj,    rd)
 196 # define  BSTRPICK_D(rd, rj, m6, l6)   ou6u6rr(0x003, m6,      l6,    rj,    rd)
 197 # define        SLTI(rd, rj,  i12)      os12rr(0x008,         i12,    rj,    rd)
 198 # define       SLTUI(rd, rj,  i12)      os12rr(0x009,         i12,    rj,    rd)
 199 # define      ADDI_W(rd, rj, si12)      os12rr(0x00a,        si12,    rj,    rd)
 200 # define      ADDI_D(rd, rj, si12)      os12rr(0x00b,        si12,    rj,    rd)
 201 # define     LU52I_D(rd, rj,  i12)      os12rr(0x00c,         i12,    rj,    rd)
 202 # define        ANDI(rd, rj,  i12)      ou12rr(0x00d,         i12,    rj,    rd)
 203 # define         ORI(rd, rj,  i12)      ou12rr(0x00e,         i12,    rj,    rd)
 204 # define        XORI(rd, rj,  i12)      ou12rr(0x00f,         i12,    rj,    rd)
 205 # define       CSRRD(rd, csr)          ou14u5r(0x004,         csr,  0x00,    rd)
 206 # define       CSRWR(rd, csr)          ou14u5r(0x004,         csr,  0x01,    rd)
 207 # define     CSRXCHG(rd, rj, csr)      ou14u5r(0x004,         csr,    rj,    rd)
 208 # define       CACOP(i5, rj, si12)     os12ru5(0x018,        si12,    rj,    i5)
 209 # define       LDDIR(rd, rj, level)      ou8rr(0x190,       level,    rj,    rd)
 210 # define       LDPTE(    rj, level)     ou8u5r(0x191,       level,    rj,  0x00)
 211 # define   IOCSRRD_B(rd, rj)             ou5rr(0xc90,        0x00,    rj,    rd)
 212 # define   IOCSRRD_H(rd, rj)             ou5rr(0xc90,        0x01,    rj,    rd)
 213 # define   IOCSRRD_W(rd, rj)             ou5rr(0xc90,        0x02,    rj,    rd)
 214 # define   IOCSRRD_D(rd, rj)             ou5rr(0xc90,        0x03,    rj,    rd)
 215 # define   IOCSRWR_B(rd, rj)             ou5rr(0xc90,        0x04,    rj,    rd)
 216 # define   IOCSRWR_H(rd, rj)             ou5rr(0xc90,        0x05,    rj,    rd)
 217 # define   IOCSRWR_W(rd, rj)             ou5rr(0xc90,        0x06,    rj,    rd)
 218 # define   IOCSRWR_D(rd, rj)             ou5rr(0xc90,        0x07,    rj,    rd)
 219 # define      TLBCLR()                      ii(                       0x6482000)
 220 # define    TLBFLUSH()                      ii(                       0x6482400)
 221 # define     TLBSRCH()                      ii(                       0x6482800)
 222 # define       TLBRD()                      ii(                       0x6482c00)
 223 # define       TLBWR()                      ii(                       0x6483000)
 224 # define     TLBFILL()                      ii(                       0x6483400)
 225 # define        ERTN()                      ii(                       0x6483800)
 226 # define        IDLE(level)               ou15(0xc91,                     level)
 227 # define      INVTLB(op, rj, rk)         orru5(0xc93,          rk,   rj,     op)
 228 # define   ADDU16I_D(rd, rj, si16)      os16rr(0x004,        si16,   rj,     rd)
 229 # define     LU12I_W(rd, si20)           os20r(0x00a,              si20,     rd)
 230 # define     LU32I_D(rd, si20)           os20r(0x00b,              si20,     rd)
 231 # define      PCADDI(rd, si20)           os20r(0x00c,              si20,     rd)
 232 # define   PCALAU12I(rd, si20)           os20r(0x00d,              si20,     rd)
 233 # define   PCADDU12I(rd, si20)           os20r(0x00e,              si20,     rd)
 234 # define   PCADDU18I(rd, si20)           os20r(0x00f,              si20,     rd)
 235 # define        LL_W(rd, rj, si14)      os14rr(0x020,        si14,   rj,     rd)
 236 # define        SC_W(rd, rj, si14)      os14rr(0x021,        si14,   rj,     rd)
 237 # define        LL_D(rd, rj, si14)      os14rr(0x022,        si14,   rj,     rd)
 238 # define        SC_D(rd, rj, si14)      os14rr(0x023,        si14,   rj,     rd)
 239 # define     LDPTR_W(rd, rj, si14)      os14rr(0x024,        si14,   rj,     rd)
 240 # define     SDPTR_W(rd, rj, si14)      os14rr(0x025,        si14,   rj,     rd)
 241 # define     LDPTR_D(rd, rj, si14)      os14rr(0x026,        si14,   rj,     rd)
 242 # define     SDPTR_D(rd, rj, si14)      os14rr(0x027,        si14,   rj,     rd)
 243 # define        LD_B(rd, rj, si12)      os12rr(0x0a0,        si12,   rj,     rd)
 244 # define        LD_H(rd, rj, si12)      os12rr(0x0a1,        si12,   rj,     rd)
 245 # define        LD_W(rd, rj, si12)      os12rr(0x0a2,        si12,   rj,     rd)
 246 # define        LD_D(rd, rj, si12)      os12rr(0x0a3,        si12,   rj,     rd)
 247 # define        ST_B(rd, rj, si12)      os12rr(0x0a4,        si12,   rj,     rd)
 248 # define        ST_H(rd, rj, si12)      os12rr(0x0a5,        si12,   rj,     rd)
 249 # define        ST_W(rd, rj, si12)      os12rr(0x0a6,        si12,   rj,     rd)
 250 # define        ST_D(rd, rj, si12)      os12rr(0x0a7,        si12,   rj,     rd)
 251 # define       LD_BU(rd, rj, si12)      os12rr(0x0a8,        si12,   rj,     rd)
 252 # define       LD_HU(rd, rj, si12)      os12rr(0x0a9,        si12,   rj,     rd)
 253 # define       LD_WU(rd, rj, si12)      os12rr(0x0aa,        si12,   rj,     rd)
 254 # define       PRELD(hint, rj, si12)   os12ru5(0x0ab,        si12,   rj ,  hint)
 255 # define       LDX_B(rd, rj, rk)         orrr(0x7000,          rk,   rj,     rd)
 256 # define       LDX_H(rd, rj, rk)         orrr(0x7008,          rk,   rj,     rd)
 257 # define       LDX_W(rd, rj, rk)         orrr(0x7010,          rk,   rj,     rd)
 258 # define       LDX_D(rd, rj, rk)         orrr(0x7018,          rk,   rj,     rd)
 259 # define       STX_B(rd, rj, rk)         orrr(0x7020,          rk,   rj,     rd)
 260 # define       STX_H(rd, rj, rk)         orrr(0x7028,          rk,   rj,     rd)
 261 # define       STX_W(rd, rj, rk)         orrr(0x7030,          rk,   rj,     rd)
 262 # define       STX_D(rd, rj, rk)         orrr(0x7038,          rk,   rj,     rd)
 263 # define      LDX_BU(rd, rj, rk)         orrr(0x7040,          rk,   rj,     rd)
 264 # define      LDX_HU(rd, rj, rk)         orrr(0x7048,          rk,   rj,     rd)
 265 # define      LDX_WU(rd, rj, rk)         orrr(0x7050,          rk,   rj,     rd)
 266 # define      PRELDX(hint, rj, rk)      orru5(0x7058,          rk,   rj,   hint)
 267 # define    AMSWAP_W(rd, rj, rk)         orrr(0x70c0,          rk,   rj,     rd)
 268 # define    AMSWAP_D(rd, rj, rk)         orrr(0x70c1,          rk,   rj,     rd)
 269 # define     AMADD_W(rd, rj, rk)         orrr(0x70c2,          rk,   rj,     rd)
 270 # define     AMADD_D(rd, rj, rk)         orrr(0x70c3,          rk,   rj,     rd)
 271 # define     AMAND_W(rd, rj, rk)         orrr(0x70c4,          rk,   rj,     rd)
 272 # define     AMAND_D(rd, rj, rk)         orrr(0x70c5,          rk,   rj,     rd)
 273 # define      AMOR_W(rd, rj, rk)         orrr(0x70c6,          rk,   rj,     rd)
 274 # define      AMOR_D(rd, rj, rk)         orrr(0x70c7,          rk,   rj,     rd)
 275 # define     AMXOR_W(rd, rj, rk)         orrr(0x70c8,          rk,   rj,     rd)
 276 # define     AMXOR_D(rd, rj, rk)         orrr(0x70c9,          rk,   rj,     rd)
 277 # define     AMMAX_W(rd, rj, rk)         orrr(0x70ca,          rk,   rj,     rd)
 278 # define     AMMAX_D(rd, rj, rk)         orrr(0x70cb,          rk,   rj,     rd)
 279 # define     AMMIN_W(rd, rj, rk)         orrr(0x70cc,          rk,   rj,     rd)
 280 # define     AMMIN_D(rd, rj, rk)         orrr(0x70cd,          rk,   rj,     rd)
 281 # define    AMMAX_WU(rd, rj, rk)         orrr(0x70ce,          rk,   rj,     rd)
 282 # define    AMMAX_DU(rd, rj, rk)         orrr(0x70cf,          rk,   rj,     rd)
 283 # define    AMMIN_WU(rd, rj, rk)         orrr(0x70d0,          rk,   rj,     rd)
 284 # define    AMMIN_DU(rd, rj, rk)         orrr(0x70d1,          rk,   rj,     rd)
 285 # define AMSWAP_DB_W(rd, rj, rk)         orrr(0x70d2,          rk,   rj,     rd)
 286 # define AMSWAP_DB_D(rd, rj, rk)         orrr(0x70d3,          rk,   rj,     rd)
 287 # define  AMADD_DB_W(rd, rj, rk)         orrr(0x70d4,          rk,   rj,     rd)
 288 # define  AMADD_DB_D(rd, rj, rk)         orrr(0x70d5,          rk,   rj,     rd)
 289 # define  AMAND_DB_W(rd, rj, rk)         orrr(0x70d6,          rk,   rj,     rd)
 290 # define  AMAND_DB_D(rd, rj, rk)         orrr(0x70d7,          rk,   rj,     rd)
 291 # define   AMOR_DB_W(rd, rj, rk)         orrr(0x70d8,          rk,   rj,     rd)
 292 # define   AMOR_DB_D(rd, rj, rk)         orrr(0x70d9,          rk,   rj,     rd)
 293 # define  AMXOR_DB_W(rd, rj, rk)         orrr(0x70da,          rk,   rj,     rd)
 294 # define  AMXOR_DB_D(rd, rj, rk)         orrr(0x70db,          rk,   rj,     rd)
 295 # define  AMMAX_DB_W(rd, rj, rk)         orrr(0x70dc,          rk,   rj,     rd)
 296 # define  AMMAX_DB_D(rd, rj, rk)         orrr(0x70dd,          rk,   rj,     rd)
 297 # define  AMMIN_DB_W(rd, rj, rk)         orrr(0x70de,          rk,   rj,     rd)
 298 # define  AMMIN_DB_D(rd, rj, rk)         orrr(0x70df,          rk,   rj,     rd)
 299 # define AMMAX_DB_WU(rd, rj, rk)         orrr(0x70e0,          rk,   rj,     rd)
 300 # define AMMAX_DB_DU(rd, rj, rk)         orrr(0x70e1,          rk,   rj,     rd)
 301 # define AMMIN_DB_WU(rd, rj, rk)         orrr(0x70e2,          rk,   rj,     rd)
 302 # define AMMIN_DB_DU(rd, rj, rk)         orrr(0x70e3,          rk,   rj,     rd)
 303 # define        DBAR(hint)               ou15(0x70e4,                      hint)
 304 # define        IBAR(hint)               ou15(0x70e5,                      hint)
 305 # define      LDGT_B(rd, rj, rk)         orrr(0x70f0,          rk,   rj,     rd)
 306 # define      LDGT_H(rd, rj, rk)         orrr(0x70f1,          rk,   rj,     rd)
 307 # define      LDGT_W(rd, rj, rk)         orrr(0x70f2,          rk,   rj,     rd)
 308 # define      LDGT_D(rd, rj, rk)         orrr(0x70f3,          rk,   rj,     rd)
 309 # define      LDLE_B(rd, rj, rk)         orrr(0x70f4,          rk,   rj,     rd)
 310 # define      LDLE_H(rd, rj, rk)         orrr(0x70f5,          rk,   rj,     rd)
 311 # define      LDLE_W(rd, rj, rk)         orrr(0x70f6,          rk,   rj,     rd)
 312 # define      LDLE_D(rd, rj, rk)         orrr(0x70f7,          rk,   rj,     rd)
 313 # define      STGT_B(rd, rj, rk)         orrr(0x70f8,          rk,   rj,     rd)
 314 # define      STGT_H(rd, rj, rk)         orrr(0x70f9,          rk,   rj,     rd)
 315 # define      STGT_W(rd, rj, rk)         orrr(0x70fa,          rk,   rj,     rd)
 316 # define      STGT_D(rd, rj, rk)         orrr(0x70fb,          rk,   rj,     rd)
 317 # define      STLE_B(rd, rj, rk)         orrr(0x70fc,          rk,   rj,     rd)
 318 # define      STLE_H(rd, rj, rk)         orrr(0x70rd,          rk,   rj,     rd)
 319 # define      STLE_W(rd, rj, rk)         orrr(0x70fe,          rk,   rj,     rd)
 320 # define      STLE_D(rd, rj, rk)         orrr(0x70ff,          rk,   rj,     rd)
 321 # define        BEQZ(    rj, offs)       orj21(0x010,                rj,   offs)
 322 # define        BNEZ(    rj, offs)       orj21(0x011,                rj,   offs)
 323 # define       BCEQZ(    cj, offs)    ou2u3j21(0x012,           0x0, cj,   offs)
 324 # define       BCNEZ(    cj, offs)    ou2u3j21(0x012,           0x1, cj,   offs)
 325 # define        JIRL(rd, rj, offs)      oj16rr(0x013,        offs,   rj,     rd)
 326 # define           B(offs)                oj26(0x014,                      offs)
 327 # define          BL(offs)                oj26(0x015,                      offs)
 328 # define         BEQ(rj, rd, offs)      oj16rr(0x016,        offs,   rj,     rd)
 329 # define         BNE(rj, rd, offs)      oj16rr(0x017,        offs,   rj,     rd)
 330 # define         BLT(rj, rd, offs)      oj16rr(0x018,        offs,   rj,     rd)
 331 # define         BGE(rj, rd, offs)      oj16rr(0x019,        offs,   rj,     rd)
 332 # define        BLTU(rj, rd, offs)      oj16rr(0x01a,        offs,   rj,     rd)
 333 # define        BGEU(rj, rd, offs)      oj16rr(0x01b,        offs,   rj,     rd)
 334 # define NOP()                          ANDI(_ZERO_REGNO, _ZERO_REGNO, 0)
 335 # define nop(i0)                        _nop(_jit, i0)
 336 # define comr(r0, r1)                   NOR(r0, r1, r1)
 337 # define negr(r0, r1)                   subr(r0, _ZERO_REGNO, r1)
 338 static void _nop(jit_state_t*,jit_int32_t);
 339 # define movr(r0, r1)                   _movr(_jit, r0, r1)
 340 static void _movr(jit_state_t*, jit_int32_t, jit_int32_t);
 341 # define movi(r0, i0)                   _movi(_jit, r0, i0)
 342 static void _movi(jit_state_t*, jit_int32_t, jit_word_t);
 343 # define movi_p(r0, i0)                 _movi_p(_jit, r0, i0)
 344 static jit_word_t _movi_p(jit_state_t*, jit_int32_t, jit_word_t);
 345 #  define movnr(r0, r1, r2)             _movnr(_jit, r0, r1, r2)
 346 static void _movnr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 347 #  define movzr(r0, r1, r2)             _movzr(_jit, r0, r1, r2)
 348 static void _movzr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 349 #  define casx(r0, r1, r2, r3, i0)      _casx(_jit, r0, r1, r2, r3, i0)
 350 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 351                   jit_int32_t,jit_int32_t,jit_word_t);
 352 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 353 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 354 # define addr(r0, r1, r2)               ADD_D(r0, r1, r2)
 355 # define addi(r0, r1, i0)               _addi(_jit, r0, r1, i0)
 356 static void _addi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 357 # define addcr(r0, r1, r2)              _addcr(_jit, r0, r1, r2)
 358 static void _addcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 359 # define addci(r0, r1, i0)              _addci(_jit, r0, r1, i0)
 360 static void _addci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 361 # define addxr(r0, r1, r2)              _addxr(_jit, r0, r1, r2)
 362 static void _addxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 363 # define addxi(r0, r1, i0)              _addxi(_jit, r0, r1, i0)
 364 static void _addxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 365 # define subr(r0, r1, r2)               SUB_D(r0, r1, r2)
 366 # define subi(r0, r1, i0)               _subi(_jit, r0, r1, i0)
 367 static void _subi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 368 # define subcr(r0, r1, r2)              _subcr(_jit, r0, r1, r2)
 369 static void _subcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 370 # define subci(r0, r1, i0)              _subci(_jit, r0, r1, i0)
 371 static void _subci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 372 # define subxr(r0, r1, r2)              _subxr(_jit, r0, r1, r2)
 373 static void _subxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 374 # define subxi(r0, r1, i0)              _subxi(_jit, r0, r1, i0)
 375 static void _subxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 376 #  define rsbi(r0, r1, i0)              _rsbi(_jit, r0, r1, i0)
 377 static void _rsbi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 378 # define mulr(r0, r1, r2)               MUL_D(r0, r1, r2)
 379 # define muli(r0, r1, i0)               _muli(_jit, r0, r1, i0)
 380 static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 381 # define qmulr(r0, r1, r2, r3)          iqmulr(r0, r1, r2, r3, 1)
 382 # define qmulr_u(r0, r1, r2, r3)        iqmulr(r0, r1, r2, r3, 0)
 383 # define iqmulr(r0, r1, r2, r3, sign)   _iqmulr(_jit, r0, r1, r2, r3, sign)
 384 static void _iqmulr(jit_state_t*, jit_int32_t, jit_int32_t,
 385                     jit_int32_t, jit_int32_t, jit_bool_t);
 386 # define qmuli(r0, r1, r2, i0)          iqmuli(r0, r1, r2, i0, 1)
 387 # define qmuli_u(r0, r1, r2, i0)        iqmuli(r0, r1, r2, i0, 0)
 388 # define iqmuli(r0, r1, r2, i0, sign)   _iqmuli(_jit, r0, r1, r2, i0, sign)
 389 static void _iqmuli(jit_state_t*, jit_int32_t, jit_int32_t,
 390                     jit_int32_t, jit_word_t, jit_bool_t);
 391 #  define divr(r0, r1, r2)              DIV_D(r0, r1, r2)
 392 #  define divi(r0, r1, i0)              _divi(_jit, r0, r1, i0)
 393 static void _divi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 394 #  define divr_u(r0, r1, r2)            DIV_DU(r0, r1, r2)
 395 #  define divi_u(r0, r1, i0)            _divi_u(_jit, r0, r1, i0)
 396 static void _divi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 397 #  define qdivr(r0, r1, r2, r3)         iqdivr(r0, r1, r2, r3, 1)
 398 #  define qdivr_u(r0, r1, r2, r3)       iqdivr(r0, r1, r2, r3, 0)
 399 #  define iqdivr(r0, r1, r2, r3, sign)  _iqdivr(_jit, r0, r1, r2, r3, sign)
 400 static void _iqdivr(jit_state_t*, jit_int32_t, jit_int32_t,
 401                     jit_int32_t, jit_int32_t, jit_bool_t);
 402 #  define qdivi(r0, r1, r2, i0)         iqdivi(r0, r1, r2, i0, 1)
 403 #  define qdivi_u(r0, r1, r2, i0)       iqdivi(r0, r1, r2, i0, 0)
 404 #  define iqdivi(r0, r1, r2, i0, sign)  _iqdivi(_jit, r0, r1, r2, i0, sign)
 405 static void _iqdivi(jit_state_t*, jit_int32_t, jit_int32_t,
 406                     jit_int32_t, jit_word_t, jit_bool_t);
 407 #  define remr(r0, r1, r2)              MOD_D(r0, r1, r2)
 408 #  define remi(r0, r1, i0)              _remi(_jit, r0, r1, i0)
 409 static void _remi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 410 #  define remr_u(r0, r1, r2)            MOD_DU(r0, r1, r2)
 411 #  define remi_u(r0, r1, i0)            _remi_u(_jit, r0, r1, i0)
 412 static void _remi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 413 # define lshr(r0, r1, r2)               SLL_D(r0, r1, r2)
 414 # define lshi(r0, r1, i0)               SLLI_D(r0, r1, i0)
 415 # define rshr(r0, r1, r2)               SRA_D(r0, r1, r2)
 416 # define rshi(r0, r1, i0)               SRAI_D(r0, r1, i0)
 417 # define rshr_u(r0, r1, r2)             SRL_D(r0, r1, r2)
 418 # define rshi_u(r0, r1, i0)             SRLI_D(r0, r1, i0)
 419 # define andr(r0, r1, r2)               AND(r0, r1, r2)
 420 # define andi(r0, r1, i0)               _andi(_jit, r0, r1, i0)
 421 static void _andi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 422 # define orr(r0, r1, r2)                OR(r0, r1, r2)
 423 # define ori(r0, r1, i0)                _ori(_jit, r0, r1, i0)
 424 static void _ori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 425 # define xorr(r0, r1, r2)               XOR(r0, r1, r2)
 426 # define xori(r0, r1, i0)               _xori(_jit, r0, r1, i0)
 427 static void _xori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 428 # define ldr_c(r0, r1)                  LD_B(r0, r1, 0)
 429 # define ldi_c(r0, i0)                  _ldi_c(_jit, r0, i0)
 430 static void _ldi_c(jit_state_t*, jit_int32_t, jit_word_t);
 431 # define ldr_uc( r0, r1)                LD_BU(r0, r1, 0)
 432 # define ldi_uc(r0, i0)                 _ldi_uc(_jit, r0, i0)
 433 static void _ldi_uc(jit_state_t*, jit_int32_t, jit_word_t);
 434 # define ldr_s(r0, r1)                  LD_H(r0, r1, 0)
 435 # define ldi_s(r0, i0)                  _ldi_s(_jit, r0, i0)
 436 static void _ldi_s(jit_state_t*, jit_int32_t, jit_word_t);
 437 # define ldr_us(r0, r1)                 LD_HU(r0, r1, 0)
 438 # define ldi_us(r0, i0)                 _ldi_us(_jit, r0, i0)
 439 static void _ldi_us(jit_state_t*, jit_int32_t, jit_word_t);
 440 # define ldr_i(r0, r1)                  LD_W(r0, r1, 0)
 441 # define ldi_i(r0, i0)                  _ldi_i(_jit, r0, i0)
 442 static void _ldi_i(jit_state_t*, jit_int32_t, jit_word_t);
 443 # define ldr_ui(r0, r1)                 LD_WU(r0, r1, 0)
 444 # define ldi_ui(r0, i0)                 _ldi_ui(_jit, r0, i0)
 445 static void _ldi_ui(jit_state_t*, jit_int32_t, jit_word_t);
 446 # define ldr_l(r0, r1)                  LD_D(r0, r1, 0)
 447 # define ldi_l(r0, i0)                  _ldi_l(_jit, r0, i0)
 448 static void _ldi_l(jit_state_t*, jit_int32_t, jit_word_t);
 449 # define ldxr_c(r0, r1, r2)             LDX_B(r0, r1, r2)
 450 # define ldxi_c(r0, r1, i0)             _ldxi_c(_jit, r0, r1, i0)
 451 static void _ldxi_c(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 452 # define ldxr_uc(r0, r1, r2)            LDX_BU(r0, r1, r2)
 453 # define ldxi_uc(r0, r1, i0)            _ldxi_uc(_jit,r0, r1, i0)
 454 static void _ldxi_uc(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 455 # define ldxr_s(r0, r1, r2)             LDX_H(r0, r1, r2)
 456 # define ldxi_s(r0, r1, i0)             _ldxi_s(_jit, r0, r1, i0)
 457 static void _ldxi_s(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 458 # define ldxr_us(r0, r1, r2)            LDX_HU(r0, r1, r2)
 459 # define ldxi_us(r0, r1, i0)            _ldxi_us(_jit, r0, r1, i0)
 460 static void _ldxi_us(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 461 # define ldxr_i(r0, r1, r2)             LDX_W(r0, r1, r2)
 462 # define ldxi_i(r0, r1, i0)             _ldxi_i(_jit, r0, r1, i0)
 463 static void _ldxi_i(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 464 # define ldxr_ui(r0, r1, r2)            LDX_WU(r0, r1, r2)
 465 # define ldxi_ui(r0, r1, i0)            _ldxi_ui(_jit, r0, r1, i0)
 466 static void _ldxi_ui(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 467 # define ldxr_l(r0, r1, r2)             LDX_D(r0, r1, r2)
 468 # define ldxi_l(r0, r1, i0)             _ldxi_l(_jit, r0, r1, i0)
 469 static void _ldxi_l(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 470 # define str_c(r0, r1)                  ST_B(r1, r0, 0)
 471 # define sti_c(i0, r0)                  _sti_c(_jit, i0, r0)
 472 static void _sti_c(jit_state_t*, jit_word_t, jit_int32_t);
 473 # define str_s(r0, r1)                  ST_H(r1, r0, 0)
 474 # define sti_s(i0, r0)                  _sti_s(_jit, i0, r0)
 475 static void _sti_s(jit_state_t*, jit_word_t, jit_int32_t);
 476 # define str_i(r0, r1)                  ST_W(r1, r0, 0)
 477 # define sti_i(i0, r0)                  _sti_i(_jit, i0, r0)
 478 static void _sti_i(jit_state_t*, jit_word_t, jit_int32_t);
 479 # define str_l(r0, r1)                  ST_D(r1, r0, 0)
 480 # define sti_l(i0, r0)                  _sti_l(_jit, i0, r0)
 481 static void _sti_l(jit_state_t*, jit_word_t, jit_int32_t);
 482 # define stxr_c(r0, r1, r2)             STX_B(r2, r1, r0)
 483 # define stxi_c(i0, r0, r1)             _stxi_c(_jit,i0, r0, r1)
 484 static void _stxi_c(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 485 # define stxr_s(r0, r1, r2)             STX_H(r2, r1, r0)
 486 # define stxi_s(i0, r0, r1)             _stxi_s(_jit, i0, r0, r1)
 487 static void _stxi_s(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 488 # define stxr_i(r0, r1, r2)             STX_W(r2, r1, r0)
 489 # define stxi_i(i0, r0, r1)             _stxi_i(_jit, i0, r0, r1)
 490 static void _stxi_i(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 491 # define stxr_l(r0, r1, r2)             STX_D(r2, r1, r0)
 492 # define stxi_l(i0, r0, r1)             _stxi_l(_jit, i0, r0, r1)
 493 static void _stxi_l(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 494 # define bswapr_us(r0,r1)               _bswapr_us(_jit,r0,r1)
 495 static void _bswapr_us(jit_state_t*, jit_int32_t, jit_int32_t);
 496 # define bswapr_ui(r0,r1)               _bswapr_ui(_jit,r0,r1)
 497 static void _bswapr_ui(jit_state_t*, jit_int32_t, jit_int32_t);
 498 # define bswapr_ul(r0, r1)              REVB_D(r0, r1)
 499 # define extr_c(r0, r1)                 EXT_W_B(r0, r1)
 500 # define extr_uc(r0, r1)                BSTRPICK_D(r0, r1, 7, 0)
 501 # define extr_s(r0, r1)                 EXT_W_H(r0, r1)
 502 # define extr_us(r0, r1)                BSTRPICK_D(r0, r1, 15, 0)
 503 # define extr_i(r0, r1)                 SLLI_W(r0, r1, 0)
 504 # define extr_ui(r0, r1)                BSTRPICK_D(r0, r1, 31, 0)
 505 # define ltr(r0, r1, r2)                SLT(r0, r1, r2)
 506 # define lti(r0, r1, i0)                _lti(_jit, r0, r1, i0)
 507 static void _lti(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 508 # define ltr_u(r0, r1, r2)              SLTU(r0, r1, r2)
 509 # define lti_u(r0, r1, i0)              _lti_u(_jit, r0, r1, i0)
 510 static void _lti_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 511 # define ler(r0, r1, r2)                _ler(_jit, r0, r1, r2)
 512 static void _ler(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 513 # define lei(r0, r1, i0)                _lei(_jit, r0, r1, i0)
 514 static void _lei(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 515 # define ler_u(r0, r1, r2)              _ler_u(_jit, r0, r1, r2)
 516 static void _ler_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 517 # define lei_u(r0, r1, i0)              _lei_u(_jit, r0, r1, i0)
 518 static void _lei_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 519 # define eqr(r0, r1, r2)                _eqr(_jit, r0, r1, r2)
 520 static void _eqr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 521 # define eqi(r0, r1, i0)                _eqi(_jit, r0, r1, i0)
 522 static void _eqi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 523 # define ger(r0, r1, r2)                _ger(_jit, r0, r1, r2)
 524 static void _ger(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 525 # define gei(r0, r1, i0)                _gei(_jit, r0, r1, i0)
 526 static void _gei(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 527 # define ger_u(r0, r1, r2)              _ger_u(_jit, r0, r1, r2)
 528 static void _ger_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 529 # define gei_u(r0, r1, i0)              _gei_u(_jit, r0, r1, i0)
 530 static void _gei_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 531 # define gtr(r0, r1, r2)                SLT(r0, r2, r1)
 532 # define gti(r0, r1, i0)                _gti(_jit, r0, r1, i0)
 533 static void _gti(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 534 # define gtr_u(r0, r1, r2)              SLTU(r0, r2, r1)
 535 # define gti_u(r0, r1, i0)              _gti_u(_jit, r0, r1, i0)
 536 static void _gti_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 537 # define ner(r0, r1, r2)                _ner(_jit, r0, r1, r2)
 538 static void _ner(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 539 # define nei(r0, r1, i0)                _nei(_jit, r0, r1, i0)
 540 static void _nei(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
 541 # define bltr(i0, r0, r1)               _bltr(_jit, i0, r0, r1)
 542 static jit_word_t _bltr(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 543 # define blti(i0, r0, i1)               _blti(_jit, i0, r0, i1)
 544 static jit_word_t _blti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 545 # define bltr_u(i0, r0, r1)             _bltr_u(_jit, i0, r0, r1)
 546 static jit_word_t _bltr_u(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 547 # define blti_u(i0, r0, i1)             _blti_u(_jit, i0, r0, i1)
 548 static jit_word_t _blti_u(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 549 # define bler(i0, r0, r1)               _bler(_jit, i0, r0, r1)
 550 static jit_word_t _bler(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 551 # define blei(i0, r0, i1)               _blei(_jit, i0, r0, i1)
 552 static jit_word_t _blei(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 553 # define bler_u(i0, r0, r1)             _bler_u(_jit, i0, r0, r1)
 554 static jit_word_t _bler_u(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 555 # define blei_u(i0, r0, i1)             _blei_u(_jit, i0, r0, i1)
 556 static jit_word_t _blei_u(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 557 # define beqr(i0, r0, r1)               _beqr(_jit, i0, r0, r1)
 558 static jit_word_t _beqr(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 559 # define beqi(i0, r0, i1)               _beqi(_jit, i0, r0, i1)
 560 static jit_word_t _beqi(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 561 # define bger(i0, r0, r1)               _bger(_jit, i0, r0, r1)
 562 static jit_word_t _bger(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 563 # define bgei(i0, r0, i1)               _bgei(_jit, i0, r0, i1)
 564 static jit_word_t _bgei(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 565 # define bger_u(i0, r0, r1)             _bger_u(_jit, i0, r0, r1)
 566 static jit_word_t _bger_u(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 567 # define bgei_u(i0, r0, i1)             _bgei_u(_jit, i0, r0, i1)
 568 static jit_word_t _bgei_u(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 569 # define bgtr(i0, r0, r1)               _bgtr(_jit, i0, r0, r1)
 570 static jit_word_t _bgtr(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 571 # define bgti(i0, r0, i1)               _bgti(_jit, i0, r0, i1)
 572 static jit_word_t _bgti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 573 # define bgtr_u(i0, r0, r1)             _bgtr_u(_jit, i0, r0, r1)
 574 static jit_word_t _bgtr_u(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 575 # define bgti_u(i0, r0, i1)             _bgti_u(_jit, i0, r0, i1)
 576 static jit_word_t _bgti_u(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 577 # define bner(i0, r0, r1)               _bner(_jit, i0, r0, r1)
 578 static jit_word_t _bner(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 579 # define bnei(i0, r0, i1)               _bnei(_jit, i0, r0, i1)
 580 static jit_word_t _bnei(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 581 # define jmpr(r0)                       JIRL(_ZERO_REGNO, r0, 0)
 582 # define jmpi(i0)                       _jmpi(_jit, i0)
 583 static void _jmpi(jit_state_t*, jit_word_t);
 584 # define jmpi_p(i0)                     _jmpi_p(_jit, i0)
 585 static jit_word_t _jmpi_p(jit_state_t*, jit_word_t);
 586 # define boaddr(i0, r0, r1)             _boaddr(_jit, i0, r0, r1)
 587 static jit_word_t _boaddr(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 588 # define boaddi(i0, r0, i1)             _boaddi(_jit, i0, r0, i1)
 589 static jit_word_t _boaddi(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 590 # define boaddr_u(i0, r0, r1)           _boaddr_u(_jit, i0, r0, r1)
 591 static jit_word_t _boaddr_u(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 592 # define boaddi_u(i0, r0, i1)           _boaddi_u(_jit, i0, r0, i1)
 593 static jit_word_t _boaddi_u(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 594 # define bxaddr(i0, r0, r1)             _bxaddr(_jit, i0, r0, r1)
 595 static jit_word_t _bxaddr(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 596 # define bxaddi(i0, r0, i1)             _bxaddi(_jit, i0, r0, i1)
 597 static jit_word_t _bxaddi(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 598 # define bxaddr_u(i0, r0, r1)           _bxaddr_u(_jit, i0, r0, r1)
 599 static jit_word_t _bxaddr_u(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 600 # define bxaddi_u(i0, r0, i1)           _bxaddi_u(_jit, i0, r0, i1)
 601 static jit_word_t _bxaddi_u(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 602 # define bosubr(i0, r0, r1)             _bosubr(_jit, i0, r0, r1)
 603 static jit_word_t _bosubr(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 604 # define bosubi(i0, r0, i1)             _bosubi(_jit, i0, r0, i1)
 605 static jit_word_t _bosubi(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 606 # define bosubr_u(i0, r0, r1)           _bosubr_u(_jit, i0, r0, r1)
 607 static jit_word_t _bosubr_u(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 608 # define bosubi_u(i0, r0, i1)           _bosubi_u(_jit, i0, r0, i1)
 609 static jit_word_t _bosubi_u(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 610 # define bxsubr(i0, r0, r1)             _bxsubr(_jit, i0, r0, r1)
 611 static jit_word_t _bxsubr(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 612 # define bxsubi(i0, r0, i1)             _bxsubi(_jit, i0, r0, i1)
 613 static jit_word_t _bxsubi(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 614 # define bxsubr_u(i0, r0, r1)           _bxsubr_u(_jit, i0, r0, r1)
 615 static jit_word_t _bxsubr_u(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
 616 # define bxsubi_u(i0, r0, i1)           _bxsubi_u(_jit, i0, r0, i1)
 617 static jit_word_t _bxsubi_u(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
 618 # define bmsr(br, r0, r1)               _bmsr(_jit, br, r0, r1)
 619 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 620 # define bmsi(br, r0, i0)               _bmsi(_jit, br, r0, i0)
 621 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 622 # define bmcr(br, r0, r1)               _bmcr(_jit, br, r0, r1)
 623 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 624 # define bmci(br, r0, i0)               _bmci(_jit, br, r0, i0)
 625 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 626 # define callr(r0)                      JIRL(_RA_REGNO, r0, 0)
 627 # define calli(i0)                      _calli(_jit, i0)
 628 static void _calli(jit_state_t*, jit_word_t);
 629 # define calli_p(i0)                    _calli_p(_jit, i0)
 630 static jit_word_t _calli_p(jit_state_t*, jit_word_t);
 631 # define prolog(i0)                     _prolog(_jit, i0)
 632 static void _prolog(jit_state_t*, jit_node_t*);
 633 # define epilog(i0)                     _epilog(_jit, i0)
 634 static void _epilog(jit_state_t*, jit_node_t*);
 635 # define vastart(r0)                    _vastart(_jit, r0)
 636 static void _vastart(jit_state_t*, jit_int32_t);
 637 # define vaarg(r0, r1)                  _vaarg(_jit, r0, r1)
 638 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 639 #define patch_at(jump, label)           _patch_at(_jit, jump, label)
 640 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 641 #endif
 642
 643 #if CODE
 644 static void
 645 _orrr(jit_state_t *_jit,
 646       jit_int32_t op, jit_int32_t rk, jit_int32_t rj, jit_int32_t rd)
 647 {
 648     assert(!(op & ~0xffff));
 649     assert(!(rk &   ~0x1f));
 650     assert(!(rj &   ~0x1f));
 651     assert(!(rd &   ~0x1f));
 652     ii((op << 15) | (rk << 10) | (rj << 5) | rd);
 653 }
 654
 655 static void
 656 _ou2rrr(jit_state_t *_jit, jit_int32_t op,
 657         jit_int32_t u2, jit_int32_t rk, jit_int32_t rj, jit_int32_t rd)
 658 {
 659     assert(!(op & ~0x7ff));
 660     assert(!(u2 &     ~3));
 661     assert(!(rk &  ~0x1f));
 662     assert(!(rj &  ~0x1f));
 663     assert(!(rd &  ~0x1f));
 664     ii((op << 17) | (u2 << 15) | (rk << 10) | (rj << 5) | rd);
 665 }
 666
 667 static void
 668 _ou3rrr(jit_state_t *_jit, jit_int32_t op,
 669         jit_int32_t u3, jit_int32_t rk, jit_int32_t rj, jit_int32_t rd)
 670 {
 671     assert(!(op & ~0x3ff));
 672     assert(!(u3 &     ~7));
 673     assert(!(rk &  ~0x1f));
 674     assert(!(rj &  ~0x1f));
 675     assert(!(rd &  ~0x1f));
 676     ii((op << 18) | (u3 << 15) | (rk << 10) | (rj << 5) | rd);
 677 }
 678
 679 static void
 680 _ou6rr(jit_state_t *_jit, jit_int32_t op,
 681        jit_int32_t u6, jit_int32_t rj, jit_int32_t rd)
 682 {
 683     assert(!(op & ~0x3ff));
 684     assert(!(u6 &  ~0x3f));
 685     assert(!(rj &  ~0x1f));
 686     assert(!(rd &  ~0x1f));
 687     ii((op << 16) | (u6 << 10) | (rj << 5) | rd);
 688 }
 689
 690 static void
 691 _ou5u1u5rr(jit_state_t *_jit, jit_int32_t op, jit_int32_t m5,
 692            jit_int32_t u1, jit_int32_t l5, jit_int32_t rj, jit_int32_t rd)
 693 {
 694     assert(!(op & ~0x7ff));
 695     assert(!(m5 &  ~0x1f));
 696     assert(!(u1  &     ~1));
 697     assert(!(l5 &  ~0x1f));
 698     assert(!(rj &  ~0x1f));
 699     assert(!(rd &  ~0x1f));
 700     ii((op << 21) | (m5 << 16) | (u1 << 15) | (l5 << 10) | (rj << 5) | rd);
 701 }
 702
 703 static void
 704 _ou6u6rr(jit_state_t *_jit, jit_int32_t op,
 705          jit_int32_t m6, jit_int32_t l6, jit_int32_t rj, jit_int32_t rd)
 706 {
 707     assert(!(op & ~0x3ff));
 708     assert(!(m6 &  ~0x3f));
 709     assert(!(l6 &  ~0x3f));
 710     assert(!(rj &  ~0x1f));
 711     assert(!(rd &  ~0x1f));
 712     ii((op << 22) | (m6 << 16) | (l6 << 10) | (rj << 5) | rd);
 713 }
 714
 715 static void
 716 _o5r23(jit_state_t *_jit, jit_int32_t op,
 717        jit_int32_t i5, jit_int32_t rj, jit_int32_t i2, jit_int32_t i3)
 718 {
 719     assert(!(op & ~0xffff));
 720     assert(!(i5 &   ~0x3f));
 721     assert(!(rj &   ~0x3f));
 722     assert(!(i2 &    ~0x3));
 723     assert(!(i3 &   ~0x1f));
 724     ii((op << 15) | (i5 << 10) | (rj << 5) | (i2 << 3) | i3);
 725 }
 726
 727 static void
 728 _o523r(jit_state_t *_jit, jit_int32_t op,
 729        jit_int32_t i5, jit_int32_t i2, jit_int32_t i3, jit_int32_t rd)
 730 {
 731     assert(!(op & ~0xffff));
 732     assert(!(i5 &   ~0x3f));
 733     assert(!(i2 &    ~0x3));
 734     assert(!(i3 &    ~0x7));
 735     assert(!(rd &   ~0x3f));
 736     ii((op << 15) | (i5 << 10) | (i2 << 8) | (i3 << 5) | rd);
 737 }
 738
 739 static void
 740 _os12rr(jit_state_t *_jit,
 741         jit_int32_t op, jit_int32_t s12, jit_int32_t rj, jit_int32_t rd)
 742 {
 743     assert(!(op  &  ~0x3ff));
 744     assert(s12   <=   2047 && s12 >= -2048);     s12 &= 0xfff;
 745     assert(!(rj  &   ~0x1f));
 746     assert(!(rd  &   ~0x1f));
 747     ii((op << 22) | (s12 << 10) | (rj << 5) | rd);
 748 }
 749
 750 static void
 751 _ou12rr(jit_state_t *_jit,
 752         jit_int32_t op, jit_int32_t u12, jit_int32_t rj, jit_int32_t rd)
 753 {
 754     assert(!(op  & ~0x3ff));
 755     assert(!(u12 & ~0xfff));
 756     assert(!(rj  &  ~0x1f));
 757     assert(!(rd  &  ~0x1f));
 758     ii((op << 22) | (u12 << 10) | (rj << 5) | rd);
 759 }
 760
 761 static void
 762 _ou14u5r(jit_state_t *_jit,
 763          jit_int32_t op, jit_int32_t u14, jit_int32_t u5, jit_int32_t rd)
 764 {
 765     assert(!(op  &   ~0xff));
 766     assert(!(u14 & ~0x3fff));
 767     assert(!(u5 &    ~0x1f));
 768     assert(!(rd &    ~0x1f));
 769     ii((op << 24) | (u14 << 10) | (u5 << 5) | rd);
 770 }
 771
 772 static void
 773 _os14rr(jit_state_t *_jit,
 774         jit_int32_t op, jit_int32_t s14, jit_int32_t rj, jit_int32_t rd)
 775 {
 776     assert(!(op &   ~0xff));
 777     assert(s14  <=    8191 && s14 >= -8192);            s14 &= 0x3fff;
 778     assert(!(rj &    ~0x1f));
 779     assert(!(rd &    ~0x1f));
 780     ii((op << 24) | (s14 << 10) | (rj << 5) | rd);
 781 }
 782
 783 static void
 784 _ou8rr(jit_state_t *_jit, jit_int32_t op,
 785        jit_int32_t u8, jit_int32_t rj, jit_int32_t rd)
 786 {
 787     assert(!(op & ~0x3fff));
 788     assert(!(u8 &   ~0xff));
 789     assert(!(rj &   ~0x1f));
 790     assert(!(rd &   ~0x1f));
 791     ii((op << 18) | (u8 << 10) | (rj << 5) | rd);
 792 }
 793
 794 static void
 795 _ou15(jit_state_t *_jit, jit_int32_t op, jit_int32_t u15)
 796 {
 797     assert(!(op  & ~0x1ffff));
 798     assert(!(u15 &  ~0x7fff));
 799     ii((op << 15) | u15);
 800 }
 801
 802 static void
 803 _orrrr(jit_state_t *_jit, jit_int32_t op,
 804        jit_int32_t ra, jit_int32_t rk, jit_int32_t rj, jit_int32_t rd)
 805 {
 806     assert(!(op & ~0xfff));
 807     assert(!(ra &  ~0x1f));
 808     assert(!(rk &  ~0x1f));
 809     assert(!(rj &  ~0x1f));
 810     assert(!(rd &  ~0x1f));
 811     ii((op << 20) | (ra << 15) | (rk << 10) | (rj << 5) | rd);
 812 }
 813
 814 static void
 815 _ou5rru2u3(jit_state_t *_jit,jit_int32_t op, jit_int32_t u5,
 816            jit_int32_t rk, jit_int32_t rj, jit_int32_t u2, jit_int32_t u3)
 817 {
 818     assert(!(op & ~0xfff));
 819     assert(!(u5 &  ~0x1f));
 820     assert(!(rk &  ~0x1f));
 821     assert(!(rj &  ~0x1f));
 822     assert(!(u2 &     ~3));
 823     assert(!(u3 &     ~7));
 824     ii((op << 20) | (u5 << 15) | (rk << 10) | (rj << 5) | (u2 << 3) | u3);
 825 }
 826
 827 static void
 828 _os16rr(jit_state_t *_jit,
 829         jit_int32_t op, jit_int32_t s16, jit_int32_t rj, jit_int32_t rd)
 830 {
 831     assert(!(op &   ~0x3f));
 832     assert(s16 <=    32767 && s16 >= -32768);           s16 &= 0xffff;
 833     assert(!(rj &    ~0x1f));
 834     assert(!(rd &    ~0x1f));
 835     ii((op << 26) | (s16 << 10) | (rj << 5) | rd);
 836 }
 837
 838 static void
 839 _os20r(jit_state_t *_jit, jit_int32_t op, jit_int32_t s20, jit_int32_t rd)
 840 {
 841     assert(!(op &  ~0x7f));
 842     assert(s20 <= 524287 && s20 >= -524288);            s20 &= 0xfffff;
 843     assert(!(rd &  ~0x1f));
 844     ii((op << 25) | (s20 << 5) | rd);
 845 }
 846
 847 static void
 848 _orj21(jit_state_t *_jit, jit_int32_t op, jit_int32_t rj ,jit_int32_t j21)
 849 {
 850     assert(!(op  &   ~0x7f));
 851     assert(j21  <= 1048575 && j21 >= -1048576);         j21 &= 0x1fffff;
 852     assert(!(rj  &   ~0x1f));
 853     ii((op << 26) | ((j21 & 0xffff) << 10) | (rj << 5) | (j21 >> 16));
 854 }
 855
 856 static void
 857 _ou2u3j21(jit_state_t *_jit,
 858         jit_int32_t op, jit_int32_t u2, jit_int32_t u3, jit_int32_t j21)
 859 {
 860     assert(!(op  &     ~0x7f));
 861     assert(j21  <= 1048575 && j21 >= -1048576);         j21 &= 0x1fffff;
 862     assert(!(u2  &        ~3));
 863     assert(!(u3  &        ~7));
 864     ii((op << 26) | ((j21 & 0xffff) << 10) | (u2 << 8) | (u3 << 5) | (j21 >> 16));
 865 }
 866
 867 static void
 868 _oj16rr(jit_state_t *_jit,
 869         jit_int32_t op, jit_int32_t j16, jit_int32_t rj, jit_int32_t rd)
 870 {
 871     assert(!(op  &  ~0x7f));
 872     assert(j16  <=  32767 && j16 >= -32768);            j16 &= 0xffff;
 873     assert(!(rd  &  ~0x1f));
 874     assert(!(rj  &  ~0x1f));
 875     ii((op << 26) | (j16 << 10) | (rj << 5) | rd);
 876 }
 877
 878 static void
 879 _oj26(jit_state_t *_jit,  jit_int32_t op, jit_int32_t j26)
 880 {
 881     assert(!(op  &      ~0x7f));
 882     assert(j26 <= 33554431 && j26 >= -33554432);        j26 &= 0x3ffffff;
 883     ii((op << 26) | ((j26 & 0x1ffffff) << 10) | (j26 >> 16));
 884 }
 885
 886 static void
 887 _nop(jit_state_t *_jit, jit_int32_t i0)
 888 {
 889     for (; i0 > 0; i0 -= 4)
 890         NOP();
 891     assert(i0 == 0);
 892 }
 893
 894 static void
 895 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 896 {
 897     jit_int32_t         reg;
 898     reg = jit_get_reg(jit_class_gpr);
 899     MASKEQZ(rn(reg), r1, r2);
 900     MASKNEZ(r0, r0, r2);
 901     OR(r0, r0, rn(reg));
 902     jit_unget_reg(reg);
 903 }
 904
 905 static void
 906 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 907 {
 908     jit_int32_t         reg;
 909     reg = jit_get_reg(jit_class_gpr);
 910     MASKNEZ(rn(reg), r1, r2);
 911     MASKEQZ(r0, r0, r2);
 912     OR(r0, r0, rn(reg));
 913     jit_unget_reg(reg);
 914 }
 915
 916 static void
 917 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
 918       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
 919 {
 920     jit_int32_t         t0, r1_reg, iscasi;
 921     jit_word_t          retry, done, jump0, jump1;
 922     if ((iscasi = (r1 == _NOREG))) {
 923         r1_reg = jit_get_reg(jit_class_gpr);
 924         r1 = rn(r1_reg);
 925         movi(r1, i0);
 926     }
 927     t0 = jit_get_reg(jit_class_gpr);
 928     movi(r0, 0);                /* Assume will fail */
 929     DBAR(0);                    /* Barrier */
 930     retry = _jit->pc.w;
 931     LL_D(rn(t0), r1, 0);        /* Load current value */
 932     jump0 = _jit->pc.w;
 933     BNE(rn(t0), r2, 0);         /* If not equal, already done and r0 is zero */
 934     movr(r0, r3);               /* Make r0 an inout argument */
 935     SC_D(r0, r1, 0);            /* r0 is 0 if failed, 1 if succeed */
 936     jump1 = _jit->pc.w;
 937     BEQ(r0, _ZERO_REGNO, 0);
 938     /* FIXME Not certain what 0x700 hint means. Copied from C generated code */
 939     DBAR(0x700);
 940     done = _jit->pc.w;
 941     patch_at(jump0, done);
 942     patch_at(jump1, retry);
 943     jit_unget_reg(t0);
 944     if (iscasi)
 945         jit_unget_reg(r1_reg);
 946 }
 947
 948 static void
 949 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
 950 {
 951     if (r0 != r1)
 952         OR(r0, r1, _ZERO_REGNO);
 953 }
 954
 955 static void
 956 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 957 {
 958     if (i0 == 0)
 959         OR(r0, _ZERO_REGNO, _ZERO_REGNO);
 960     else if (can_sign_extend_si12_p(i0))
 961         ADDI_D(r0, _ZERO_REGNO, i0);
 962     else if (!(i0 & 0xffff) && can_sign_extend_si16_p(i0 >> 16))
 963         ADDU16I_D(r0, _ZERO_REGNO, i0 >> 16);
 964     else {
 965         jit_word_t              w = i0 - _jit->pc.w;
 966         /* If loading some constant reachable address */
 967         if (can_sign_extend_si32_p(w)) {
 968             jit_int32_t         lo = (jit_int32_t)w << 20 >> 20;
 969             jit_int32_t         hi = w - lo;
 970             PCADDU12I(r0, hi >> 12);
 971             if (lo)
 972                 ADDI_D(r0, r0, lo);
 973         }
 974         else {
 975             jit_int32_t     _00_11, _12_31, _32_51, _52_63;
 976             _00_11 =  i0        &   0xfff;
 977             _12_31 = (i0 >> 12) & 0xfffff;
 978             _32_51 = (i0 >> 32) & 0xfffff;
 979             _52_63 = (i0 >> 52) &   0xfff;
 980             if (_12_31) {
 981                 LU12I_W(r0, _12_31 << 12 >> 12);
 982                 if (_00_11)
 983                     ORI(r0, r0, _00_11);
 984             }
 985             else
 986                 ORI(r0, _ZERO_REGNO, _00_11);
 987             if (_32_51 || (_12_31 & 0x80000))
 988                 LU32I_D(r0, _32_51 << 12 >> 12);
 989             if (_52_63 || (_12_31 & 0x80000) || (_32_51 & 0x80000))
 990                 LU52I_D(r0, r0, _52_63 << 20 >> 20);
 991         }
 992     }
 993 }
 994
 995 static jit_word_t
 996 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
 997 {
 998     jit_word_t          w;
 999     jit_int32_t _00_11, _12_31, _32_51, _52_63;
1000     _00_11 =  i0        &   0xfff;
1001     _12_31 = (i0 >> 12) & 0xfffff;
1002     _32_51 = (i0 >> 32) & 0xfffff;
1003     _52_63 = (i0 >> 52) &   0xfff;
1004     w = _jit->pc.w;
1005     LU12I_W(r0, _12_31 << 12 >> 12);
1006     ORI(r0, r0, _00_11);
1007     LU32I_D(r0, _32_51 << 12 >> 12);
1008     LU52I_D(r0, r0, _52_63 << 20 >> 20);
1009     return (w);
1010 }
1011
1012 static void
1013 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1014 {
1015     jit_int32_t         reg;
1016     if (i0 == 0)
1017         movr(r0, r1);
1018     else if (can_sign_extend_si12_p(i0))
1019         ADDI_D(r0, r1, i0);
1020     else if (!(i0 & 0xffff) && can_sign_extend_si16_p(i0 >> 16))
1021         ADDU16I_D(r0, r1, i0 >> 16);
1022     else {
1023         reg = jit_get_reg(jit_class_gpr);
1024         movi(rn(reg), i0);
1025         addr(r0, r1, rn(reg));
1026         jit_unget_reg(reg);
1027     }
1028 }
1029
1030 static void
1031 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1032 {
1033     jit_int32_t         t0;
1034     if (jit_carry == _NOREG)
1035         jit_carry = jit_get_reg(jit_class_gpr);
1036     if (r0 == r1) {
1037         t0 = jit_get_reg(jit_class_gpr);
1038         addr(rn(t0), r1, r2);
1039         SLTU(rn(jit_carry), rn(t0), r1);
1040         movr(r0, rn(t0));
1041         jit_unget_reg(t0);
1042     }
1043     else {
1044         addr(r0, r1, r2);
1045         SLTU(rn(jit_carry), r0, r1);
1046     }
1047 }
1048
1049 static void
1050 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1051 {
1052     jit_int32_t         t0;
1053     if (jit_carry == _NOREG)
1054         jit_carry = jit_get_reg(jit_class_gpr);
1055     t0 = jit_get_reg(jit_class_gpr);
1056     if (r0 == r1) {
1057         if (can_sign_extend_si12_p(i0))
1058             ADDI_D(rn(t0), r1, i0);
1059         else if (!(i0 & 0xffff) && can_sign_extend_si16_p(i0 >> 16))
1060             ADDU16I_D(rn(t0), r1, i0 >> 16);
1061         else {
1062             movi(rn(t0), i0);
1063             addr(rn(t0), r1, rn(t0));
1064         }
1065         SLTU(rn(jit_carry), rn(t0), r1);
1066         movr(r0, rn(t0));
1067     }
1068     else {
1069         if (can_sign_extend_si12_p(i0))
1070             ADDI_D(r0, r1, i0);
1071         else if (!(i0 & 0xffff) && can_sign_extend_si16_p(i0 >> 16))
1072             ADDU16I_D(r0, r1, i0 >> 16);
1073         else {
1074             movi(rn(t0), i0);
1075             addr(r0, r1, rn(t0));
1076         }
1077         SLTU(rn(jit_carry), r0, r1);
1078     }
1079     jit_unget_reg(t0);
1080 }
1081
1082 static void
1083 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1084 {
1085     jit_int32_t         t0;
1086     assert(jit_carry != _NOREG);
1087     t0 = jit_get_reg(jit_class_gpr);
1088     movr(rn(t0), rn(jit_carry));
1089     addcr(r0, r1, r2);
1090     addcr(r0, r0, rn(t0));
1091     jit_unget_reg(t0);
1092 }
1093
1094 static void
1095 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1096 {
1097     jit_int32_t         t0;
1098     assert(jit_carry != _NOREG);
1099     t0 = jit_get_reg(jit_class_gpr);
1100     movr(rn(t0), rn(jit_carry));
1101     addci(r0, r1, i0);
1102     addcr(r0, r0, rn(t0));
1103     jit_unget_reg(t0);
1104 }
1105
1106 static void
1107 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1108 {
1109     jit_int32_t         reg;
1110     if (i0 == 0)
1111         movr(r0, r1);
1112     else if (can_sign_extend_si12_p(-i0))
1113         ADDI_D(r0, r1, -i0);
1114     else if (!(-i0 & 0xffff) && can_sign_extend_si16_p(-i0 >> 16))
1115         ADDU16I_D(r0, r1, -i0 >> 16);
1116     else {
1117         reg = jit_get_reg(jit_class_gpr);
1118         movi(rn(reg), i0);
1119         subr(r0, r1, rn(reg));
1120         jit_unget_reg(reg);
1121     }
1122 }
1123
1124 static void
1125 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1126 {
1127     jit_int32_t         t0;
1128     if (jit_carry == _NOREG)
1129         jit_carry = jit_get_reg(jit_class_gpr);
1130     if (r0 == r1) {
1131         t0 = jit_get_reg(jit_class_gpr);
1132         subr(rn(t0), r1, r2);
1133         SLTU(rn(jit_carry), r1, rn(t0));
1134         movr(r0, rn(t0));
1135         jit_unget_reg(t0);
1136     }
1137     else {
1138         subr(r0, r1, r2);
1139         SLTU(rn(jit_carry), r1, r0);
1140     }
1141 }
1142
1143 static void
1144 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1145 {
1146     jit_int32_t         t0;
1147     if (jit_carry == _NOREG)
1148         jit_carry = jit_get_reg(jit_class_gpr);
1149     t0 = jit_get_reg(jit_class_gpr);
1150     if (r0 == r1) {
1151         if (can_sign_extend_si12_p(-i0))
1152             ADDI_D(rn(t0), r1, -i0);
1153         else if (!(-i0 & 0xffff) && can_sign_extend_si16_p(-i0 >> 16))
1154             ADDU16I_D(rn(t0), r1, -i0 >> 16);
1155         else {
1156             movi(rn(t0), i0);
1157             subr(rn(t0), r1, rn(t0));
1158         }
1159         SLTU(rn(jit_carry), r1, rn(t0));
1160         movr(r0, rn(t0));
1161     }
1162     else {
1163         if (can_sign_extend_si12_p(-i0))
1164             ADDI_D(r0, r1, -i0);
1165         else if (!(-i0 & 0xffff) && can_sign_extend_si16_p(-i0 >> 16))
1166             ADDU16I_D(r0, r1, -i0 >> 16);
1167         else {
1168             movi(rn(t0), i0);
1169             subr(r0, r1, rn(t0));
1170         }
1171         SLTU(rn(jit_carry), r1, r0);
1172     }
1173     jit_unget_reg(t0);
1174 }
1175
1176 static void
1177 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1178 {
1179     jit_int32_t         t0;
1180     assert(jit_carry != _NOREG);
1181     t0 = jit_get_reg(jit_class_gpr);
1182     movr(rn(t0), rn(jit_carry));
1183     subcr(r0, r1, r2);
1184     subcr(r0, r0, rn(t0));
1185     jit_unget_reg(t0);
1186 }
1187
1188 static void
1189 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1190 {
1191     jit_int32_t         t0;
1192     assert(jit_carry != _NOREG);
1193     t0 = jit_get_reg(jit_class_gpr);
1194     movr(rn(t0), rn(jit_carry));
1195     subci(r0, r1, i0);
1196     subcr(r0, r0, rn(t0));
1197     jit_unget_reg(t0);
1198 }
1199
1200 static void
1201 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1202 {
1203     subi(r0, r1, i0);
1204     negr(r0, r0);
1205 }
1206
1207 static void
1208 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1209 {
1210     jit_int32_t         reg;
1211     reg = jit_get_reg(jit_class_gpr);
1212     movi(rn(reg), i0);
1213     mulr(r0, r1, rn(reg));
1214     jit_unget_reg(reg);
1215 }
1216
1217 static void
1218 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1219         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1220 {
1221     jit_int32_t         t0;
1222     if (r0 == r2 || r0 == r3) {
1223         t0 = jit_get_reg(jit_class_gpr);
1224         mulr(rn(t0), r2, r3);
1225     }
1226     else
1227         mulr(r0, r2, r3);
1228     if (sign)
1229         MULH_D(r1, r2, r3);
1230     else
1231         MULH_DU(r1, r2, r3);
1232     if (r0 == r2 || r0 == r3) {
1233         movr(r0, rn(t0));
1234         jit_unget_reg(t0);
1235     }
1236 }
1237
1238 static void
1239 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1240         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1241 {
1242     jit_int32_t         reg;
1243     reg = jit_get_reg(jit_class_gpr);
1244     movi(rn(reg), i0);
1245     iqmulr(r0, r1, r2, rn(reg), sign);
1246     jit_unget_reg(reg);
1247 }
1248
1249 static void
1250 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1251 {
1252     jit_int32_t         reg;
1253     reg = jit_get_reg(jit_class_gpr);
1254     movi(rn(reg), i0);
1255     divr(r0, r1, rn(reg));
1256     jit_unget_reg(reg);
1257 }
1258
1259 static void
1260 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1261 {
1262     jit_int32_t         reg;
1263     reg = jit_get_reg(jit_class_gpr);
1264     movi(rn(reg), i0);
1265     divr_u(r0, r1, rn(reg));
1266     jit_unget_reg(reg);
1267 }
1268
1269 static void
1270 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1271         jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1272 {
1273     jit_int32_t         t0;
1274     if (r0 == r2 || r0 == r3)
1275         t0 = jit_get_reg(jit_class_gpr);
1276     else
1277         t0 = _NOREG;
1278     if (sign) {
1279         if (t0 == _NOREG)
1280             DIV_D(r0, r2, r3);
1281         else
1282             DIV_D(rn(t0), r2, r3);
1283         MOD_D(r1, r2, r3);
1284     }
1285     else {
1286         if (t0 == _NOREG)
1287             DIV_DU(r0, r2, r3);
1288         else
1289             DIV_DU(rn(t0), r2, r3);
1290         MOD_DU(r1, r2, r3);
1291     }
1292     if (t0 != _NOREG) {
1293         movr(r0, rn(t0));
1294         jit_unget_reg(t0);
1295     }
1296 }
1297
1298 static void
1299 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1300         jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1301 {
1302     jit_int32_t         reg;
1303     reg = jit_get_reg(jit_class_gpr);
1304     movi(rn(reg), i0);
1305     iqdivr(r0, r1, r2, rn(reg), sign);
1306     jit_unget_reg(reg);
1307 }
1308
1309 static void
1310 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1311 {
1312     jit_int32_t         reg;
1313     reg = jit_get_reg(jit_class_gpr);
1314     movi(rn(reg), i0);
1315     remr(r0, r1, rn(reg));
1316     jit_unget_reg(reg);
1317 }
1318
1319 static void
1320 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1321 {
1322     jit_int32_t         reg;
1323     reg = jit_get_reg(jit_class_gpr);
1324     movi(rn(reg), i0);
1325     remr_u(r0, r1, rn(reg));
1326     jit_unget_reg(reg);
1327 }
1328
1329 static void
1330 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1331 {
1332     jit_int32_t         reg;
1333     if (can_zero_extend_u12_p(i0))
1334         ANDI(r0, r1, i0);
1335     else {
1336         reg = jit_get_reg(jit_class_gpr);
1337         movi(rn(reg), i0);
1338         AND(r0, r1, rn(reg));
1339         jit_unget_reg(reg);
1340     }
1341 }
1342
1343 static void
1344 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1345 {
1346     jit_int32_t         reg;
1347     if (can_zero_extend_u12_p(i0))
1348         ORI(r0, r1, i0);
1349     else {
1350         reg = jit_get_reg(jit_class_gpr);
1351         movi(rn(reg), i0);
1352         OR(r0, r1, rn(reg));
1353         jit_unget_reg(reg);
1354     }
1355 }
1356
1357 static void
1358 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1359 {
1360     jit_int32_t         reg;
1361     if (can_zero_extend_u12_p(i0))
1362         XORI(r0, r1, i0);
1363     else {
1364         reg = jit_get_reg(jit_class_gpr);
1365         movi(rn(reg), i0);
1366         XOR(r0, r1, rn(reg));
1367         jit_unget_reg(reg);
1368     }
1369 }
1370
1371 static void
1372 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1373 {
1374     jit_int32_t         reg;
1375     if (can_sign_extend_si12_p(i0))
1376         LD_B(r0, _ZERO_REGNO, i0);
1377     else {
1378         reg = jit_get_reg(jit_class_gpr);
1379         movi(rn(reg), i0);
1380         LD_B(r0, rn(reg), 0);
1381         jit_unget_reg(reg);
1382     }
1383 }
1384
1385 static void
1386 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1387 {
1388     jit_int32_t         reg;
1389     if (can_sign_extend_si12_p(i0))
1390         LD_BU(r0, _ZERO_REGNO, i0);
1391     else {
1392         reg = jit_get_reg(jit_class_gpr);
1393         movi(rn(reg), i0);
1394         LD_BU(r0, rn(reg), 0);
1395         jit_unget_reg(reg);
1396     }
1397 }
1398
1399 static void
1400 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1401 {
1402     jit_int32_t         reg;
1403     if (can_sign_extend_si12_p(i0))
1404         LD_H(r0, _ZERO_REGNO, i0);
1405     else {
1406         reg = jit_get_reg(jit_class_gpr);
1407         movi(rn(reg), i0);
1408         LD_H(r0, rn(reg), 0);
1409         jit_unget_reg(reg);
1410     }
1411 }
1412
1413 static void
1414 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1415 {
1416     jit_int32_t         reg;
1417     if (can_sign_extend_si12_p(i0))
1418         LD_HU(r0, _ZERO_REGNO, i0);
1419     else {
1420         reg = jit_get_reg(jit_class_gpr);
1421         movi(rn(reg), i0);
1422         LD_HU(r0, rn(reg), 0);
1423         jit_unget_reg(reg);
1424     }
1425 }
1426
1427 static void
1428 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1429 {
1430     jit_int32_t         reg;
1431     if (can_sign_extend_si12_p(i0))
1432         LD_W(r0, _ZERO_REGNO, i0);
1433     else {
1434         reg = jit_get_reg(jit_class_gpr);
1435         movi(rn(reg), i0);
1436         LD_W(r0, rn(reg), 0);
1437         jit_unget_reg(reg);
1438     }
1439 }
1440
1441 static void
1442 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1443 {
1444     jit_int32_t         reg;
1445     if (can_sign_extend_si12_p(i0))
1446         LD_WU(r0, _ZERO_REGNO, i0);
1447     else {
1448         reg = jit_get_reg(jit_class_gpr);
1449         movi(rn(reg), i0);
1450         LD_WU(r0, rn(reg), 0);
1451         jit_unget_reg(reg);
1452     }
1453 }
1454
1455 static void
1456 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1457 {
1458     jit_int32_t         reg;
1459     if (can_sign_extend_si12_p(i0))
1460         LD_D(r0, _ZERO_REGNO, i0);
1461     else {
1462         reg = jit_get_reg(jit_class_gpr);
1463         movi(rn(reg), i0);
1464         LD_D(r0, rn(reg), 0);
1465         jit_unget_reg(reg);
1466     }
1467 }
1468
1469 static void
1470 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1471 {
1472     jit_int32_t         reg;
1473     if (can_sign_extend_si12_p(i0))
1474         LD_B(r0, r1, i0);
1475     else {
1476         reg = jit_get_reg(jit_class_gpr);
1477         movi(rn(reg), i0);
1478         LDX_B(r0, r1, rn(reg));
1479         jit_unget_reg(reg);
1480     }
1481 }
1482
1483 static void
1484 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1485 {
1486     jit_int32_t         reg;
1487     if (can_sign_extend_si12_p(i0))
1488         LD_BU(r0, r1, i0);
1489     else {
1490         reg = jit_get_reg(jit_class_gpr);
1491         movi(rn(reg), i0);
1492         LDX_BU(r0, r1, rn(reg));
1493         jit_unget_reg(reg);
1494     }
1495 }
1496
1497 static void
1498 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1499 {
1500     jit_int32_t         reg;
1501     if (can_sign_extend_si12_p(i0))
1502         LD_H(r0, r1, i0);
1503     else {
1504         reg = jit_get_reg(jit_class_gpr);
1505         movi(rn(reg), i0);
1506         LDX_H(r0, r1, rn(reg));
1507         jit_unget_reg(reg);
1508     }
1509 }
1510
1511 static void
1512 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1513 {
1514     jit_int32_t         reg;
1515     if (can_sign_extend_si12_p(i0))
1516         LD_HU(r0, r1, i0);
1517     else {
1518         reg = jit_get_reg(jit_class_gpr);
1519         movi(rn(reg), i0);
1520         LDX_HU(r0, r1, rn(reg));
1521         jit_unget_reg(reg);
1522     }
1523 }
1524
1525 static void
1526 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1527 {
1528     jit_int32_t         reg;
1529     if (can_sign_extend_si12_p(i0))
1530         LD_W(r0, r1, i0);
1531     else {
1532         reg = jit_get_reg(jit_class_gpr);
1533         movi(rn(reg), i0);
1534         LDX_W(r0, r1, rn(reg));
1535         jit_unget_reg(reg);
1536     }
1537 }
1538
1539 static void
1540 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1541 {
1542     jit_int32_t         reg;
1543     if (can_sign_extend_si12_p(i0))
1544         LD_WU(r0, r1, i0);
1545     else {
1546         reg = jit_get_reg(jit_class_gpr);
1547         movi(rn(reg), i0);
1548         LDX_WU(r0, r1, rn(reg));
1549         jit_unget_reg(reg);
1550     }
1551 }
1552
1553 static void
1554 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1555 {
1556     jit_int32_t         reg;
1557     if (can_sign_extend_si12_p(i0))
1558         LD_D(r0, r1, i0);
1559     else {
1560         reg = jit_get_reg(jit_class_gpr);
1561         movi(rn(reg), i0);
1562         LDX_D(r0, r1, rn(reg));
1563         jit_unget_reg(reg);
1564     }
1565 }
1566
1567 static void
1568 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1569 {
1570     jit_int32_t         reg;
1571     if (can_sign_extend_si12_p(i0))
1572         ST_B(r0, _ZERO_REGNO, i0);
1573     else {
1574         reg = jit_get_reg(jit_class_gpr);
1575         movi(rn(reg), i0);
1576         ST_B(r0, rn(reg), 0);
1577         jit_unget_reg(reg);
1578     }
1579 }
1580
1581 static void
1582 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1583 {
1584     jit_int32_t         reg;
1585     if (can_sign_extend_si12_p(i0))
1586         ST_H(r0, _ZERO_REGNO, i0);
1587     else {
1588         reg = jit_get_reg(jit_class_gpr);
1589         movi(rn(reg), i0);
1590         ST_H(r0, rn(reg), 0);
1591         jit_unget_reg(reg);
1592     }
1593 }
1594
1595 static void
1596 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1597 {
1598     jit_int32_t         reg;
1599     if (can_sign_extend_si12_p(i0))
1600         ST_W(r0, _ZERO_REGNO, i0);
1601     else {
1602         reg = jit_get_reg(jit_class_gpr);
1603         movi(rn(reg), i0);
1604         ST_W(r0, rn(reg), 0);
1605         jit_unget_reg(reg);
1606     }
1607 }
1608
1609 static void
1610 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1611 {
1612     jit_int32_t         reg;
1613     if (can_sign_extend_si12_p(i0))
1614         ST_D(r0, _ZERO_REGNO, i0);
1615     else {
1616         reg = jit_get_reg(jit_class_gpr);
1617         movi(rn(reg), i0);
1618         ST_D(r0, rn(reg), 0);
1619         jit_unget_reg(reg);
1620     }
1621 }
1622
1623 static void
1624 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1625 {
1626     jit_int32_t         reg;
1627     if (can_sign_extend_si12_p(i0))
1628         ST_B(r1, r0, i0);
1629     else {
1630         reg = jit_get_reg(jit_class_gpr);
1631         movi(rn(reg), i0);
1632         STX_B(r1, r0, rn(reg));
1633         jit_unget_reg(reg);
1634     }
1635 }
1636
1637 static void
1638 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1639 {
1640     jit_int32_t         reg;
1641     if (can_sign_extend_si12_p(i0))
1642         ST_H(r1, r0, i0);
1643     else {
1644         reg = jit_get_reg(jit_class_gpr);
1645         movi(rn(reg), i0);
1646         STX_H(r1, r0, rn(reg));
1647         jit_unget_reg(reg);
1648     }
1649 }
1650
1651 static void
1652 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1653 {
1654     jit_int32_t         reg;
1655     if (can_sign_extend_si12_p(i0))
1656         ST_W(r1, r0, i0);
1657     else {
1658         reg = jit_get_reg(jit_class_gpr);
1659         movi(rn(reg), i0);
1660         STX_W(r1, r0, rn(reg));
1661         jit_unget_reg(reg);
1662     }
1663 }
1664
1665 static void
1666 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1667 {
1668     jit_int32_t         reg;
1669     if (can_sign_extend_si12_p(i0))
1670         ST_D(r1, r0, i0);
1671     else {
1672         reg = jit_get_reg(jit_class_gpr);
1673         movi(rn(reg), i0);
1674         STX_D(r1, r0, rn(reg));
1675         jit_unget_reg(reg);
1676     }
1677 }
1678
1679 static void
1680 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1681 {
1682     REVB_2H(r0, r1);
1683     extr_us(r0, r0);
1684 }
1685
1686 static void
1687 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1688 {
1689     REVB_2W(r0, r1);
1690     extr_ui(r0, r0);
1691 }
1692
1693 static void
1694 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1695 {
1696     jit_int32_t         reg;
1697     if (can_sign_extend_si12_p(i0))
1698         SLTI(r0, r1, i0);
1699     else {
1700         reg = jit_get_reg(jit_class_gpr);
1701         movi(rn(reg), i0);
1702         ltr(r0, r1, rn(reg));
1703         jit_unget_reg(reg);
1704     }
1705 }
1706
1707 static void
1708 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1709 {
1710     jit_int32_t         reg;
1711     if (can_sign_extend_si12_p(i0))
1712         SLTUI(r0, r1, i0);
1713     else {
1714         reg = jit_get_reg(jit_class_gpr);
1715         movi(rn(reg), i0);
1716         ltr_u(r0, r1, rn(reg));
1717         jit_unget_reg(reg);
1718     }
1719 }
1720
1721 static void
1722 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1723 {
1724     SLT(r0, r2, r1);
1725     XORI(r0, r0, 1);
1726 }
1727
1728 static void
1729 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1730 {
1731     jit_int32_t         reg;
1732     if (can_sign_extend_si12_p(i0 + 1))
1733         SLTI(r0, r1, i0 + 1);
1734     else {
1735         reg = jit_get_reg(jit_class_gpr);
1736         movi(rn(reg), i0);
1737         ler(r0, r1, rn(reg));
1738         jit_unget_reg(reg);
1739     }
1740 }
1741
1742 static void
1743 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1744 {
1745     SLTU(r0, r2, r1);
1746     XORI(r0, r0, 1);
1747 }
1748
1749 static void
1750 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1751 {
1752     jit_int32_t         reg;
1753     if (can_sign_extend_si12_p(i0 + 1))
1754         SLTUI(r0, r1, i0 + 1);
1755     else {
1756         reg = jit_get_reg(jit_class_gpr);
1757         movi(rn(reg), i0);
1758         ler_u(r0, r1, rn(reg));
1759         jit_unget_reg(reg);
1760     }
1761 }
1762
1763 static void
1764 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1765 {
1766     subr(r0, r1, r2);
1767     SLTU(r0, _ZERO_REGNO, r0);
1768     XORI(r0, r0, 1);
1769 }
1770
1771 static void
1772 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1773 {
1774     if (i0) {
1775         subi(r0, r1, i0);
1776         SLTU(r0, _ZERO_REGNO, r0);
1777     }
1778     else
1779         SLTU(r0, _ZERO_REGNO, r1);
1780     XORI(r0, r0, 1);
1781 }
1782
1783 static void
1784 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1785 {
1786     SLT(r0, r1, r2);
1787     XORI(r0, r0, 1);
1788 }
1789
1790 static void
1791 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1792 {
1793     jit_int32_t         reg;
1794     if (can_sign_extend_si12_p(i0)) {
1795         SLTI(r0, r1, i0);
1796         XORI(r0, r0, 1);
1797     } else {
1798         reg = jit_get_reg(jit_class_gpr);
1799         movi(rn(reg), i0);
1800         ger(r0, r1, rn(reg));
1801         jit_unget_reg(reg);
1802     }
1803 }
1804
1805 static void
1806 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1807 {
1808     SLTU(r0, r1, r2);
1809     XORI(r0, r0, 1);
1810 }
1811
1812 static void
1813 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1814 {
1815     jit_int32_t         reg;
1816     if (can_sign_extend_si12_p(i0)) {
1817         SLTUI(r0, r1, i0);
1818         XORI(r0, r0, 1);
1819     } else {
1820         reg = jit_get_reg(jit_class_gpr);
1821         movi(rn(reg), i0);
1822         ger_u(r0, r1, rn(reg));
1823         jit_unget_reg(reg);
1824     }
1825 }
1826
1827 static void
1828 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1829 {
1830     jit_int32_t         reg;
1831     if (i0 == 0)
1832         SLT(r0, _ZERO_REGNO, r1);
1833     else {
1834         reg = jit_get_reg(jit_class_gpr);
1835         movi(rn(reg), i0);
1836         SLT(r0, rn(reg), r1);
1837         jit_unget_reg(reg);
1838     }
1839 }
1840
1841 static void
1842 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1843 {
1844     jit_int32_t         reg;
1845     if (i0 == 0)
1846         SLTU(r0, _ZERO_REGNO, r1);
1847     else {
1848         reg = jit_get_reg(jit_class_gpr);
1849         movi(rn(reg), i0);
1850         SLTU(r0, rn(reg), r1);
1851         jit_unget_reg(reg);
1852     }
1853 }
1854
1855 static void
1856 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1857 {
1858     subr(r0, r1, r2);
1859     SLTU(r0, _ZERO_REGNO, r0);
1860 }
1861
1862 static void
1863 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1864 {
1865     if (i0) {
1866         subi(r0, r1, i0);
1867         SLTU(r0, _ZERO_REGNO, r0);
1868     }
1869     else
1870         SLTU(r0, _ZERO_REGNO, r1);
1871 }
1872
1873 static jit_word_t
1874 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1875 {
1876     jit_word_t          w;
1877     w = _jit->pc.w;
1878     BLT(r0, r1, (i0 - w) >> 2);
1879     return (w);
1880 }
1881
1882 static jit_word_t
1883 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1884 {
1885     jit_word_t          w;
1886     jit_int32_t         reg;
1887     if (i1 == 0) {
1888         w = _jit->pc.w;
1889         BLT(r0, _ZERO_REGNO, (i0 - w) >> 2);
1890     }
1891     if (i1) {
1892         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1893         movi(rn(reg), i1);
1894         w = _jit->pc.w;
1895         BLT(r0, rn(reg), (i0 - w) >> 2);
1896         jit_unget_reg(reg);
1897     }
1898     return (w);
1899 }
1900
1901 static jit_word_t
1902 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1903 {
1904     jit_word_t          w;
1905     w = _jit->pc.w;
1906     BLTU(r0, r1, (i0 - w) >> 2);
1907     return (w);
1908 }
1909
1910 static jit_word_t
1911 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1912 {
1913     jit_word_t          w;
1914     jit_int32_t         reg;
1915     if (i1 == 0)
1916         w = bltr_u(i0, r0, _ZERO_REGNO);
1917     else {
1918         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1919         movi(rn(reg), i1);
1920         w = _jit->pc.w;
1921         BLTU(r0, rn(reg), (i0 - w) >> 2);
1922         jit_unget_reg(reg);
1923     }
1924     return (w);
1925 }
1926
1927 static jit_word_t
1928 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1929 {
1930     jit_word_t          w;
1931     jit_int32_t         reg;
1932     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1933     SLT(rn(reg), r1, r0);
1934     w = _jit->pc.w;
1935     BEQZ(rn(reg), (i0 - w) >> 2);
1936     jit_unget_reg(reg);
1937     return (w);
1938 }
1939
1940 static jit_word_t
1941 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1942 {
1943     jit_word_t          w;
1944     jit_int32_t         reg;
1945     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1946     movi(rn(reg), i1);
1947     w = bler(i0, r0, rn(reg));
1948     jit_unget_reg(reg);
1949     return (w);
1950 }
1951
1952 static jit_word_t
1953 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1954 {
1955     jit_word_t          w;
1956     jit_int32_t         reg;
1957     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1958     SLTU(rn(reg), r1, r0);
1959     w = _jit->pc.w;
1960     BEQZ(rn(reg), (i0 - w) >> 2);
1961     jit_unget_reg(reg);
1962     return (w);
1963 }
1964
1965 static jit_word_t
1966 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1967 {
1968     jit_word_t          w;
1969     jit_int32_t         reg;
1970     if (i1 == 0)
1971         w = bler_u(i0, r0, _ZERO_REGNO);
1972     else {
1973         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1974         movi(rn(reg), i1);
1975         w = bler_u(i0, r0, rn(reg));
1976         jit_unget_reg(reg);
1977     }
1978     return (w);
1979 }
1980
1981 static jit_word_t
1982 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1983 {
1984     jit_word_t          w;
1985     w = _jit->pc.w;
1986     BEQ(r0, r1, (i0 - w) >> 2);
1987     return (w);
1988 }
1989
1990 static jit_word_t
1991 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1992 {
1993     jit_word_t          w;
1994     jit_int32_t         reg;
1995     if (i1 == 0) {
1996         w = _jit->pc.w;
1997         BEQZ(r0, (i0 - w) >> 2);
1998     }
1999     else {
2000         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2001         movi(rn(reg), i1);
2002         w = beqr(i0, r0, rn(reg));
2003         jit_unget_reg(reg);
2004     }
2005     return (w);
2006 }
2007
2008 static jit_word_t
2009 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2010 {
2011     jit_word_t          w;
2012     w = _jit->pc.w;
2013     BGE(r0, r1, (i0 - w) >> 2);
2014     return (w);
2015 }
2016
2017 static jit_word_t
2018 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2019 {
2020    jit_word_t           w;
2021     jit_int32_t         reg;
2022     if (i1 == 0)
2023         w = bger(i0, r0, _ZERO_REGNO);
2024     else {
2025         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2026         movi(rn(reg), i1);
2027         w = bger(i0, r0, rn(reg));
2028         jit_unget_reg(reg);
2029     }
2030     return (w);
2031 }
2032
2033 static jit_word_t
2034 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2035 {
2036     jit_word_t          w;
2037     w = _jit->pc.w;
2038     BGEU(r0, r1, (i0 - w) >> 2);
2039     return (w);
2040 }
2041
2042 static jit_word_t
2043 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2044 {
2045    jit_word_t           w;
2046     jit_int32_t         reg;
2047     if (i1 == 0) {
2048         w = _jit->pc.w;
2049         B((i0 - w) >> 2);
2050     }
2051     else {
2052         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2053         movi(rn(reg), i1);
2054         w = bger_u(i0, r0, rn(reg));
2055         jit_unget_reg(reg);
2056     }
2057     return (w);
2058 }
2059
2060 static jit_word_t
2061 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2062 {
2063     jit_word_t          w;
2064     jit_int32_t         reg;
2065     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2066     SLT(rn(reg), r1, r0);
2067     w = _jit->pc.w;
2068     BNEZ(rn(reg), (i0 - w) >> 2);
2069     jit_unget_reg(reg);
2070     return (w);
2071 }
2072
2073 static jit_word_t
2074 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2075 {
2076     jit_word_t          w;
2077     jit_int32_t         reg;
2078     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2079     movi(rn(reg), i1);
2080     w = bgtr(i0, r0, rn(reg));
2081     jit_unget_reg(reg);
2082     return (w);
2083 }
2084
2085 static jit_word_t
2086 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2087 {
2088     jit_word_t          w;
2089     jit_int32_t         reg;
2090     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2091     SLTU(rn(reg), r1, r0);
2092     w = _jit->pc.w;
2093     BNEZ(rn(reg), (i0 - w) >> 2);
2094     jit_unget_reg(reg);
2095     return (w);
2096 }
2097
2098 static jit_word_t
2099 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2100 {
2101     jit_word_t          w;
2102     jit_int32_t         reg;
2103     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2104     movi(rn(reg), i1);
2105     w = bgtr_u(i0, r0, rn(reg));
2106     jit_unget_reg(reg);
2107     return (w);
2108 }
2109
2110 static jit_word_t
2111 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2112 {
2113     jit_word_t          w;
2114     w = _jit->pc.w;
2115     BNE(r0, r1, (i0 - w) >> 2);
2116     return (w);
2117 }
2118
2119 static jit_word_t
2120 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2121 {
2122     jit_word_t          w;
2123     jit_int32_t         reg;
2124     if (i1 == 0) {
2125         w = _jit->pc.w;
2126         BNEZ(r0, (i0 - w) >> 2);
2127     }
2128     else {
2129         reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2130         movi(rn(reg), i1);
2131         w = bner(i0, r0, rn(reg));
2132         jit_unget_reg(reg);
2133     }
2134     return (w);
2135 }
2136
2137 static void
2138 _jmpi(jit_state_t *_jit, jit_word_t i0)
2139 {
2140     jit_word_t          w;
2141     w = (i0 - _jit->pc.w) >> 2;
2142     if (can_sign_extend_si26_p(i0))
2143         B(w);
2144     else
2145         (void)jmpi_p(i0);
2146 }
2147
2148 static jit_word_t
2149 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2150 {
2151     jit_word_t          w;
2152     jit_int32_t         reg;
2153     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2154     w = movi_p(rn(reg), i0);
2155     jmpr(rn(reg));
2156     jit_unget_reg(reg);
2157     return (w);
2158 }
2159
2160 static jit_word_t
2161 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2162 {
2163     jit_word_t          w, b;
2164     jit_int32_t         t0, t1;
2165     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2166     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2167     /* t0 = r1 < 0; */
2168     SLT(rn(t0), r1, _ZERO_REGNO);
2169     /* t1 = r0 */
2170     movr(rn(t1), r0);
2171     /* r0 = r0 + r1 */
2172     addr(r0, r0, r1);
2173     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
2174     w = _jit->pc.w;
2175     BNEZ(rn(t0), 0);
2176     /* r1 >= 0 */
2177     SLT(rn(t1), r0, rn(t1));
2178     b = _jit->pc.w;
2179     B(0);
2180     /* r1 < 0 */
2181     patch_at(w, _jit->pc.w);
2182     SLT(rn(t1), rn(t1), r0);
2183     /**/
2184     patch_at(b, _jit->pc.w);
2185     w = _jit->pc.w;
2186     BNEZ(rn(t1), (i0 - w) >> 2);
2187     jit_unget_reg(t1);
2188     jit_unget_reg(t0);
2189     return (w);
2190 }
2191
2192 static jit_word_t
2193 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2194 {
2195     jit_word_t          w;
2196     jit_int32_t         t0;
2197     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2198     movi(rn(t0), i1);
2199     w = boaddr(i0, r0, rn(t0));
2200     jit_unget_reg(t0);
2201     return (w);
2202 }
2203
2204 static jit_word_t
2205 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2206 {
2207     jit_word_t          w;
2208     jit_int32_t         t0, t1;
2209     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2210     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2211     addr(rn(t0), r0, r1);
2212     SLTU(rn(t1), rn(t0), r0);
2213     movr(r0, rn(t0));
2214     w = _jit->pc.w;
2215     BNEZ(rn(t1), (i0 - w) >> 2);
2216     jit_unget_reg(t1);
2217     jit_unget_reg(t0);
2218     return (w);
2219 }
2220
2221 static jit_word_t
2222 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2223 {
2224     jit_word_t          w;
2225     jit_int32_t         t0;
2226     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2227     movi(rn(t0), i1);
2228     w = boaddr_u(i0, r0, rn(t0));
2229     jit_unget_reg(t0);
2230     return (w);
2231 }
2232
2233 static jit_word_t
2234 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2235 {
2236     jit_word_t          w, b;
2237     jit_int32_t         t0, t1;
2238     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2239     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2240     /* t0 = r1 < 0; */
2241     SLT(rn(t0), r1, _ZERO_REGNO);
2242     /* t1 = r0 */
2243     movr(rn(t1), r0);
2244     /* r0 = r0 + r1 */
2245     addr(r0, r0, r1);
2246     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
2247     w = _jit->pc.w;
2248     BNEZ(rn(t0), 0);
2249     /* r1 >= 0 */
2250     SLT(rn(t1), r0, rn(t1));
2251     b = _jit->pc.w;
2252     B(0);
2253     /* r1 < 0 */
2254     patch_at(w, _jit->pc.w);
2255     SLT(rn(t1), rn(t1), r0);
2256     /**/
2257     patch_at(b, _jit->pc.w);
2258     w = _jit->pc.w;
2259     BEQZ(rn(t1), (i0 - w) >> 2);
2260     jit_unget_reg(t1);
2261     jit_unget_reg(t0);
2262     return (w);
2263 }
2264
2265 static jit_word_t
2266 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2267 {
2268     jit_word_t          w;
2269     jit_int32_t         t0;
2270     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2271     movi(rn(t0), i1);
2272     w = bxaddr(i0, r0, rn(t0));
2273     jit_unget_reg(t0);
2274     return (w);
2275 }
2276
2277 static jit_word_t
2278 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2279 {
2280     jit_word_t          w;
2281     jit_int32_t         t0, t1;
2282     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2283     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2284     addr(rn(t0), r0, r1);
2285     SLTU(rn(t1), rn(t0), r0);
2286     movr(r0, rn(t0));
2287     w = _jit->pc.w;
2288     BEQZ(rn(t1), (i0 - w) >> 2);
2289     jit_unget_reg(t1);
2290     jit_unget_reg(t0);
2291     return (w);
2292 }
2293
2294 static jit_word_t
2295 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2296 {
2297     jit_word_t          w;
2298     jit_int32_t         t0;
2299     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2300     movi(rn(t0), i1);
2301     w = bxaddr_u(i0, r0, rn(t0));
2302     jit_unget_reg(t0);
2303     return (w);
2304 }
2305
2306 static jit_word_t
2307 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2308 {
2309     jit_word_t          w, b;
2310     jit_int32_t         t0, t1;
2311     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2312     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2313     /* t0 = 0 < r1; */
2314     SLT(rn(t0), _ZERO_REGNO, r1);
2315     /* t1 = r0 */
2316     movr(rn(t1), r0);
2317     /* r0 = r0 - r1 */
2318     subr(r0, r0, r1);
2319     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
2320     w = _jit->pc.w;
2321     BNE(rn(t0), _ZERO_REGNO, 0);
2322     /* r1 >= 0 */
2323     SLT(rn(t1), r0, rn(t1));
2324     b = _jit->pc.w;
2325     B(0);
2326     /* r1 < 0 */
2327     patch_at(w, _jit->pc.w);
2328     SLT(rn(t1), rn(t1), r0);
2329     /**/
2330     patch_at(b, _jit->pc.w);
2331     w = _jit->pc.w;
2332     BNEZ(rn(t1), (i0 - w) >> 2);
2333     jit_unget_reg(t1);
2334     jit_unget_reg(t0);
2335     return (w);
2336 }
2337
2338 static jit_word_t
2339 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2340 {
2341     jit_word_t          w;
2342     jit_int32_t         t0;
2343     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2344     movi(rn(t0), i1);
2345     w = bosubr(i0, r0, rn(t0));
2346     jit_unget_reg(t0);
2347     return (w);
2348 }
2349
2350 static jit_word_t
2351 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2352 {
2353     jit_word_t          w;
2354     jit_int32_t         t0, t1;
2355     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2356     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2357     subr(rn(t0), r0, r1);
2358     SLTU(rn(t1), r0, rn(t0));
2359     movr(r0, rn(t0));
2360     w = _jit->pc.w;
2361     BNEZ(rn(t1), (i0 - w) >> 2);
2362     jit_unget_reg(t1);
2363     jit_unget_reg(t0);
2364     return (w);
2365 }
2366
2367 static jit_word_t
2368 _bosubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2369 {
2370     jit_word_t          w;
2371     jit_int32_t         t0;
2372     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2373     movi(rn(t0), i0);
2374     w = bosubr_u(br, r0, rn(t0));
2375     jit_unget_reg(t0);
2376     return (w);
2377 }
2378
2379 static jit_word_t
2380 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2381 {
2382     jit_word_t          w, b;
2383     jit_int32_t         t0, t1;
2384     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2385     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2386     /* t0 = r1 < 0; */
2387     SLT(rn(t0), _ZERO_REGNO, r1);
2388     /* t1 = r0 */
2389     movr(rn(t1), r0);
2390     /* r0 = r0 - r1 */
2391     subr(r0, r0, r1);
2392     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
2393     w = _jit->pc.w;
2394     BNEZ(rn(t0), 0);
2395     /* r1 >= 0 */
2396     SLT(rn(t1), r0, rn(t1));
2397     b = _jit->pc.w;
2398     B(0);
2399     /* r1 < 0 */
2400     patch_at(w, _jit->pc.w);
2401     SLT(rn(t1), rn(t1), r0);
2402     /**/
2403     patch_at(b, _jit->pc.w);
2404     w = _jit->pc.w;
2405     BEQZ(rn(t1), (i0 - w) >> 2);
2406     jit_unget_reg(t1);
2407     jit_unget_reg(t0);
2408     return (w);
2409 }
2410
2411 static jit_word_t
2412 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2413 {
2414     jit_word_t          w;
2415     jit_int32_t         t0;
2416     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2417     movi(rn(t0), i1);
2418     w = bxsubr(i0, r0, rn(t0));
2419     jit_unget_reg(t0);
2420     return (w);
2421 }
2422
2423 static jit_word_t
2424 _bxsubr_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, t1;
2428     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2429     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2430     subr(rn(t0), r0, r1);
2431     SLTU(rn(t1), r0, rn(t0));
2432     movr(r0, rn(t0));
2433     w = _jit->pc.w;
2434     BEQZ(rn(t1), (i0 - w) >> 2);
2435     jit_unget_reg(t1);
2436     jit_unget_reg(t0);
2437     return (w);
2438 }
2439
2440 static jit_word_t
2441 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2442 {
2443     jit_word_t          w;
2444     jit_int32_t         t0;
2445     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2446     movi(rn(t0), i1);
2447     w = bxsubr_u(i0, r0, rn(t0));
2448     jit_unget_reg(t0);
2449     return (w);
2450 }
2451
2452 static jit_word_t
2453 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2454 {
2455     jit_word_t          w;
2456     jit_int32_t         t0;
2457     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2458     AND(rn(t0), r0, r1);
2459     w = _jit->pc.w;
2460     BNEZ(rn(t0), (i0 - w) >> 2);
2461     jit_unget_reg(t0);
2462     return (w);
2463 }
2464
2465 static jit_word_t
2466 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2467 {
2468     jit_word_t          w;
2469     jit_int32_t         t0;
2470     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2471     andi(rn(t0), r0, i1);
2472     w = _jit->pc.w;
2473     BNEZ(rn(t0), (i0 - w) >> 2);
2474     jit_unget_reg(t0);
2475     return (w);
2476 }
2477
2478 static jit_word_t
2479 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2480 {
2481     jit_word_t          w;
2482     jit_int32_t         t0;
2483     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2484     AND(rn(t0), r0, r1);
2485     w = _jit->pc.w;
2486     BEQZ(rn(t0), (i0 - w) >> 2);
2487     jit_unget_reg(t0);
2488     return (w);
2489 }
2490
2491 static jit_word_t
2492 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2493 {
2494     jit_word_t          w;
2495     jit_int32_t         t0;
2496     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2497     andi(rn(t0), r0, i1);
2498     w = _jit->pc.w;
2499     BEQZ(rn(t0), (i0 - w) >> 2);
2500     jit_unget_reg(t0);
2501     return (w);
2502 }
2503
2504 static void
2505 _calli(jit_state_t *_jit, jit_word_t i0)
2506 {
2507     jit_word_t          w;
2508     w = (i0 - _jit->pc.w) >> 2;
2509     if (can_sign_extend_si26_p(i0))
2510         BL(w);
2511     else
2512         (void)calli_p(i0);
2513 }
2514
2515 static jit_word_t
2516 _calli_p(jit_state_t *_jit, jit_word_t i0)
2517 {
2518     jit_word_t  w;
2519     jit_word_t  reg;
2520     reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2521     w = movi_p(rn(reg), i0);
2522     callr(rn(reg));
2523     jit_unget_reg(reg);
2524     return (w);
2525 }
2526
2527 static void
2528 _prolog(jit_state_t *_jit, jit_node_t *node)
2529 {
2530     jit_int32_t         reg;
2531     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2532         jit_int32_t     frame = -_jitc->function->frame;
2533         assert(_jitc->function->self.aoff >= frame);
2534         if (_jitc->function->assume_frame)
2535             return;
2536         _jitc->function->self.aoff = frame;
2537     }
2538     if (_jitc->function->allocar)
2539         _jitc->function->self.aoff &= -16;
2540     _jitc->function->stack = ((_jitc->function->self.alen -
2541                               /* align stack at 16 bytes */
2542                               _jitc->function->self.aoff) + 15) & -16;
2543     subi(_SP_REGNO, _SP_REGNO, stack_framesize);
2544     stxi(0, _SP_REGNO, _RA_REGNO);
2545     stxi(8, _SP_REGNO, _FP_REGNO);
2546     if (jit_regset_tstbit(&_jitc->function->regset, _S0))
2547         stxi(16, _SP_REGNO, rn(_S0));
2548     if (jit_regset_tstbit(&_jitc->function->regset, _S1))
2549         stxi(24, _SP_REGNO, rn(_S1));
2550     if (jit_regset_tstbit(&_jitc->function->regset, _S2))
2551         stxi(32, _SP_REGNO, rn(_S2));
2552     if (jit_regset_tstbit(&_jitc->function->regset, _S3))
2553         stxi(40, _SP_REGNO, rn(_S3));
2554     if (jit_regset_tstbit(&_jitc->function->regset, _S4))
2555         stxi(48, _SP_REGNO, rn(_S4));
2556     if (jit_regset_tstbit(&_jitc->function->regset, _S5))
2557         stxi(56, _SP_REGNO, rn(_S5));
2558     if (jit_regset_tstbit(&_jitc->function->regset, _S6))
2559         stxi(64, _SP_REGNO, rn(_S6));
2560     if (jit_regset_tstbit(&_jitc->function->regset, _S7))
2561         stxi(72, _SP_REGNO, rn(_S7));
2562     if (jit_regset_tstbit(&_jitc->function->regset, _S8))
2563         stxi(80, _SP_REGNO, rn(_S8));
2564     if (jit_regset_tstbit(&_jitc->function->regset, _FS0))
2565         stxi_d(88, _SP_REGNO, rn(_FS0));
2566     if (jit_regset_tstbit(&_jitc->function->regset, _FS1))
2567         stxi_d(96, _SP_REGNO, rn(_FS1));
2568     if (jit_regset_tstbit(&_jitc->function->regset, _FS2))
2569         stxi_d(104, _SP_REGNO, rn(_FS2));
2570     if (jit_regset_tstbit(&_jitc->function->regset, _FS3))
2571         stxi_d(112, _SP_REGNO, rn(_FS3));
2572     if (jit_regset_tstbit(&_jitc->function->regset, _FS4))
2573         stxi_d(120, _SP_REGNO, rn(_FS4));
2574     if (jit_regset_tstbit(&_jitc->function->regset, _FS5))
2575         stxi_d(128, _SP_REGNO, rn(_FS5));
2576     if (jit_regset_tstbit(&_jitc->function->regset, _FS6))
2577         stxi_d(136, _SP_REGNO, rn(_FS6));
2578     if (jit_regset_tstbit(&_jitc->function->regset, _FS7))
2579         stxi_d(144, _SP_REGNO, rn(_FS7));
2580     movr(_FP_REGNO, _SP_REGNO);
2581     if (_jitc->function->stack)
2582         subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
2583     if (_jitc->function->allocar) {
2584         reg = jit_get_reg(jit_class_gpr);
2585         movi(rn(reg), _jitc->function->self.aoff);
2586         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2587         jit_unget_reg(reg);
2588     }
2589     if (_jitc->function->self.call & jit_call_varargs) {
2590         for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2591             stxi(stack_framesize - ((8 - reg) * 8),
2592                  _FP_REGNO, rn(JIT_RA0 - reg));
2593     }
2594 }
2595
2596 static void
2597 _epilog(jit_state_t *_jit, jit_node_t *node)
2598 {
2599     if (_jitc->function->assume_frame)
2600         return;
2601     movr(_SP_REGNO, _FP_REGNO);
2602     ldxi(_RA_REGNO, _SP_REGNO, 0);
2603     ldxi(_FP_REGNO, _SP_REGNO, 8);
2604     if (jit_regset_tstbit(&_jitc->function->regset, _S0))
2605         ldxi(rn(_S0), _SP_REGNO, 16);
2606     if (jit_regset_tstbit(&_jitc->function->regset, _S1))
2607         ldxi(rn(_S1), _SP_REGNO, 24);
2608     if (jit_regset_tstbit(&_jitc->function->regset, _S2))
2609         ldxi(rn(_S2), _SP_REGNO, 32);
2610     if (jit_regset_tstbit(&_jitc->function->regset, _S3))
2611         ldxi(rn(_S3), _SP_REGNO, 40);
2612     if (jit_regset_tstbit(&_jitc->function->regset, _S4))
2613         ldxi(rn(_S4), _SP_REGNO, 48);
2614     if (jit_regset_tstbit(&_jitc->function->regset, _S5))
2615         ldxi(rn(_S5), _SP_REGNO, 56);
2616     if (jit_regset_tstbit(&_jitc->function->regset, _S6))
2617         ldxi(rn(_S6), _SP_REGNO, 64);
2618     if (jit_regset_tstbit(&_jitc->function->regset, _S7))
2619         ldxi(rn(_S7), _SP_REGNO, 72);
2620     if (jit_regset_tstbit(&_jitc->function->regset, _S8))
2621         ldxi(rn(_S8), _SP_REGNO, 80);
2622     if (jit_regset_tstbit(&_jitc->function->regset, _FS0))
2623         ldxi_d(rn(_FS0), _SP_REGNO, 88);
2624     if (jit_regset_tstbit(&_jitc->function->regset, _FS1))
2625         ldxi_d(rn(_FS1), _SP_REGNO, 96);
2626     if (jit_regset_tstbit(&_jitc->function->regset, _FS2))
2627         ldxi_d(rn(_FS2), _SP_REGNO, 104);
2628     if (jit_regset_tstbit(&_jitc->function->regset, _FS3))
2629         ldxi_d(rn(_FS3), _SP_REGNO, 112);
2630     if (jit_regset_tstbit(&_jitc->function->regset, _FS4))
2631         ldxi_d(rn(_FS4), _SP_REGNO, 120);
2632     if (jit_regset_tstbit(&_jitc->function->regset, _FS5))
2633         ldxi_d(rn(_FS5), _SP_REGNO, 128);
2634     if (jit_regset_tstbit(&_jitc->function->regset, _FS6))
2635         ldxi_d(rn(_FS6), _SP_REGNO, 136);
2636     if (jit_regset_tstbit(&_jitc->function->regset, _FS7))
2637         ldxi_d(rn(_FS7), _SP_REGNO, 144);
2638     addi(_SP_REGNO, _SP_REGNO, stack_framesize);
2639     JIRL(_ZERO_REGNO, _RA_REGNO, 0);
2640 }
2641
2642 static void
2643 _vastart(jit_state_t *_jit, jit_int32_t r0)
2644 {
2645     assert(_jitc->function->self.call & jit_call_varargs);
2646     /* Initialize va_list to the first stack argument. */
2647     if (jit_arg_reg_p(_jitc->function->vagp))
2648         addi(r0, _FP_REGNO, stack_framesize - ((8 - _jitc->function->vagp) * 8));
2649     else
2650         addi(r0, _FP_REGNO, _jitc->function->self.size);
2651 }
2652
2653 static void
2654 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2655 {
2656     assert(_jitc->function->self.call & jit_call_varargs);
2657     /* Load argument. */
2658     ldr(r0, r1);
2659     /* Update va_list. */
2660     addi(r1, r1, sizeof(jit_word_t));
2661 }
2662
2663 static void
2664 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2665 {
2666     jit_uint32_t         c;
2667     union {
2668         jit_uint32_t    *i;
2669         jit_word_t       w;
2670     } u;
2671     u.w = instr;
2672     c = u.i[0];
2673     /* movi_p? */
2674     if ((c >> 25) == 10) {                              /* LU12I_W */
2675         jit_int32_t     _00_11, _12_31, _32_51, _52_63;
2676         _00_11 =  label        &   0xfff;
2677         _12_31 = (label >> 12) & 0xfffff;
2678         _32_51 = (label >> 32) & 0xfffff;
2679         _52_63 = (label >> 52) &   0xfff;
2680         u.i[0] &= ~(0xfffff << 5);
2681         u.i[0] |= _12_31 << 5;
2682         assert((u.i[1] >> 22) == 14);                   /* ORI */
2683         u.i[1] &= ~(0xfff << 10);
2684         u.i[1] |= _00_11 << 10;
2685         assert((u.i[2] >> 25) == 11);                   /* LU32I_D */
2686         u.i[2] &= ~(0xfffff << 5);
2687         u.i[2] |= _32_51 << 5;
2688         assert((u.i[3] >> 22) == 12);                   /* LU52I_D */
2689         u.i[3] &= ~(0xfff << 10);
2690         u.i[3] |= _52_63 << 0;
2691     }
2692     else if ((c >> 26) >= 22 && (c >> 26) <= 27) {
2693         /* B{EQ,NE,LT,GE,LTU,GEU} */
2694         jit_word_t      disp = (label - instr) >> 2;
2695         assert(can_sign_extend_si16_p(disp));
2696         u.i[0] &= ~(0xffff << 10);
2697         u.i[0] |= (disp & 0xffff) << 10;
2698     }
2699     else if ((c >> 26) == 20 || (c >> 26) == 21) {      /* B or BL */
2700         jit_word_t disp = (label - instr) >> 2;
2701         assert(can_sign_extend_si26_p(disp));
2702         disp &= 0x3ffffff;
2703         u.i[0] &= ~0x3ffffff;
2704         u.i[0] |= ((disp & 0xffff) << 10) | (disp >> 16);
2705     }
2706     else if ((c >> 26) >= 16 && (c >> 26) <= 18) {      /* B{,C}{EQ,NE}Z */
2707         jit_word_t disp = (label - instr) >> 2;
2708         assert(can_sign_extend_si21_p(disp));
2709         disp &= 0x1fffff;
2710         u.i[0] &= ~((0xffff << 10) | 0x1f);
2711         u.i[0] |= ((disp & 0xffff) << 10) | (disp >> 16);
2712     }
2713     else
2714         abort();
2715 }
2716 #endif