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