deps/lightning/lib/jit_loongarch-cpu.c

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